2017-01-24 15:09:23 +00:00
|
|
|
package chromedp
|
|
|
|
|
|
|
|
import (
|
2017-02-12 04:59:33 +00:00
|
|
|
"time"
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
"github.com/knq/chromedp/cdp"
|
2017-01-24 15:09:23 +00:00
|
|
|
"github.com/knq/chromedp/cdp/util"
|
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
2017-02-12 04:59:33 +00:00
|
|
|
// DefaultNewTargetTimeout is the default time to wait for a new target to
|
|
|
|
// be started.
|
|
|
|
DefaultNewTargetTimeout = 3 * time.Second
|
|
|
|
|
|
|
|
// DefaultCheckDuration is the default time to sleep between a check.
|
|
|
|
DefaultCheckDuration = 50 * time.Millisecond
|
|
|
|
|
|
|
|
// EmptyFrameID is the "non-existent" (ie current) frame.
|
|
|
|
EmptyFrameID cdp.FrameID = cdp.FrameID("")
|
2017-01-24 15:09:23 +00:00
|
|
|
|
2017-02-12 04:59:33 +00:00
|
|
|
// EmptyNodeID is the "non-existent" node id.
|
|
|
|
EmptyNodeID cdp.NodeID = cdp.NodeID(0)
|
2017-01-24 15:09:23 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// UnmarshalMessage unmarshals the message result or params.
|
2017-01-26 07:28:34 +00:00
|
|
|
func UnmarshalMessage(msg *cdp.Message) (interface{}, error) {
|
2017-01-24 15:09:23 +00:00
|
|
|
return util.UnmarshalMessage(msg)
|
|
|
|
}
|
|
|
|
|
|
|
|
// FrameOp is a frame manipulation operation.
|
2017-01-26 07:28:34 +00:00
|
|
|
type FrameOp func(*cdp.Frame)
|
2017-01-24 15:09:23 +00:00
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
/*func domContentEventFired(f *cdp.Frame) {
|
2017-01-24 15:09:23 +00:00
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func loadEventFired(f *cdp.Frame) {
|
2017-01-24 15:09:23 +00:00
|
|
|
}*/
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func frameAttached(id cdp.FrameID) FrameOp {
|
|
|
|
return func(f *cdp.Frame) {
|
2017-01-24 15:09:23 +00:00
|
|
|
f.ParentID = id
|
2017-01-26 07:28:34 +00:00
|
|
|
setFrameState(f, cdp.FrameAttached)
|
2017-01-24 15:09:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
/*func frameNavigated(f *cdp.Frame) {
|
|
|
|
setFrameState(f, cdp.FrameNavigated)
|
2017-01-24 15:09:23 +00:00
|
|
|
}*/
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func frameDetached(f *cdp.Frame) {
|
2017-02-12 04:59:33 +00:00
|
|
|
f.ParentID = EmptyFrameID
|
2017-01-26 07:28:34 +00:00
|
|
|
clearFrameState(f, cdp.FrameAttached)
|
2017-01-24 15:09:23 +00:00
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func frameStartedLoading(f *cdp.Frame) {
|
|
|
|
setFrameState(f, cdp.FrameLoading)
|
2017-01-24 15:09:23 +00:00
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func frameStoppedLoading(f *cdp.Frame) {
|
|
|
|
clearFrameState(f, cdp.FrameLoading)
|
2017-01-24 15:09:23 +00:00
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func frameScheduledNavigation(f *cdp.Frame) {
|
|
|
|
setFrameState(f, cdp.FrameScheduledNavigation)
|
2017-01-24 15:09:23 +00:00
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func frameClearedScheduledNavigation(f *cdp.Frame) {
|
|
|
|
clearFrameState(f, cdp.FrameScheduledNavigation)
|
2017-01-24 15:09:23 +00:00
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
/*func frameResized(f *cdp.Frame) {
|
2017-01-24 15:09:23 +00:00
|
|
|
// TODO
|
|
|
|
}*/
|
|
|
|
|
|
|
|
// setFrameState sets the frame state via bitwise or (|).
|
2017-01-26 07:28:34 +00:00
|
|
|
func setFrameState(f *cdp.Frame, fs cdp.FrameState) {
|
2017-01-24 15:09:23 +00:00
|
|
|
f.State |= fs
|
|
|
|
}
|
|
|
|
|
|
|
|
// clearFrameState clears the frame state via bit clear (&^).
|
2017-01-26 07:28:34 +00:00
|
|
|
func clearFrameState(f *cdp.Frame, fs cdp.FrameState) {
|
2017-01-24 15:09:23 +00:00
|
|
|
f.State &^= fs
|
|
|
|
}
|
|
|
|
|
|
|
|
// NodeOp is a node manipulation operation.
|
2017-01-26 07:28:34 +00:00
|
|
|
type NodeOp func(*cdp.Node)
|
2017-01-24 15:09:23 +00:00
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func walk(m map[cdp.NodeID]*cdp.Node, n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
m[n.NodeID] = n
|
|
|
|
|
|
|
|
for _, c := range n.Children {
|
|
|
|
c.Parent = n
|
|
|
|
c.Invalidated = n.Invalidated
|
|
|
|
walk(m, c)
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, c := range n.ShadowRoots {
|
|
|
|
c.Parent = n
|
|
|
|
c.Invalidated = n.Invalidated
|
|
|
|
walk(m, c)
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, c := range n.PseudoElements {
|
|
|
|
c.Parent = n
|
|
|
|
c.Invalidated = n.Invalidated
|
|
|
|
walk(m, c)
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
for _, c := range []*cdp.Node{n.ContentDocument, n.TemplateContent, n.ImportedDocument} {
|
2017-01-24 15:09:23 +00:00
|
|
|
if c == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
c.Parent = n
|
|
|
|
c.Invalidated = n.Invalidated
|
|
|
|
walk(m, c)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func setChildNodes(m map[cdp.NodeID]*cdp.Node, nodes []*cdp.Node) NodeOp {
|
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
n.Children = nodes
|
|
|
|
walk(m, n)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func attributeModified(name, value string) NodeOp {
|
2017-01-26 07:28:34 +00:00
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
var found bool
|
|
|
|
|
|
|
|
i := 0
|
|
|
|
for ; i < len(n.Attributes); i += 2 {
|
|
|
|
if n.Attributes[i] == name {
|
|
|
|
found = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if found {
|
|
|
|
n.Attributes[i] = name
|
|
|
|
n.Attributes[i+1] = value
|
|
|
|
} else {
|
|
|
|
n.Attributes = append(n.Attributes, name, value)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func attributeRemoved(name string) NodeOp {
|
2017-01-26 07:28:34 +00:00
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
var a []string
|
|
|
|
for i := 0; i < len(n.Attributes); i += 2 {
|
|
|
|
if n.Attributes[i] == name {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
a = append(a, n.Attributes[i], n.Attributes[i+1])
|
|
|
|
}
|
|
|
|
n.Attributes = a
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func inlineStyleInvalidated(ids []cdp.NodeID) NodeOp {
|
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func characterDataModified(characterData string) NodeOp {
|
2017-01-26 07:28:34 +00:00
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
n.Value = characterData
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func childNodeCountUpdated(count int64) NodeOp {
|
2017-01-26 07:28:34 +00:00
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
n.ChildNodeCount = count
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func childNodeInserted(m map[cdp.NodeID]*cdp.Node, prevID cdp.NodeID, c *cdp.Node) NodeOp {
|
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
n.Children = insertNode(n.Children, prevID, c)
|
|
|
|
walk(m, n)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func childNodeRemoved(m map[cdp.NodeID]*cdp.Node, id cdp.NodeID) NodeOp {
|
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
n.Children = removeNode(n.Children, id)
|
|
|
|
//delete(m, id)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func shadowRootPushed(m map[cdp.NodeID]*cdp.Node, c *cdp.Node) NodeOp {
|
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
n.ShadowRoots = append(n.ShadowRoots, c)
|
|
|
|
walk(m, n)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func shadowRootPopped(m map[cdp.NodeID]*cdp.Node, id cdp.NodeID) NodeOp {
|
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
n.ShadowRoots = removeNode(n.ShadowRoots, id)
|
|
|
|
//delete(m, id)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func pseudoElementAdded(m map[cdp.NodeID]*cdp.Node, c *cdp.Node) NodeOp {
|
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
n.PseudoElements = append(n.PseudoElements, c)
|
|
|
|
walk(m, n)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func pseudoElementRemoved(m map[cdp.NodeID]*cdp.Node, id cdp.NodeID) NodeOp {
|
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
n.PseudoElements = removeNode(n.PseudoElements, id)
|
|
|
|
//delete(m, id)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func distributedNodesUpdated(nodes []*cdp.BackendNode) NodeOp {
|
|
|
|
return func(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
n.DistributedNodes = nodes
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func nodeHighlightRequested(n *cdp.Node) {
|
2017-01-24 15:09:23 +00:00
|
|
|
// TODO
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func insertNode(n []*cdp.Node, prevID cdp.NodeID, c *cdp.Node) []*cdp.Node {
|
2017-01-24 15:09:23 +00:00
|
|
|
i := 0
|
|
|
|
found := false
|
|
|
|
for ; i < len(n); i++ {
|
|
|
|
if n[i].NodeID == prevID {
|
|
|
|
found = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if !found {
|
|
|
|
return append(n, c)
|
|
|
|
}
|
|
|
|
|
|
|
|
i++
|
|
|
|
n = append(n, nil)
|
|
|
|
copy(n[i+1:], n[i:])
|
|
|
|
n[i] = c
|
|
|
|
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
2017-01-26 07:28:34 +00:00
|
|
|
func removeNode(n []*cdp.Node, id cdp.NodeID) []*cdp.Node {
|
2017-01-24 15:09:23 +00:00
|
|
|
if len(n) == 0 {
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
|
|
|
var found bool
|
|
|
|
i := 0
|
|
|
|
for ; i < len(n); i++ {
|
|
|
|
if n[i].NodeID == id {
|
|
|
|
found = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if !found {
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
|
|
|
|
return append(n[:i], n[i+1:]...)
|
|
|
|
}
|
2017-02-08 16:01:35 +00:00
|
|
|
|
|
|
|
// isCouldNotComputeBoxModelError unwraps the err as a MessagError and
|
|
|
|
// determines if it is a compute box model error.
|
|
|
|
func isCouldNotComputeBoxModelError(err error) bool {
|
|
|
|
e, ok := err.(*cdp.MessageError)
|
|
|
|
return ok && e.Code == -32000 && e.Message == "Could not compute box model."
|
|
|
|
}
|