DevTools: Rename WebInspector.DOMAgent into WebInspector.DOMModel

Source/devtools/front_end/CSSStyleModel.js

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * 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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 20 matching lines @@
 /**
  * @constructor
  * @extends {WebInspector.Object}
  * @param {!WebInspector.Workspace} workspace
  */
 WebInspector.CSSStyleModel = function(workspace)
 {
     this._workspace = workspace;
     this._pendingCommandsMajorState = [];
     this._styleLoader = new WebInspector.CSSStyleModel.ComputedStyleLoader(this);
-    WebInspector.domAgent.addEventListener(WebInspector.DOMAgent.Events.UndoRedoRequested, this._undoRedoRequested, this);
-    WebInspector.domAgent.addEventListener(WebInspector.DOMAgent.Events.UndoRedoCompleted, this._undoRedoCompleted, this);
+    WebInspector.domModel.addEventListener(WebInspector.DOMModel.Events.UndoRedoRequested, this._undoRedoRequested, this);
+    WebInspector.domModel.addEventListener(WebInspector.DOMModel.Events.UndoRedoCompleted, this._undoRedoCompleted, this);
     WebInspector.resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.MainFrameCreatedOrNavigated, this._mainFrameCreatedOrNavigated, this);
     InspectorBackend.registerCSSDispatcher(new WebInspector.CSSDispatcher(this));
     CSSAgent.enable(this._wasEnabled.bind(this));
     this._resetStyleSheets();
 }
 
 /**
  * @param {!Array.<!CSSAgent.RuleMatch>|undefined} matchArray
  */
 WebInspector.CSSStyleModel.parseRuleMatchArrayPayload = function(matchArray)
@@ skipping 186 matching lines @@
          * @param {!CSSAgent.CSSRule} rulePayload
          * @this {WebInspector.CSSStyleModel}
          */
         function callback(nodeId, successCallback, failureCallback, newSelector, error, rulePayload)
         {
             this._pendingCommandsMajorState.pop();
             if (error) {
                 failureCallback();
                 return;
             }
-            WebInspector.domAgent.markUndoableState();
+            WebInspector.domModel.markUndoableState();
             this._computeMatchingSelectors(rulePayload, nodeId, successCallback, failureCallback);
         }
 
 
         this._pendingCommandsMajorState.push(true);
         CSSAgent.setRuleSelector(ruleId, newSelector, callback.bind(this, nodeId, successCallback, failureCallback, newSelector));
     },
 
     /**
      * @param {!CSSAgent.CSSRule} rulePayload
      * @param {!DOMAgent.NodeId} nodeId
      * @param {function(!WebInspector.CSSRule)} successCallback
      * @param {function()} failureCallback
      */
     _computeMatchingSelectors: function(rulePayload, nodeId, successCallback, failureCallback)
     {
         var ownerDocumentId = this._ownerDocumentId(nodeId);
         if (!ownerDocumentId) {
             failureCallback();
             return;
         }
         var rule = WebInspector.CSSRule.parsePayload(rulePayload);
         var matchingSelectors = [];
         var allSelectorsBarrier = new CallbackBarrier();
         for (var i = 0; i < rule.selectors.length; ++i) {
             var selector = rule.selectors[i];
             var boundCallback = allSelectorsBarrier.createCallback(selectorQueried.bind(null, i, nodeId, matchingSelectors));
-            WebInspector.domAgent.querySelectorAll(ownerDocumentId, selector.value, boundCallback);
+            WebInspector.domModel.querySelectorAll(ownerDocumentId, selector.value, boundCallback);
         }
         allSelectorsBarrier.callWhenDone(function() {
             rule.matchingSelectors = matchingSelectors;
             successCallback(rule);
         });
 
         /**
          * @param {number} index
          * @param {!DOMAgent.NodeId} nodeId
          * @param {!Array.<number>} matchingSelectors
@@ skipping 25 matching lines @@
          * @param {!CSSAgent.CSSRule} rulePayload
          * @this {WebInspector.CSSStyleModel}
          */
         function callback(error, rulePayload)
         {
             this._pendingCommandsMajorState.pop();
             if (error) {
                 // Invalid syntax for a selector
                 failureCallback();
             } else {
-                WebInspector.domAgent.markUndoableState();
+                WebInspector.domModel.markUndoableState();
                 this._computeMatchingSelectors(rulePayload, node.id, successCallback, failureCallback);
             }
         }
     },
 
     /**
      * @param {!WebInspector.DOMNode} node
      * @param {function(?WebInspector.CSSStyleSheetHeader)} callback
      */
     requestViaInspectorStylesheet: function(node, callback)
@@ skipping 46 matching lines @@
     {
         return Object.values(this._styleSheetIdToHeader);
     },
 
     /**
      * @param {!DOMAgent.NodeId} nodeId
      * @return {?DOMAgent.NodeId}
      */
     _ownerDocumentId: function(nodeId)
     {
-        var node = WebInspector.domAgent.nodeForId(nodeId);
+        var node = WebInspector.domModel.nodeForId(nodeId);
         if (!node)
             return null;
         return node.ownerDocument ? node.ownerDocument.id : null;
     },
 
     /**
      * @param {!CSSAgent.StyleSheetId} styleSheetId
      */
     _fireStyleSheetChanged: function(styleSheetId)
     {
@@ skipping 90 matching lines @@
         header.setContent(newText, callback.bind(this));
 
         /**
          * @param {?Protocol.Error} error
          * @this {WebInspector.CSSStyleModel}
          */
         function callback(error)
         {
             this._pendingCommandsMajorState.pop();
             if (!error && majorChange)
-                WebInspector.domAgent.markUndoableState();
+                WebInspector.domModel.markUndoableState();
             
             if (!error && userCallback)
                 userCallback(error);
         }
     },
 
     _undoRedoRequested: function()
     {
         this._pendingCommandsMajorState.push(true);
     },
@@ skipping 605 matching lines @@
         /**
          * @param {?string} error
          * @param {!CSSAgent.CSSStyle} stylePayload
          * @this {WebInspector.CSSProperty}
          */
         function callback(error, stylePayload)
         {
             WebInspector.cssModel._pendingCommandsMajorState.pop();
             if (!error) {
                 if (majorChange)
-                    WebInspector.domAgent.markUndoableState();
+                    WebInspector.domModel.markUndoableState();
                 var style = WebInspector.CSSStyleDeclaration.parsePayload(stylePayload);
                 var newProperty = style.allProperties[this.index];
 
                 if (newProperty && this.disabled && !propertyText.match(/^\s*$/)) {
                     newProperty.setDisabled(false, enabledCallback);
                     return;
                 }
                 if (userCallback)
                     userCallback(style);
             } else {
@@ skipping 431 matching lines @@
             for (var i = 0; i < callbacks.length; ++i)
                 callbacks[i](computedStyle);
         }
     }
 }
 
 /**
  * @type {!WebInspector.CSSStyleModel}
  */
 WebInspector.cssModel;