b647c708b4
Chrome already starts with a blank page, so use that for the first target context instead of creating a new tab. Add the first version of the Targets API, which is useful to test this feature. Fixes #291.
157 lines
3.6 KiB
Go
157 lines
3.6 KiB
Go
package chromedp
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/chromedp/cdproto/css"
|
|
"github.com/chromedp/cdproto/dom"
|
|
"github.com/chromedp/cdproto/inspector"
|
|
"github.com/chromedp/cdproto/log"
|
|
"github.com/chromedp/cdproto/page"
|
|
"github.com/chromedp/cdproto/runtime"
|
|
"github.com/chromedp/cdproto/target"
|
|
)
|
|
|
|
// Context is attached to any context.Context which is valid for use with Run.
|
|
type Context struct {
|
|
Allocator Allocator
|
|
|
|
Browser *Browser
|
|
|
|
Target *Target
|
|
}
|
|
|
|
// NewContext creates a browser context using the parent context.
|
|
func NewContext(parent context.Context, opts ...ContextOption) (context.Context, context.CancelFunc) {
|
|
ctx, cancel := context.WithCancel(parent)
|
|
|
|
c := &Context{}
|
|
if pc := FromContext(parent); pc != nil {
|
|
c.Allocator = pc.Allocator
|
|
c.Browser = pc.Browser
|
|
// don't inherit SessionID, so that NewContext can be used to
|
|
// create a new tab on the same browser.
|
|
}
|
|
|
|
for _, o := range opts {
|
|
o(c)
|
|
}
|
|
if c.Allocator == nil {
|
|
WithExecAllocator(
|
|
NoFirstRun,
|
|
NoDefaultBrowserCheck,
|
|
Headless,
|
|
)(&c.Allocator)
|
|
}
|
|
|
|
ctx = context.WithValue(ctx, contextKey{}, c)
|
|
return ctx, cancel
|
|
}
|
|
|
|
type contextKey struct{}
|
|
|
|
// FromContext extracts the Context data stored inside a context.Context.
|
|
func FromContext(ctx context.Context) *Context {
|
|
c, _ := ctx.Value(contextKey{}).(*Context)
|
|
return c
|
|
}
|
|
|
|
// Run runs an action against the provided context. The provided context must
|
|
// contain a valid Allocator; typically, that will be created via NewContext or
|
|
// NewAllocator.
|
|
func Run(ctx context.Context, actions ...Action) error {
|
|
c := FromContext(ctx)
|
|
if c == nil || c.Allocator == nil {
|
|
return ErrInvalidContext
|
|
}
|
|
first := c.Browser == nil
|
|
if first {
|
|
browser, err := c.Allocator.Allocate(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.Browser = browser
|
|
}
|
|
if c.Target == nil {
|
|
if err := c.newSession(ctx, first); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return Tasks(actions).Do(ctx, c.Target)
|
|
}
|
|
|
|
func (c *Context) newSession(ctx context.Context, first bool) error {
|
|
var targetID target.ID
|
|
if first {
|
|
// If we just allocated this browser, and it has a single page
|
|
// that's blank and not attached, use it.
|
|
infos, err := target.GetTargets().Do(ctx, c.Browser)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
pages := 0
|
|
for _, info := range infos {
|
|
if info.Type == "page" && info.URL == "about:blank" && !info.Attached {
|
|
targetID = info.TargetID
|
|
pages++
|
|
}
|
|
}
|
|
if pages > 1 {
|
|
// Multiple blank pages; just in case, don't use any.
|
|
targetID = ""
|
|
}
|
|
}
|
|
|
|
if targetID == "" {
|
|
var err error
|
|
targetID, err = target.CreateTarget("about:blank").Do(ctx, c.Browser)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
sessionID, err := target.AttachToTarget(targetID).Do(ctx, c.Browser)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.Target = c.Browser.newExecutorForTarget(ctx, sessionID)
|
|
|
|
// enable domains
|
|
for _, enable := range []Action{
|
|
log.Enable(),
|
|
runtime.Enable(),
|
|
//network.Enable(),
|
|
inspector.Enable(),
|
|
page.Enable(),
|
|
dom.Enable(),
|
|
css.Enable(),
|
|
} {
|
|
if err := enable.Do(ctx, c.Target); err != nil {
|
|
return fmt.Errorf("unable to execute %T: %v", enable, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ContextOption func(*Context)
|
|
|
|
// Targets lists all the targets in the browser attached to the given context.
|
|
func Targets(ctx context.Context) ([]*target.Info, error) {
|
|
// Don't rely on Run, as that needs to be able to call Targets, and we
|
|
// don't want cyclic func calls.
|
|
|
|
c := FromContext(ctx)
|
|
if c == nil || c.Allocator == nil {
|
|
return nil, ErrInvalidContext
|
|
}
|
|
if c.Browser == nil {
|
|
browser, err := c.Allocator.Allocate(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
c.Browser = browser
|
|
}
|
|
return target.GetTargets().Do(ctx, c.Browser)
|
|
}
|