DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/sdk/ApplicationCacheModel.js

 /*
  * Copyright (C) 2011 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:
  *
  * 1. Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *
@@ skipping 11 matching lines @@
  * 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.
  */
 
 /**
  * @unrestricted
  */
-WebInspector.ApplicationCacheModel = class extends WebInspector.SDKModel {
+SDK.ApplicationCacheModel = class extends SDK.SDKModel {
   /**
-   * @param {!WebInspector.Target} target
-   * @param {!WebInspector.ResourceTreeModel} resourceTreeModel
+   * @param {!SDK.Target} target
+   * @param {!SDK.ResourceTreeModel} resourceTreeModel
    */
   constructor(target, resourceTreeModel) {
-    super(WebInspector.ApplicationCacheModel, target);
+    super(SDK.ApplicationCacheModel, target);
 
-    target.registerApplicationCacheDispatcher(new WebInspector.ApplicationCacheDispatcher(this));
+    target.registerApplicationCacheDispatcher(new SDK.ApplicationCacheDispatcher(this));
     this._agent = target.applicationCacheAgent();
     this._agent.enable();
 
     resourceTreeModel.addEventListener(
-        WebInspector.ResourceTreeModel.Events.FrameNavigated, this._frameNavigated, this);
-    resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.Events.FrameDetached, this._frameDetached, this);
+        SDK.ResourceTreeModel.Events.FrameNavigated, this._frameNavigated, this);
+    resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.FrameDetached, this._frameDetached, this);
 
     this._statuses = {};
     this._manifestURLsByFrame = {};
 
     this._mainFrameNavigated();
     this._onLine = true;
   }
 
   /**
-   * @param {!WebInspector.Target} target
-   * @return {?WebInspector.ApplicationCacheModel}
+   * @param {!SDK.Target} target
+   * @return {?SDK.ApplicationCacheModel}
    */
   static fromTarget(target) {
-    return /** @type {?WebInspector.ApplicationCacheModel} */ (target.model(WebInspector.ApplicationCacheModel));
+    return /** @type {?SDK.ApplicationCacheModel} */ (target.model(SDK.ApplicationCacheModel));
   }
 
   _frameNavigated(event) {
-    var frame = /** @type {!WebInspector.ResourceTreeFrame} */ (event.data);
+    var frame = /** @type {!SDK.ResourceTreeFrame} */ (event.data);
     if (frame.isMainFrame()) {
       this._mainFrameNavigated();
       return;
     }
 
     this._agent.getManifestForFrame(frame.id, this._manifestForFrameLoaded.bind(this, frame.id));
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _frameDetached(event) {
-    var frame = /** @type {!WebInspector.ResourceTreeFrame} */ (event.data);
+    var frame = /** @type {!SDK.ResourceTreeFrame} */ (event.data);
     this._frameManifestRemoved(frame.id);
   }
 
   reset() {
     this._statuses = {};
     this._manifestURLsByFrame = {};
-    this.dispatchEventToListeners(WebInspector.ApplicationCacheModel.Events.FrameManifestsReset);
+    this.dispatchEventToListeners(SDK.ApplicationCacheModel.Events.FrameManifestsReset);
   }
 
   _mainFrameNavigated() {
     this._agent.getFramesWithManifests(this._framesWithManifestsLoaded.bind(this));
   }
 
   /**
    * @param {string} frameId
    * @param {?Protocol.Error} error
    * @param {string} manifestURL
@@ skipping 38 matching lines @@
       return;
 
     if (this._manifestURLsByFrame[frameId] && manifestURL !== this._manifestURLsByFrame[frameId])
       this._frameManifestRemoved(frameId);
 
     var statusChanged = this._statuses[frameId] !== status;
     this._statuses[frameId] = status;
 
     if (!this._manifestURLsByFrame[frameId]) {
       this._manifestURLsByFrame[frameId] = manifestURL;
-      this.dispatchEventToListeners(WebInspector.ApplicationCacheModel.Events.FrameManifestAdded, frameId);
+      this.dispatchEventToListeners(SDK.ApplicationCacheModel.Events.FrameManifestAdded, frameId);
     }
 
     if (statusChanged)
-      this.dispatchEventToListeners(WebInspector.ApplicationCacheModel.Events.FrameManifestStatusUpdated, frameId);
+      this.dispatchEventToListeners(SDK.ApplicationCacheModel.Events.FrameManifestStatusUpdated, frameId);
   }
 
   /**
    * @param {string} frameId
    */
   _frameManifestRemoved(frameId) {
     if (!this._manifestURLsByFrame[frameId])
       return;
 
     delete this._manifestURLsByFrame[frameId];
     delete this._statuses[frameId];
 
-    this.dispatchEventToListeners(WebInspector.ApplicationCacheModel.Events.FrameManifestRemoved, frameId);
+    this.dispatchEventToListeners(SDK.ApplicationCacheModel.Events.FrameManifestRemoved, frameId);
   }
 
   /**
    * @param {string} frameId
    * @return {string}
    */
   frameManifestURL(frameId) {
     return this._manifestURLsByFrame[frameId] || '';
   }
 
@@ skipping 41 matching lines @@
     }
 
     this._agent.getApplicationCacheForFrame(frameId, callbackWrapper);
   }
 
   /**
    * @param {boolean} isNowOnline
    */
   _networkStateUpdated(isNowOnline) {
     this._onLine = isNowOnline;
-    this.dispatchEventToListeners(WebInspector.ApplicationCacheModel.Events.NetworkStateChanged, isNowOnline);
+    this.dispatchEventToListeners(SDK.ApplicationCacheModel.Events.NetworkStateChanged, isNowOnline);
   }
 };
 
 /** @enum {symbol} */
-WebInspector.ApplicationCacheModel.Events = {
+SDK.ApplicationCacheModel.Events = {
   FrameManifestStatusUpdated: Symbol('FrameManifestStatusUpdated'),
   FrameManifestAdded: Symbol('FrameManifestAdded'),
   FrameManifestRemoved: Symbol('FrameManifestRemoved'),
   FrameManifestsReset: Symbol('FrameManifestsReset'),
   NetworkStateChanged: Symbol('NetworkStateChanged')
 };
 
 /**
  * @implements {Protocol.ApplicationCacheDispatcher}
  * @unrestricted
  */
-WebInspector.ApplicationCacheDispatcher = class {
+SDK.ApplicationCacheDispatcher = class {
   constructor(applicationCacheModel) {
     this._applicationCacheModel = applicationCacheModel;
   }
 
   /**
    * @override
    * @param {string} frameId
    * @param {string} manifestURL
    * @param {number} status
    */
   applicationCacheStatusUpdated(frameId, manifestURL, status) {
     this._applicationCacheModel._statusUpdated(frameId, manifestURL, status);
   }
 
   /**
    * @override
    * @param {boolean} isNowOnline
    */
   networkStateUpdated(isNowOnline) {
     this._applicationCacheModel._networkStateUpdated(isNowOnline);
   }
 };