DevTools: Rename WebInspector.DOMAgent into WebInspector.DOMModel

Source/devtools/front_end/ElementsTreeOutline.js

 /*
  * Copyright (C) 2007, 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2008 Matt Lilek <webkit@mattlilek.com>
  * 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 379 matching lines @@
         if (this._previousHoveredElement) {
             this._previousHoveredElement.hovered = false;
             delete this._previousHoveredElement;
         }
 
         if (element) {
             element.hovered = true;
             this._previousHoveredElement = element;
         }
 
-        WebInspector.domAgent.highlightDOMNode(element && element._node ? element._node.id : 0);
+        WebInspector.domModel.highlightDOMNode(element && element._node ? element._node.id : 0);
     },
 
     _onmouseout: function(event)
     {
         var nodeUnderMouse = document.elementFromPoint(event.pageX, event.pageY);
         if (nodeUnderMouse && nodeUnderMouse.isDescendant(this.element))
             return;
 
         if (this._previousHoveredElement) {
             this._previousHoveredElement.hovered = false;
             delete this._previousHoveredElement;
         }
 
-        WebInspector.domAgent.hideDOMNodeHighlight();
+        WebInspector.domModel.hideDOMNodeHighlight();
     },
 
     _ondragstart: function(event)
     {
         if (!window.getSelection().isCollapsed)
             return false;
         if (event.target.nodeName === "A")
             return false;
 
         var treeElement = this._treeElementFromEvent(event);
         if (!treeElement)
             return false;
 
         if (!this._isValidDragSourceOrTarget(treeElement))
             return false;
 
         if (treeElement._node.nodeName() === "BODY" || treeElement._node.nodeName() === "HEAD")
             return false;
 
         event.dataTransfer.setData("text/plain", treeElement.listItemElement.textContent);
         event.dataTransfer.effectAllowed = "copyMove";
         this._treeElementBeingDragged = treeElement;
 
-        WebInspector.domAgent.hideDOMNodeHighlight();
+        WebInspector.domModel.hideDOMNodeHighlight();
 
         return true;
     },
 
     _ondragover: function(event)
     {
         if (!this._treeElementBeingDragged)
             return false;
 
         var treeElement = this._treeElementFromEvent(event);
@@ skipping 210 matching lines @@
      * @param {!DOMAgent.NodeId=} nodeId
      */
     _selectNodeAfterEdit: function(wasExpanded, error, nodeId)
     {
         if (error)
             return;
 
         // Select it and expand if necessary. We force tree update so that it processes dom events and is up to date.
         this._updateModifiedNodes();
 
-        var newNode = nodeId ? WebInspector.domAgent.nodeForId(nodeId) : null;
+        var newNode = nodeId ? WebInspector.domModel.nodeForId(nodeId) : null;
         if (!newNode)
             return;
 
         this.selectDOMNode(newNode, true);
 
         var newTreeItem = this.findTreeElement(newNode);
         if (wasExpanded) {
             if (newTreeItem)
                 newTreeItem.expand();
         }
@@ skipping 565 matching lines @@
     /**
      * @override
      * @param {boolean=} selectedByUser
      * @return {boolean}
      */
     onselect: function(selectedByUser)
     {
         this.treeOutline.suppressRevealAndSelect = true;
         this.treeOutline.selectDOMNode(this._node, selectedByUser);
         if (selectedByUser)
-            WebInspector.domAgent.highlightDOMNode(this._node.id);
+            WebInspector.domModel.highlightDOMNode(this._node.id);
         this.updateSelection();
         this.treeOutline.suppressRevealAndSelect = false;
         return true;
     },
 
     /**
      * @override
      * @return {boolean}
      */
     ondelete: function()
@@ skipping 1107 matching lines @@
             }
 
             if (object)
                 object.callFunction(scrollIntoView);
         }
         
         WebInspector.RemoteObject.resolveNode(this._node, "", scrollIntoViewCallback);
     },
 
     /**
-     * @return {!Array.<!WebInspector.DOMAgent>}
+     * @return {!Array.<!WebInspector.DOMModel>}
      */
     _visibleShadowRoots: function()
     {
         var roots = this._node.shadowRoots();
         if (roots.length && !WebInspector.settings.showUAShadowDOM.get()) {
             roots = roots.filter(function(root) {
                 return root.shadowRootType() === WebInspector.DOMNode.ShadowRootTypes.Author;
             });
         }
         return roots;
@@ skipping 41 matching lines @@
 
     __proto__: TreeElement.prototype
 }
 
 /**
  * @constructor
  * @param {!WebInspector.ElementsTreeOutline} treeOutline
  */
 WebInspector.ElementsTreeUpdater = function(treeOutline)
 {
-    WebInspector.domAgent.addEventListener(WebInspector.DOMAgent.Events.NodeInserted, this._nodeInserted, this);
-    WebInspector.domAgent.addEventListener(WebInspector.DOMAgent.Events.NodeRemoved, this._nodeRemoved, this);
-    WebInspector.domAgent.addEventListener(WebInspector.DOMAgent.Events.AttrModified, this._attributesUpdated, this);
-    WebInspector.domAgent.addEventListener(WebInspector.DOMAgent.Events.AttrRemoved, this._attributesUpdated, this);
-    WebInspector.domAgent.addEventListener(WebInspector.DOMAgent.Events.CharacterDataModified, this._characterDataModified, this);
-    WebInspector.domAgent.addEventListener(WebInspector.DOMAgent.Events.DocumentUpdated, this._documentUpdated, this);
-    WebInspector.domAgent.addEventListener(WebInspector.DOMAgent.Events.ChildNodeCountUpdated, this._childNodeCountUpdated, this);
+    WebInspector.domModel.addEventListener(WebInspector.DOMModel.Events.NodeInserted, this._nodeInserted, this);
+    WebInspector.domModel.addEventListener(WebInspector.DOMModel.Events.NodeRemoved, this._nodeRemoved, this);
+    WebInspector.domModel.addEventListener(WebInspector.DOMModel.Events.AttrModified, this._attributesUpdated, this);
+    WebInspector.domModel.addEventListener(WebInspector.DOMModel.Events.AttrRemoved, this._attributesUpdated, this);
+    WebInspector.domModel.addEventListener(WebInspector.DOMModel.Events.CharacterDataModified, this._characterDataModified, this);
+    WebInspector.domModel.addEventListener(WebInspector.DOMModel.Events.DocumentUpdated, this._documentUpdated, this);
+    WebInspector.domModel.addEventListener(WebInspector.DOMModel.Events.ChildNodeCountUpdated, this._childNodeCountUpdated, this);
 
     this._treeOutline = treeOutline;
     /** @type {!Map.<!WebInspector.DOMNode, !WebInspector.ElementsTreeUpdater.UpdateEntry>} */
     this._recentlyModifiedNodes = new Map();
 }
 
 WebInspector.ElementsTreeUpdater.prototype = {
     /**
      * @param {!WebInspector.DOMNode} node
      * @param {boolean} isUpdated
@@ skipping 120 matching lines @@
         }
         this._recentlyModifiedNodes.clear();
 
         this._treeOutline._fireElementsTreeUpdated(nodes);
     },
 
     _reset: function()
     {
         this._treeOutline.rootDOMNode = null;
         this._treeOutline.selectDOMNode(null, false);
-        WebInspector.domAgent.hideDOMNodeHighlight();
+        WebInspector.domModel.hideDOMNodeHighlight();
         this._recentlyModifiedNodes.clear();
     }
 }
 
 /**
  * @constructor
  * @param {boolean} isUpdated
  * @param {!WebInspector.DOMNode=} parent
  */
 WebInspector.ElementsTreeUpdater.UpdateEntry = function(isUpdated, parent)
@@ skipping 23 matching lines @@
         var treeOutline = new WebInspector.ElementsTreeOutline(false, false);
         treeOutline.rootDOMNode = /** @type {!WebInspector.DOMNode} */ (object);
         treeOutline.element.classList.add("outline-disclosure");
         if (!treeOutline.children[0].hasChildren)
             treeOutline.element.classList.add("single-node");
         treeOutline.setVisible(true);
         treeOutline.element.treeElementForTest = treeOutline.children[0];
         return treeOutline.element;
     }
 }