DevTools: Rename WebInspector.DOMAgent into WebInspector.DOMModel

Source/devtools/front_end/DOMModel.js

 /*
  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 13 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @constructor
- * @param {!WebInspector.DOMAgent} domAgent
+ * @param {!WebInspector.DOMModel} domModel
  * @param {?WebInspector.DOMDocument} doc
  * @param {boolean} isInShadowTree
  * @param {!DOMAgent.Node} payload
  */
-WebInspector.DOMNode = function(domAgent, doc, isInShadowTree, payload) {
-    this._domAgent = domAgent;
+WebInspector.DOMNode = function(domModel, doc, isInShadowTree, payload) {
+    this._domModel = domModel;
     this.ownerDocument = doc;
     this._isInShadowTree = isInShadowTree;
 
     this.id = payload.nodeId;
-    domAgent._idToDOMNode[this.id] = this;
+    domModel._idToDOMNode[this.id] = this;
     this._nodeType = payload.nodeType;
     this._nodeName = payload.nodeName;
     this._localName = payload.localName;
     this._nodeValue = payload.nodeValue;
     this._pseudoType = payload.pseudoType;
     this._shadowRootType = payload.shadowRootType;
     this._frameId = payload.frameId || null;
 
     this._shadowRoots = [];
 
@@ skipping 10 matching lines @@
 
     this.nextSibling = null;
     this.previousSibling = null;
     this.firstChild = null;
     this.lastChild = null;
     this.parentNode = null;
 
     if (payload.shadowRoots) {
         for (var i = 0; i < payload.shadowRoots.length; ++i) {
             var root = payload.shadowRoots[i];
-            var node = new WebInspector.DOMNode(this._domAgent, this.ownerDocument, true, root);
+            var node = new WebInspector.DOMNode(this._domModel, this.ownerDocument, true, root);
             this._shadowRoots.push(node);
             node.parentNode = this;
         }
     }
 
     if (payload.templateContent) {
-        this._templateContent = new WebInspector.DOMNode(this._domAgent, this.ownerDocument, true, payload.templateContent);
+        this._templateContent = new WebInspector.DOMNode(this._domModel, this.ownerDocument, true, payload.templateContent);
         this._templateContent.parentNode = this;
     }
 
     if (payload.importedDocument) {
-        this._importedDocument = new WebInspector.DOMNode(this._domAgent, this.ownerDocument, true, payload.importedDocument);
+        this._importedDocument = new WebInspector.DOMNode(this._domModel, this.ownerDocument, true, payload.importedDocument);
         this._importedDocument.parentNode = this;
     }
 
     if (payload.children)
         this._setChildrenPayload(payload.children);
 
     this._setPseudoElements(payload.pseudoElements);
 
     if (payload.contentDocument) {
-        this._contentDocument = new WebInspector.DOMDocument(domAgent, payload.contentDocument);
+        this._contentDocument = new WebInspector.DOMDocument(domModel, payload.contentDocument);
         this._children = [this._contentDocument];
         this._renumber();
     }
 
     if (this._nodeType === Node.ELEMENT_NODE) {
         // HTML and BODY from internal iframes should not overwrite top-level ones.
         if (this.ownerDocument && !this.ownerDocument.documentElement && this._nodeName === "HTML")
             this.ownerDocument.documentElement = this;
         if (this.ownerDocument && !this.ownerDocument.body && this._nodeName === "BODY")
             this.ownerDocument.body = this;
@@ skipping 168 matching lines @@
             return "#shadow-root" + (shadowRootType === WebInspector.DOMNode.ShadowRootTypes.UserAgent ? " (user-agent)" : "");
         return this.isXMLNode() ? this.nodeName() : this.nodeName().toLowerCase();
     },
 
     /**
      * @param {string} name
      * @param {function(?Protocol.Error)=} callback
      */
     setNodeName: function(name, callback)
     {
-        DOMAgent.setNodeName(this.id, name, WebInspector.domAgent._markRevision(this, callback));
+        DOMAgent.setNodeName(this.id, name, WebInspector.domModel._markRevision(this, callback));
     },
 
     /**
      * @return {string}
      */
     localName: function()
     {
         return this._localName;
     },
 
     /**
      * @return {string}
      */
     nodeValue: function()
     {
         return this._nodeValue;
     },
 
     /**
      * @param {string} value
      * @param {function(?Protocol.Error)=} callback
      */
     setNodeValue: function(value, callback)
     {
-        DOMAgent.setNodeValue(this.id, value, WebInspector.domAgent._markRevision(this, callback));
+        DOMAgent.setNodeValue(this.id, value, WebInspector.domModel._markRevision(this, callback));
     },
 
     /**
      * @param {string} name
      * @return {string}
      */
     getAttribute: function(name)
     {
         var attr = this._attributesMap[name];
         return attr ? attr.value : undefined;
     },
 
     /**
      * @param {string} name
      * @param {string} text
      * @param {function(?Protocol.Error)=} callback
      */
     setAttribute: function(name, text, callback)
     {
-        DOMAgent.setAttributesAsText(this.id, text, name, WebInspector.domAgent._markRevision(this, callback));
+        DOMAgent.setAttributesAsText(this.id, text, name, WebInspector.domModel._markRevision(this, callback));
     },
 
     /**
      * @param {string} name
      * @param {string} value
      * @param {function(?Protocol.Error)=} callback
      */
     setAttributeValue: function(name, value, callback)
     {
-        DOMAgent.setAttributeValue(this.id, name, value, WebInspector.domAgent._markRevision(this, callback));
+        DOMAgent.setAttributeValue(this.id, name, value, WebInspector.domModel._markRevision(this, callback));
     },
 
     /**
      * @return {!Object}
      */
     attributes: function()
     {
         return this._attributes;
     },
 
@@ skipping 12 matching lines @@
             if (!error) {
                 delete this._attributesMap[name];
                 for (var i = 0;  i < this._attributes.length; ++i) {
                     if (this._attributes[i].name === name) {
                         this._attributes.splice(i, 1);
                         break;
                     }
                 }
             }
 
-            WebInspector.domAgent._markRevision(this, callback)(error);
+            WebInspector.domModel._markRevision(this, callback)(error);
         }
         DOMAgent.removeAttribute(this.id, name, mycallback.bind(this));
     },
 
     /**
      * @param {function(?Array.<!WebInspector.DOMNode>)=} callback
      */
     getChildNodes: function(callback)
     {
         if (this._children) {
@@ skipping 41 matching lines @@
     {
         DOMAgent.getOuterHTML(this.id, callback);
     },
 
     /**
      * @param {string} html
      * @param {function(?Protocol.Error)=} callback
      */
     setOuterHTML: function(html, callback)
     {
-        DOMAgent.setOuterHTML(this.id, html, WebInspector.domAgent._markRevision(this, callback));
+        DOMAgent.setOuterHTML(this.id, html, WebInspector.domModel._markRevision(this, callback));
     },
 
     /**
      * @param {function(?Protocol.Error, !DOMAgent.NodeId=)=} callback
      */
     removeNode: function(callback)
     {
-        DOMAgent.removeNode(this.id, WebInspector.domAgent._markRevision(this, callback));
+        DOMAgent.removeNode(this.id, WebInspector.domModel._markRevision(this, callback));
     },
 
     copyNode: function()
     {
         function copy(error, text)
         {
             if (!error)
                 InspectorFrontendHost.copyText(text);
         }
         DOMAgent.getOuterHTML(this.id, copy);
@@ skipping 96 matching lines @@
         return attributesChanged;
     },
 
     /**
      * @param {!WebInspector.DOMNode} prev
      * @param {!DOMAgent.Node} payload
      * @return {!WebInspector.DOMNode}
      */
     _insertChild: function(prev, payload)
     {
-        var node = new WebInspector.DOMNode(this._domAgent, this.ownerDocument, this._isInShadowTree, payload);
+        var node = new WebInspector.DOMNode(this._domModel, this.ownerDocument, this._isInShadowTree, payload);
         this._children.splice(this._children.indexOf(prev) + 1, 0, node);
         this._renumber();
         return node;
     },
 
     /**
      * @param {!WebInspector.DOMNode} node
      */
     _removeChild: function(node)
     {
@@ skipping 16 matching lines @@
      */
     _setChildrenPayload: function(payloads)
     {
         // We set children in the constructor.
         if (this._contentDocument)
             return;
 
         this._children = [];
         for (var i = 0; i < payloads.length; ++i) {
             var payload = payloads[i];
-            var node = new WebInspector.DOMNode(this._domAgent, this.ownerDocument, this._isInShadowTree, payload);
+            var node = new WebInspector.DOMNode(this._domModel, this.ownerDocument, this._isInShadowTree, payload);
             this._children.push(node);
         }
         this._renumber();
     },
 
     /**
      * @param {!Array.<!DOMAgent.Node>|undefined} payloads
      */
     _setPseudoElements: function(payloads)
     {
         this._pseudoElements = {};
         if (!payloads)
             return;
 
         for (var i = 0; i < payloads.length; ++i) {
-            var node = new WebInspector.DOMNode(this._domAgent, this.ownerDocument, this._isInShadowTree, payloads[i]);
+            var node = new WebInspector.DOMNode(this._domModel, this.ownerDocument, this._isInShadowTree, payloads[i]);
             node.parentNode = this;
             this._pseudoElements[node.pseudoType()] = node;
         }
     },
 
     _renumber: function()
     {
         this._childNodeCount = this._children.length;
         if (this._childNodeCount == 0) {
             this.firstChild = null;
@@ skipping 51 matching lines @@
         }
     },
 
     /**
      * @param {!WebInspector.DOMNode} targetNode
      * @param {?WebInspector.DOMNode} anchorNode
      * @param {function(?Protocol.Error, !DOMAgent.NodeId=)=} callback
      */
     moveTo: function(targetNode, anchorNode, callback)
     {
-        DOMAgent.moveTo(this.id, targetNode.id, anchorNode ? anchorNode.id : undefined, WebInspector.domAgent._markRevision(this, callback));
+        DOMAgent.moveTo(this.id, targetNode.id, anchorNode ? anchorNode.id : undefined, WebInspector.domModel._markRevision(this, callback));
     },
 
     /**
      * @return {boolean}
      */
     isXMLNode: function()
     {
         return !!this.ownerDocument && !!this.ownerDocument.xmlVersion;
     },
 
@@ skipping 81 matching lines @@
             if (frameOwnerCandidate.baseURL)
                 return WebInspector.ParsedURL.completeURL(frameOwnerCandidate.baseURL, url);
         }
         return null;
     }
 }
 
 /**
  * @extends {WebInspector.DOMNode}
  * @constructor
- * @param {!WebInspector.DOMAgent} domAgent
+ * @param {!WebInspector.DOMModel} domModel
  * @param {!DOMAgent.Node} payload
  */
-WebInspector.DOMDocument = function(domAgent, payload)
+WebInspector.DOMDocument = function(domModel, payload)
 {
-    WebInspector.DOMNode.call(this, domAgent, this, false, payload);
+    WebInspector.DOMNode.call(this, domModel, this, false, payload);
     this.documentURL = payload.documentURL || "";
     this.baseURL = payload.baseURL || "";
     this.xmlVersion = payload.xmlVersion;
     this._listeners = {};
 }
 
 WebInspector.DOMDocument.prototype = {
     __proto__: WebInspector.DOMNode.prototype
 }
 
 /**
  * @extends {WebInspector.Object}
  * @constructor
  */
-WebInspector.DOMAgent = function() {
+WebInspector.DOMModel = function() {
     /** @type {!Object.<number, !WebInspector.DOMNode>} */
     this._idToDOMNode = {};
     /** @type {?WebInspector.DOMDocument} */
     this._document = null;
     /** @type {!Object.<number, boolean>} */
     this._attributeLoadNodeIds = {};
     InspectorBackend.registerDOMDispatcher(new WebInspector.DOMDispatcher(this));
 
     this._defaultHighlighter = new WebInspector.DefaultDOMNodeHighlighter();
     this._highlighter = this._defaultHighlighter;
 }
 
-WebInspector.DOMAgent.Events = {
+WebInspector.DOMModel.Events = {
     AttrModified: "AttrModified",
     AttrRemoved: "AttrRemoved",
     CharacterDataModified: "CharacterDataModified",
     NodeInserted: "NodeInserted",
     NodeRemoved: "NodeRemoved",
     DocumentUpdated: "DocumentUpdated",
     ChildNodeCountUpdated: "ChildNodeCountUpdated",
     UndoRedoRequested: "UndoRedoRequested",
     UndoRedoCompleted: "UndoRedoCompleted",
 }
 
-WebInspector.DOMAgent.prototype = {
+WebInspector.DOMModel.prototype = {
     /**
      * @param {function(!WebInspector.DOMDocument)=} callback
      */
     requestDocument: function(callback)
     {
         if (this._document) {
             if (callback)
                 callback(this._document);
             return;
         }
 
         if (this._pendingDocumentRequestCallbacks) {
             this._pendingDocumentRequestCallbacks.push(callback);
             return;
         }
 
         this._pendingDocumentRequestCallbacks = [callback];
 
         /**
-         * @this {WebInspector.DOMAgent}
+         * @this {WebInspector.DOMModel}
          * @param {?Protocol.Error} error
          * @param {!DOMAgent.Node} root
          */
         function onDocumentAvailable(error, root)
         {
             if (!error)
                 this._setDocument(root);
 
             for (var i = 0; i < this._pendingDocumentRequestCallbacks.length; ++i) {
                 var callback = this._pendingDocumentRequestCallbacks[i];
@@ skipping 65 matching lines @@
     /**
      * @param {function(function(?Protocol.Error, !T=)=)} func
      * @param {function(!T)=} callback
      * @template T
      */
     _dispatchWhenDocumentAvailable: function(func, callback)
     {
         var callbackWrapper = this._wrapClientCallback(callback);
 
         /**
-         * @this {WebInspector.DOMAgent}
+         * @this {WebInspector.DOMModel}
          */
         function onDocumentAvailable()
         {
             if (this._document)
                 func(callbackWrapper);
             else {
                 if (callbackWrapper)
                     callbackWrapper("No document");
             }
         }
         this.requestDocument(onDocumentAvailable.bind(this));
     },
 
     /**
      * @param {!DOMAgent.NodeId} nodeId
      * @param {string} name
      * @param {string} value
      */
     _attributeModified: function(nodeId, name, value)
     {
         var node = this._idToDOMNode[nodeId];
         if (!node)
             return;
 
         node._setAttribute(name, value);
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.AttrModified, { node: node, name: name });
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.AttrModified, { node: node, name: name });
     },
 
     /**
      * @param {!DOMAgent.NodeId} nodeId
      * @param {string} name
      */
     _attributeRemoved: function(nodeId, name)
     {
         var node = this._idToDOMNode[nodeId];
         if (!node)
             return;
         node._removeAttribute(name);
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.AttrRemoved, { node: node, name: name });
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.AttrRemoved, { node: node, name: name });
     },
 
     /**
      * @param {!Array.<!DOMAgent.NodeId>} nodeIds
      */
     _inlineStyleInvalidated: function(nodeIds)
     {
         for (var i = 0; i < nodeIds.length; ++i)
             this._attributeLoadNodeIds[nodeIds[i]] = true;
         if ("_loadNodeAttributesTimeout" in this)
             return;
         this._loadNodeAttributesTimeout = setTimeout(this._loadNodeAttributes.bind(this), 20);
     },
 
     _loadNodeAttributes: function()
     {
         /**
-         * @this {WebInspector.DOMAgent}
+         * @this {WebInspector.DOMModel}
          * @param {!DOMAgent.NodeId} nodeId
          * @param {?Protocol.Error} error
          * @param {!Array.<string>} attributes
          */
         function callback(nodeId, error, attributes)
         {
             if (error) {
                 // We are calling _loadNodeAttributes asynchronously, it is ok if node is not found.
                 return;
             }
             var node = this._idToDOMNode[nodeId];
             if (node) {
                 if (node._setAttributesPayload(attributes))
-                    this.dispatchEventToListeners(WebInspector.DOMAgent.Events.AttrModified, { node: node, name: "style" });
+                    this.dispatchEventToListeners(WebInspector.DOMModel.Events.AttrModified, { node: node, name: "style" });
             }
         }
 
         delete this._loadNodeAttributesTimeout;
 
         for (var nodeId in this._attributeLoadNodeIds) {
             var nodeIdAsNumber = parseInt(nodeId, 10);
             DOMAgent.getAttributes(nodeIdAsNumber, callback.bind(this, nodeIdAsNumber));
         }
         this._attributeLoadNodeIds = {};
     },
 
     /**
      * @param {!DOMAgent.NodeId} nodeId
      * @param {string} newValue
      */
     _characterDataModified: function(nodeId, newValue)
     {
         var node = this._idToDOMNode[nodeId];
         node._nodeValue = newValue;
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.CharacterDataModified, node);
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.CharacterDataModified, node);
     },
 
     /**
      * @param {!DOMAgent.NodeId} nodeId
      * @return {?WebInspector.DOMNode}
      */
     nodeForId: function(nodeId)
     {
         return this._idToDOMNode[nodeId] || null;
     },
 
     _documentUpdated: function()
     {
         this._setDocument(null);
     },
 
     /**
      * @param {?DOMAgent.Node} payload
      */
     _setDocument: function(payload)
     {
         this._idToDOMNode = {};
         if (payload && "nodeId" in payload)
             this._document = new WebInspector.DOMDocument(this, payload);
         else
             this._document = null;
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.DocumentUpdated, this._document);
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.DocumentUpdated, this._document);
     },
 
     /**
      * @param {!DOMAgent.Node} payload
      */
     _setDetachedRoot: function(payload)
     {
         if (payload.nodeName === "#document")
             new WebInspector.DOMDocument(this, payload);
         else
@@ skipping 16 matching lines @@
     },
 
     /**
      * @param {!DOMAgent.NodeId} nodeId
      * @param {number} newValue
      */
     _childNodeCountUpdated: function(nodeId, newValue)
     {
         var node = this._idToDOMNode[nodeId];
         node._childNodeCount = newValue;
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.ChildNodeCountUpdated, node);
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.ChildNodeCountUpdated, node);
     },
 
     /**
      * @param {!DOMAgent.NodeId} parentId
      * @param {!DOMAgent.NodeId} prevId
      * @param {!DOMAgent.Node} payload
      */
     _childNodeInserted: function(parentId, prevId, payload)
     {
         var parent = this._idToDOMNode[parentId];
         var prev = this._idToDOMNode[prevId];
         var node = parent._insertChild(prev, payload);
         this._idToDOMNode[node.id] = node;
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.NodeInserted, node);
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.NodeInserted, node);
     },
 
     /**
      * @param {!DOMAgent.NodeId} parentId
      * @param {!DOMAgent.NodeId} nodeId
      */
     _childNodeRemoved: function(parentId, nodeId)
     {
         var parent = this._idToDOMNode[parentId];
         var node = this._idToDOMNode[nodeId];
         parent._removeChild(node);
         this._unbind(node);
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.NodeRemoved, {node: node, parent: parent});
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.NodeRemoved, {node: node, parent: parent});
     },
 
     /**
      * @param {!DOMAgent.NodeId} hostId
      * @param {!DOMAgent.Node} root
      */
     _shadowRootPushed: function(hostId, root)
     {
         var host = this._idToDOMNode[hostId];
         if (!host)
             return;
         var node = new WebInspector.DOMNode(this, host.ownerDocument, true, root);
         node.parentNode = host;
         this._idToDOMNode[node.id] = node;
         host._shadowRoots.push(node);
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.NodeInserted, node);
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.NodeInserted, node);
     },
 
     /**
      * @param {!DOMAgent.NodeId} hostId
      * @param {!DOMAgent.NodeId} rootId
      */
     _shadowRootPopped: function(hostId, rootId)
     {
         var host = this._idToDOMNode[hostId];
         if (!host)
             return;
         var root = this._idToDOMNode[rootId];
         if (!root)
             return;
         host._removeChild(root);
         this._unbind(root);
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.NodeRemoved, {node: root, parent: host});
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.NodeRemoved, {node: root, parent: host});
     },
 
     /**
      * @param {!DOMAgent.NodeId} parentId
      * @param {!DOMAgent.Node} pseudoElement
      */
     _pseudoElementAdded: function(parentId, pseudoElement)
     {
         var parent = this._idToDOMNode[parentId];
         if (!parent)
             return;
         var node = new WebInspector.DOMNode(this, parent.ownerDocument, false, pseudoElement);
         node.parentNode = parent;
         this._idToDOMNode[node.id] = node;
         console.assert(!parent._pseudoElements[node.pseudoType()]);
         parent._pseudoElements[node.pseudoType()] = node;
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.NodeInserted, node);
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.NodeInserted, node);
     },
 
     /**
      * @param {!DOMAgent.NodeId} parentId
      * @param {!DOMAgent.NodeId} pseudoElementId
      */
     _pseudoElementRemoved: function(parentId, pseudoElementId)
     {
         var parent = this._idToDOMNode[parentId];
         if (!parent)
             return;
         var pseudoElement = this._idToDOMNode[pseudoElementId];
         if (!pseudoElement)
             return;
         parent._removeChild(pseudoElement);
         this._unbind(pseudoElement);
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.NodeRemoved, {node: pseudoElement, parent: parent});
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.NodeRemoved, {node: pseudoElement, parent: parent});
     },
 
     /**
      * @param {!WebInspector.DOMNode} node
      */
     _unbind: function(node)
     {
         delete this._idToDOMNode[node.id];
         for (var i = 0; node._children && i < node._children.length; ++i)
             this._unbind(node._children[i]);
@@ skipping 27 matching lines @@
      * @param {function(number)} searchCallback
      */
     performSearch: function(query, searchCallback)
     {
         this.cancelSearch();
 
         /**
          * @param {?Protocol.Error} error
          * @param {string} searchId
          * @param {number} resultsCount
-         * @this {WebInspector.DOMAgent}
+         * @this {WebInspector.DOMModel}
          */
         function callback(error, searchId, resultsCount)
         {
             this._searchId = searchId;
             searchCallback(resultsCount);
         }
         DOMAgent.performSearch(query, callback.bind(this));
     },
 
     /**
      * @param {number} index
      * @param {?function(?WebInspector.DOMNode)} callback
      */
     searchResult: function(index, callback)
     {
         if (this._searchId)
             DOMAgent.getSearchResults(this._searchId, index, index + 1, searchResultsCallback.bind(this));
         else
             callback(null);
 
         /**
          * @param {?Protocol.Error} error
          * @param {!Array.<number>} nodeIds
-         * @this {WebInspector.DOMAgent}
+         * @this {WebInspector.DOMModel}
          */
         function searchResultsCallback(error, nodeIds)
         {
             if (error) {
                 console.error(error);
                 callback(null);
                 return;
             }
             if (nodeIds.length != 1)
                 return;
@@ skipping 59 matching lines @@
     },
 
     /**
      * @param {boolean} enabled
      * @param {boolean} inspectUAShadowDOM
      * @param {function(?Protocol.Error)=} callback
      */
     setInspectModeEnabled: function(enabled, inspectUAShadowDOM, callback)
     {
         /**
-         * @this {WebInspector.DOMAgent}
+         * @this {WebInspector.DOMModel}
          */
         function onDocumentAvailable()
         {
             this._highlighter.setInspectModeEnabled(enabled, inspectUAShadowDOM, this._buildHighlightConfig(), callback);
         }
         this.requestDocument(onDocumentAvailable.bind(this));
     },
 
     /**
      * @param {string=} mode
@@ skipping 24 matching lines @@
     /**
      * @param {!WebInspector.DOMNode} node
      * @param {function(?Protocol.Error, !A=, !B=)=} callback
      * @return {function(?Protocol.Error, !A=, !B=)}
      * @template A,B
      */
     _markRevision: function(node, callback)
     {
         /**
          * @param {?Protocol.Error} error
-         * @this {WebInspector.DOMAgent}
+         * @this {WebInspector.DOMModel}
          */
         function wrapperFunction(error)
         {
             if (!error)
                 this.markUndoableState();
 
             if (callback)
                 callback.apply(this, arguments);
         }
         return wrapperFunction.bind(this);
@@ skipping 21 matching lines @@
         } else {
             if (typeof this._addTouchEventsScriptId !== "undefined") {
                 PageAgent.removeScriptToEvaluateOnLoad(this._addTouchEventsScriptId);
                 delete this._addTouchEventsScriptId;
             }
         }
 
         /**
          * @param {?Protocol.Error} error
          * @param {string} scriptId
-         * @this {WebInspector.DOMAgent}
+         * @this {WebInspector.DOMModel}
          */
         function scriptAddedCallback(error, scriptId)
         {
             delete this._addTouchEventsScriptInjecting;
             if (error)
                 return;
             this._addTouchEventsScriptId = scriptId;
         }
 
         PageAgent.setTouchEmulationEnabled(emulationEnabled);
     },
 
     markUndoableState: function()
     {
         DOMAgent.markUndoableState();
     },
 
     /**
      * @param {function(?Protocol.Error)=} callback
      */
     undo: function(callback)
     {
         /**
          * @param {?Protocol.Error} error
-         * @this {WebInspector.DOMAgent}
+         * @this {WebInspector.DOMModel}
          */
         function mycallback(error)
         {
-            this.dispatchEventToListeners(WebInspector.DOMAgent.Events.UndoRedoCompleted);
+            this.dispatchEventToListeners(WebInspector.DOMModel.Events.UndoRedoCompleted);
             callback(error);
         }
 
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.UndoRedoRequested);
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.UndoRedoRequested);
         DOMAgent.undo(callback);
     },
 
     /**
      * @param {function(?Protocol.Error)=} callback
      */
     redo: function(callback)
     {
         /**
          * @param {?Protocol.Error} error
-         * @this {WebInspector.DOMAgent}
+         * @this {WebInspector.DOMModel}
          */
         function mycallback(error)
         {
-            this.dispatchEventToListeners(WebInspector.DOMAgent.Events.UndoRedoCompleted);
+            this.dispatchEventToListeners(WebInspector.DOMModel.Events.UndoRedoCompleted);
             callback(error);
         }
 
-        this.dispatchEventToListeners(WebInspector.DOMAgent.Events.UndoRedoRequested);
+        this.dispatchEventToListeners(WebInspector.DOMModel.Events.UndoRedoRequested);
         DOMAgent.redo(callback);
     },
 
     /**
      * @param {?WebInspector.DOMNodeHighlighter} highlighter
      */
     setHighlighter: function(highlighter)
     {
         this._highlighter = highlighter || this._defaultHighlighter;
     },
 
     __proto__: WebInspector.Object.prototype
 }
 
 /**
  * @constructor
  * @implements {DOMAgent.Dispatcher}
- * @param {!WebInspector.DOMAgent} domAgent
+ * @param {!WebInspector.DOMModel} domModel
  */
-WebInspector.DOMDispatcher = function(domAgent)
+WebInspector.DOMDispatcher = function(domModel)
 {
-    this._domAgent = domAgent;
+    this._domModel = domModel;
 }
 
 WebInspector.DOMDispatcher.prototype = {
     documentUpdated: function()
     {
-        this._domAgent._documentUpdated();
+        this._domModel._documentUpdated();
     },
 
     /**
      * @param {!DOMAgent.NodeId} nodeId
      */
     inspectNodeRequested: function(nodeId)
     {
-        this._domAgent._inspectNodeRequested(nodeId);
+        this._domModel._inspectNodeRequested(nodeId);
     },
 
     /**
      * @param {!DOMAgent.NodeId} nodeId
      * @param {string} name
      * @param {string} value
      */
     attributeModified: function(nodeId, name, value)
     {
-        this._domAgent._attributeModified(nodeId, name, value);
+        this._domModel._attributeModified(nodeId, name, value);
     },
 
     /**
      * @param {!DOMAgent.NodeId} nodeId
      * @param {string} name
      */
     attributeRemoved: function(nodeId, name)
     {
-        this._domAgent._attributeRemoved(nodeId, name);
+        this._domModel._attributeRemoved(nodeId, name);
     },
 
     /**
      * @param {!Array.<!DOMAgent.NodeId>} nodeIds
      */
     inlineStyleInvalidated: function(nodeIds)
     {
-        this._domAgent._inlineStyleInvalidated(nodeIds);
+        this._domModel._inlineStyleInvalidated(nodeIds);
     },
 
     /**
      * @param {!DOMAgent.NodeId} nodeId
      * @param {string} characterData
      */
     characterDataModified: function(nodeId, characterData)
     {
-        this._domAgent._characterDataModified(nodeId, characterData);
+        this._domModel._characterDataModified(nodeId, characterData);
     },
 
     /**
      * @param {!DOMAgent.NodeId} parentId
      * @param {!Array.<!DOMAgent.Node>} payloads
      */
     setChildNodes: function(parentId, payloads)
     {
-        this._domAgent._setChildNodes(parentId, payloads);
+        this._domModel._setChildNodes(parentId, payloads);
     },
 
     /**
      * @param {!DOMAgent.NodeId} nodeId
      * @param {number} childNodeCount
      */
     childNodeCountUpdated: function(nodeId, childNodeCount)
     {
-        this._domAgent._childNodeCountUpdated(nodeId, childNodeCount);
+        this._domModel._childNodeCountUpdated(nodeId, childNodeCount);
     },
 
     /**
      * @param {!DOMAgent.NodeId} parentNodeId
      * @param {!DOMAgent.NodeId} previousNodeId
      * @param {!DOMAgent.Node} payload
      */
     childNodeInserted: function(parentNodeId, previousNodeId, payload)
     {
-        this._domAgent._childNodeInserted(parentNodeId, previousNodeId, payload);
+        this._domModel._childNodeInserted(parentNodeId, previousNodeId, payload);
     },
 
     /**
      * @param {!DOMAgent.NodeId} parentNodeId
      * @param {!DOMAgent.NodeId} nodeId
      */
     childNodeRemoved: function(parentNodeId, nodeId)
     {
-        this._domAgent._childNodeRemoved(parentNodeId, nodeId);
+        this._domModel._childNodeRemoved(parentNodeId, nodeId);
     },
 
     /**
      * @param {!DOMAgent.NodeId} hostId
      * @param {!DOMAgent.Node} root
      */
     shadowRootPushed: function(hostId, root)
     {
-        this._domAgent._shadowRootPushed(hostId, root);
+        this._domModel._shadowRootPushed(hostId, root);
     },
 
     /**
      * @param {!DOMAgent.NodeId} hostId
      * @param {!DOMAgent.NodeId} rootId
      */
     shadowRootPopped: function(hostId, rootId)
     {
-        this._domAgent._shadowRootPopped(hostId, rootId);
+        this._domModel._shadowRootPopped(hostId, rootId);
     },
 
     /**
      * @param {!DOMAgent.NodeId} parentId
      * @param {!DOMAgent.Node} pseudoElement
      */
     pseudoElementAdded: function(parentId, pseudoElement)
     {
-        this._domAgent._pseudoElementAdded(parentId, pseudoElement);
+        this._domModel._pseudoElementAdded(parentId, pseudoElement);
     },
 
     /**
      * @param {!DOMAgent.NodeId} parentId
      * @param {!DOMAgent.NodeId} pseudoElementId
      */
     pseudoElementRemoved: function(parentId, pseudoElementId)
     {
-        this._domAgent._pseudoElementRemoved(parentId, pseudoElementId);
+        this._domModel._pseudoElementRemoved(parentId, pseudoElementId);
     }
 }
 
 /**
  * @interface
  */
 WebInspector.DOMNodeHighlighter = function() {
 }
 
 WebInspector.DOMNodeHighlighter.prototype = {
@@ skipping 40 matching lines @@
      * @param {!DOMAgent.HighlightConfig} config
      * @param {function(?Protocol.Error)=} callback
      */
     setInspectModeEnabled: function(enabled, inspectUAShadowDOM, config, callback)
     {
         DOMAgent.setInspectModeEnabled(enabled, inspectUAShadowDOM, config, callback);
     }
 }
 
 /**
- * @type {!WebInspector.DOMAgent}
+ * @type {!WebInspector.DOMModel}
  */
-WebInspector.domAgent;
+WebInspector.domModel;