devtools/shared/specs/walker.js

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4 "use strict";
   5
   6 const {
   7   Arg,
   8   Option,
   9   RetVal,
  10   generateActorSpec,
  11   types,
  12 } = require("resource://devtools/shared/protocol.js");
  13
  14 types.addDictType("dommutation", {});
  15
  16 types.addDictType("searchresult", {
  17   list: "domnodelist",
  18   // Right now there is isn't anything required for metadata,
  19   // but it's json so it can be extended with extra data.
  20   metadata: "array:json",
  21 });
  22
  23 // Some common request/response templates for the dom walker
  24
  25 var nodeArrayMethod = {
  26   request: {
  27     node: Arg(0, "domnode"),
  28     maxNodes: Option(1),
  29     center: Option(1, "domnode"),
  30     start: Option(1, "domnode"),
  31   },
  32   response: RetVal(
  33     types.addDictType("domtraversalarray", {
  34       nodes: "array:domnode",
  35     })
  36   ),
  37 };
  38
  39 var traversalMethod = {
  40   request: {
  41     node: Arg(0, "domnode"),
  42   },
  43   response: {
  44     node: RetVal("nullable:domnode"),
  45   },
  46 };
  47
  48 const walkerSpec = generateActorSpec({
  49   typeName: "domwalker",
  50
  51   events: {
  52     "new-mutations": {
  53       type: "newMutations",
  54     },
  55     "root-available": {
  56       type: "root-available",
  57       node: Arg(0, "nullable:domnode"),
  58     },
  59     "root-destroyed": {
  60       type: "root-destroyed",
  61       node: Arg(0, "nullable:domnode"),
  62     },
  63     "picker-node-picked": {
  64       type: "pickerNodePicked",
  65       node: Arg(0, "disconnectedNode"),
  66     },
  67     "picker-node-previewed": {
  68       type: "pickerNodePreviewed",
  69       node: Arg(0, "disconnectedNode"),
  70     },
  71     "picker-node-hovered": {
  72       type: "pickerNodeHovered",
  73       node: Arg(0, "disconnectedNode"),
  74     },
  75     "picker-node-canceled": {
  76       type: "pickerNodeCanceled",
  77     },
  78     "display-change": {
  79       type: "display-change",
  80       nodes: Arg(0, "array:domnode"),
  81     },
  82     "scrollable-change": {
  83       type: "scrollable-change",
  84       nodes: Arg(0, "array:domnode"),
  85     },
  86     "overflow-change": {
  87       type: "overflow-change",
  88       nodes: Arg(0, "array:domnode"),
  89     },
  90     "container-type-change": {
  91       type: "container-type-change",
  92       nodes: Arg(0, "array:domnode"),
  93     },
  94     // The walker actor emits a useful "resize" event to its front to let
  95     // clients know when the browser window gets resized. This may be useful
  96     // for refreshing a DOM node's styles for example, since those may depend on
  97     // media-queries.
  98     resize: {
  99       type: "resize",
 100     },
 101   },
 102
 103   methods: {
 104     release: {
 105       release: true,
 106     },
 107     document: {
 108       request: { node: Arg(0, "nullable:domnode") },
 109       response: { node: RetVal("domnode") },
 110     },
 111     documentElement: {
 112       request: { node: Arg(0, "nullable:domnode") },
 113       response: { node: RetVal("domnode") },
 114     },
 115     retainNode: {
 116       request: { node: Arg(0, "domnode") },
 117       response: {},
 118     },
 119     unretainNode: {
 120       request: { node: Arg(0, "domnode") },
 121       response: {},
 122     },
 123     releaseNode: {
 124       request: {
 125         node: Arg(0, "domnode"),
 126         force: Option(1),
 127       },
 128     },
 129     children: nodeArrayMethod,
 130     nextSibling: traversalMethod,
 131     previousSibling: traversalMethod,
 132     findInspectingNode: {
 133       request: {},
 134       response: RetVal("disconnectedNode"),
 135     },
 136     querySelector: {
 137       request: {
 138         node: Arg(0, "domnode"),
 139         selector: Arg(1),
 140       },
 141       response: RetVal("disconnectedNode"),
 142     },
 143     getIdrefNode: {
 144       request: {
 145         node: Arg(0, "domnode"),
 146         id: Arg(1),
 147       },
 148       response: RetVal("disconnectedNode"),
 149     },
 150     querySelectorAll: {
 151       request: {
 152         node: Arg(0, "domnode"),
 153         selector: Arg(1),
 154       },
 155       response: {
 156         list: RetVal("domnodelist"),
 157       },
 158     },
 159     search: {
 160       request: {
 161         query: Arg(0),
 162       },
 163       response: {
 164         list: RetVal("searchresult"),
 165       },
 166     },
 167     getSuggestionsForQuery: {
 168       request: {
 169         query: Arg(0),
 170         completing: Arg(1),
 171         selectorState: Arg(2),
 172       },
 173       response: {
 174         list: RetVal("array:array:string"),
 175       },
 176     },
 177     addPseudoClassLock: {
 178       request: {
 179         node: Arg(0, "domnode"),
 180         pseudoClass: Arg(1),
 181         parents: Option(2),
 182         enabled: Option(2, "boolean"),
 183       },
 184       response: {},
 185     },
 186     hideNode: {
 187       request: { node: Arg(0, "domnode") },
 188     },
 189     unhideNode: {
 190       request: { node: Arg(0, "domnode") },
 191     },
 192     removePseudoClassLock: {
 193       request: {
 194         node: Arg(0, "domnode"),
 195         pseudoClass: Arg(1),
 196         parents: Option(2),
 197       },
 198       response: {},
 199     },
 200     clearPseudoClassLocks: {
 201       request: {
 202         node: Arg(0, "nullable:domnode"),
 203       },
 204       response: {},
 205     },
 206     innerHTML: {
 207       request: {
 208         node: Arg(0, "domnode"),
 209       },
 210       response: {
 211         value: RetVal("longstring"),
 212       },
 213     },
 214     setInnerHTML: {
 215       request: {
 216         node: Arg(0, "domnode"),
 217         value: Arg(1, "string"),
 218       },
 219       response: {},
 220     },
 221     outerHTML: {
 222       request: {
 223         node: Arg(0, "domnode"),
 224       },
 225       response: {
 226         value: RetVal("longstring"),
 227       },
 228     },
 229     setOuterHTML: {
 230       request: {
 231         node: Arg(0, "domnode"),
 232         value: Arg(1, "string"),
 233       },
 234       response: {},
 235     },
 236     insertAdjacentHTML: {
 237       request: {
 238         node: Arg(0, "domnode"),
 239         position: Arg(1, "string"),
 240         value: Arg(2, "string"),
 241       },
 242       response: RetVal("disconnectedNodeArray"),
 243     },
 244     duplicateNode: {
 245       request: {
 246         node: Arg(0, "domnode"),
 247       },
 248       response: {},
 249     },
 250     removeNode: {
 251       request: {
 252         node: Arg(0, "domnode"),
 253       },
 254       response: {
 255         nextSibling: RetVal("nullable:domnode"),
 256       },
 257     },
 258     removeNodes: {
 259       request: {
 260         node: Arg(0, "array:domnode"),
 261       },
 262       response: {},
 263     },
 264     insertBefore: {
 265       request: {
 266         node: Arg(0, "domnode"),
 267         parent: Arg(1, "domnode"),
 268         sibling: Arg(2, "nullable:domnode"),
 269       },
 270       response: {},
 271     },
 272     editTagName: {
 273       request: {
 274         node: Arg(0, "domnode"),
 275         tagName: Arg(1, "string"),
 276       },
 277       response: {},
 278     },
 279     getMutations: {
 280       request: {
 281         cleanup: Option(0),
 282       },
 283       response: {
 284         mutations: RetVal("array:dommutation"),
 285       },
 286     },
 287     isInDOMTree: {
 288       request: { node: Arg(0, "domnode") },
 289       response: { attached: RetVal("boolean") },
 290     },
 291     getNodeActorFromWindowID: {
 292       request: {
 293         windowID: Arg(0, "string"),
 294       },
 295       response: {
 296         nodeFront: RetVal("nullable:disconnectedNode"),
 297       },
 298     },
 299     getNodeActorFromContentDomReference: {
 300       request: {
 301         contentDomReference: Arg(0, "json"),
 302       },
 303       response: {
 304         nodeFront: RetVal("nullable:disconnectedNode"),
 305       },
 306     },
 307     getStyleSheetOwnerNode: {
 308       request: {
 309         styleSheetActorID: Arg(0, "string"),
 310       },
 311       response: {
 312         ownerNode: RetVal("nullable:disconnectedNode"),
 313       },
 314     },
 315     getNodeFromActor: {
 316       request: {
 317         actorID: Arg(0, "string"),
 318         path: Arg(1, "array:string"),
 319       },
 320       response: {
 321         node: RetVal("nullable:disconnectedNode"),
 322       },
 323     },
 324     getLayoutInspector: {
 325       request: {},
 326       response: {
 327         actor: RetVal("layout"),
 328       },
 329     },
 330     getParentGridNode: {
 331       request: {
 332         node: Arg(0, "nullable:domnode"),
 333       },
 334       response: {
 335         node: RetVal("nullable:domnode"),
 336       },
 337     },
 338     getOffsetParent: {
 339       request: {
 340         node: Arg(0, "nullable:domnode"),
 341       },
 342       response: {
 343         node: RetVal("nullable:domnode"),
 344       },
 345     },
 346     setMutationBreakpoints: {
 347       request: {
 348         node: Arg(0, "nullable:domnode"),
 349         subtree: Option(1, "nullable:boolean"),
 350         removal: Option(1, "nullable:boolean"),
 351         attribute: Option(1, "nullable:boolean"),
 352       },
 353       response: {},
 354     },
 355     getEmbedderElement: {
 356       request: {
 357         browsingContextID: Arg(0, "string"),
 358       },
 359       response: {
 360         nodeFront: RetVal("disconnectedNode"),
 361       },
 362     },
 363     pick: {
 364       request: {
 365         doFocus: Arg(0, "nullable:boolean"),
 366         isLocalTab: Arg(1, "nullable:boolean"),
 367       },
 368     },
 369     cancelPick: {
 370       request: {},
 371       response: {},
 372     },
 373     clearPicker: {
 374       request: {},
 375       oneway: true,
 376     },
 377     watchRootNode: {
 378       request: {},
 379       response: {},
 380     },
 381     getOverflowCausingElements: {
 382       request: {
 383         node: Arg(0, "domnode"),
 384       },
 385       response: {
 386         list: RetVal("disconnectedNodeArray"),
 387       },
 388     },
 389     getScrollableAncestorNode: {
 390       request: {
 391         node: Arg(0, "domnode"),
 392       },
 393       response: {
 394         node: RetVal("nullable:domnode"),
 395       },
 396     },
 397   },
 398 });
 399
 400 exports.walkerSpec = walkerSpec;