DevTools: rename WebInspector into modules.

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

 /*
  * Copyright (C) 2009 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 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * 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.
  */
 /**
- * @typedef {{object: ?WebInspector.RemoteObject, wasThrown: (boolean|undefined)}}
+ * @typedef {{object: ?SDK.RemoteObject, wasThrown: (boolean|undefined)}}
  */
-WebInspector.CallFunctionResult;
+SDK.CallFunctionResult;
 
 /**
  * @unrestricted
  */
-WebInspector.RemoteObject = class {
+SDK.RemoteObject = class {
   /**
-   * This may not be an interface due to "instanceof WebInspector.RemoteObject" checks in the code.
+   * This may not be an interface due to "instanceof SDK.RemoteObject" checks in the code.
    */
 
   /**
    * @param {*} value
-   * @return {!WebInspector.RemoteObject}
+   * @return {!SDK.RemoteObject}
    */
   static fromLocalObject(value) {
-    return new WebInspector.LocalJSONObject(value);
+    return new SDK.LocalJSONObject(value);
   }
 
   /**
-   * @param {!WebInspector.RemoteObject} remoteObject
+   * @param {!SDK.RemoteObject} remoteObject
    * @return {string}
    */
   static type(remoteObject) {
     if (remoteObject === null)
       return 'null';
 
     var type = typeof remoteObject;
     if (type !== 'object' && type !== 'function')
       return type;
 
     return remoteObject.type;
   }
 
   /**
-   * @param {!WebInspector.RemoteObject|!Protocol.Runtime.RemoteObject|!Protocol.Runtime.ObjectPreview} object
+   * @param {!SDK.RemoteObject|!Protocol.Runtime.RemoteObject|!Protocol.Runtime.ObjectPreview} object
    * @return {number}
    */
   static arrayLength(object) {
     if (object.subtype !== 'array' && object.subtype !== 'typedarray')
       return 0;
     var matches = object.description.match(/\[([0-9]+)\]/);
     if (!matches)
       return 0;
     return parseInt(matches[1], 10);
   }
 
   /**
-   * @param {!Protocol.Runtime.RemoteObject|!WebInspector.RemoteObject|number|string|boolean|undefined|null} object
+   * @param {!Protocol.Runtime.RemoteObject|!SDK.RemoteObject|number|string|boolean|undefined|null} object
    * @return {!Protocol.Runtime.CallArgument}
    */
   static toCallArgument(object) {
     var type = typeof object;
     if (type === 'undefined')
       return {};
     if (type === 'number') {
       var description = String(object);
       if (object === 0 && 1 / object < 0)
         return {unserializableValue: Protocol.Runtime.UnserializableValue.Negative0};
@@ skipping 18 matching lines @@
 
     if (typeof object.objectId !== 'undefined')
       return {objectId: object.objectId};
     if (typeof object._objectId !== 'undefined')
       return {objectId: object._objectId};
 
     return {value: object.value};
   }
 
   /**
-   * @param {!WebInspector.RemoteObject} object
-   * @param {function(?Array.<!WebInspector.RemoteObjectProperty>, ?Array.<!WebInspector.RemoteObjectProperty>)} callback
+   * @param {!SDK.RemoteObject} object
+   * @param {function(?Array.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
    */
   static loadFromObjectPerProto(object, callback) {
     // Combines 2 asynch calls. Doesn't rely on call-back orders (some calls may be loop-back).
     var savedOwnProperties;
     var savedAccessorProperties;
     var savedInternalProperties;
     var resultCounter = 2;
 
     function processCallback() {
       if (--resultCounter)
@@ skipping 19 matching lines @@
         }
         return callback(
             propertiesMap.valuesArray().concat(propertySymbols),
             savedInternalProperties ? savedInternalProperties : null);
       } else {
         callback(null, null);
       }
     }
 
     /**
-     * @param {?Array.<!WebInspector.RemoteObjectProperty>} properties
-     * @param {?Array.<!WebInspector.RemoteObjectProperty>} internalProperties
+     * @param {?Array.<!SDK.RemoteObjectProperty>} properties
+     * @param {?Array.<!SDK.RemoteObjectProperty>} internalProperties
      */
     function allAccessorPropertiesCallback(properties, internalProperties) {
       savedAccessorProperties = properties;
       processCallback();
     }
 
     /**
-     * @param {?Array.<!WebInspector.RemoteObjectProperty>} properties
-     * @param {?Array.<!WebInspector.RemoteObjectProperty>} internalProperties
+     * @param {?Array.<!SDK.RemoteObjectProperty>} properties
+     * @param {?Array.<!SDK.RemoteObjectProperty>} internalProperties
      */
     function ownPropertiesCallback(properties, internalProperties) {
       savedOwnProperties = properties;
       savedInternalProperties = internalProperties;
       processCallback();
     }
 
     object.getAllProperties(true, allAccessorPropertiesCallback);
     object.getOwnProperties(ownPropertiesCallback);
   }
@@ skipping 26 matching lines @@
   }
 
   /**
    * @return {number}
    */
   arrayLength() {
     throw 'Not implemented';
   }
 
   /**
-   * @param {function(?Array.<!WebInspector.RemoteObjectProperty>, ?Array.<!WebInspector.RemoteObjectProperty>)} callback
+   * @param {function(?Array.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
    */
   getOwnProperties(callback) {
     throw 'Not implemented';
   }
 
   /**
-   * @return {!Promise<!{properties: ?Array.<!WebInspector.RemoteObjectProperty>, internalProperties: ?Array.<!WebInspector.RemoteObjectProperty>}>}
+   * @return {!Promise<!{properties: ?Array.<!SDK.RemoteObjectProperty>, internalProperties: ?Array.<!SDK.RemoteObjectProperty>}>}
    */
   getOwnPropertiesPromise() {
     return new Promise(promiseConstructor.bind(this));
 
     /**
-     * @param {function(!{properties: ?Array.<!WebInspector.RemoteObjectProperty>, internalProperties: ?Array.<!WebInspector.RemoteObjectProperty>})} success
-     * @this {WebInspector.RemoteObject}
+     * @param {function(!{properties: ?Array.<!SDK.RemoteObjectProperty>, internalProperties: ?Array.<!SDK.RemoteObjectProperty>})} success
+     * @this {SDK.RemoteObject}
      */
     function promiseConstructor(success) {
       this.getOwnProperties(getOwnPropertiesCallback.bind(null, success));
     }
 
     /**
-     * @param {function(!{properties: ?Array.<!WebInspector.RemoteObjectProperty>, internalProperties: ?Array.<!WebInspector.RemoteObjectProperty>})} callback
-     * @param {?Array.<!WebInspector.RemoteObjectProperty>} properties
-     * @param {?Array.<!WebInspector.RemoteObjectProperty>} internalProperties
+     * @param {function(!{properties: ?Array.<!SDK.RemoteObjectProperty>, internalProperties: ?Array.<!SDK.RemoteObjectProperty>})} callback
+     * @param {?Array.<!SDK.RemoteObjectProperty>} properties
+     * @param {?Array.<!SDK.RemoteObjectProperty>} internalProperties
      */
     function getOwnPropertiesCallback(callback, properties, internalProperties) {
       callback({properties: properties, internalProperties: internalProperties});
     }
   }
 
   /**
    * @param {boolean} accessorPropertiesOnly
-   * @param {function(?Array<!WebInspector.RemoteObjectProperty>, ?Array<!WebInspector.RemoteObjectProperty>)} callback
+   * @param {function(?Array<!SDK.RemoteObjectProperty>, ?Array<!SDK.RemoteObjectProperty>)} callback
    */
   getAllProperties(accessorPropertiesOnly, callback) {
     throw 'Not implemented';
   }
 
   /**
    * @param {boolean} accessorPropertiesOnly
-   * @return {!Promise<!{properties: ?Array<!WebInspector.RemoteObjectProperty>, internalProperties: ?Array<!WebInspector.RemoteObjectProperty>}>}
+   * @return {!Promise<!{properties: ?Array<!SDK.RemoteObjectProperty>, internalProperties: ?Array<!SDK.RemoteObjectProperty>}>}
    */
   getAllPropertiesPromise(accessorPropertiesOnly) {
     return new Promise(promiseConstructor.bind(this));
 
     /**
-     * @param {function(!{properties: ?Array<!WebInspector.RemoteObjectProperty>, internalProperties: ?Array.<!WebInspector.RemoteObjectProperty>})} success
-     * @this {WebInspector.RemoteObject}
+     * @param {function(!{properties: ?Array<!SDK.RemoteObjectProperty>, internalProperties: ?Array.<!SDK.RemoteObjectProperty>})} success
+     * @this {SDK.RemoteObject}
      */
     function promiseConstructor(success) {
       this.getAllProperties(accessorPropertiesOnly, getAllPropertiesCallback.bind(null, success));
     }
 
     /**
-     * @param {function(!{properties: ?Array<!WebInspector.RemoteObjectProperty>, internalProperties: ?Array<!WebInspector.RemoteObjectProperty>})} callback
-     * @param {?Array<!WebInspector.RemoteObjectProperty>} properties
-     * @param {?Array<!WebInspector.RemoteObjectProperty>} internalProperties
+     * @param {function(!{properties: ?Array<!SDK.RemoteObjectProperty>, internalProperties: ?Array<!SDK.RemoteObjectProperty>})} callback
+     * @param {?Array<!SDK.RemoteObjectProperty>} properties
+     * @param {?Array<!SDK.RemoteObjectProperty>} internalProperties
      */
     function getAllPropertiesCallback(callback, properties, internalProperties) {
       callback({properties: properties, internalProperties: internalProperties});
     }
   }
 
   /**
-   * @return {!Promise<?Array<!WebInspector.EventListener>>}
+   * @return {!Promise<?Array<!SDK.EventListener>>}
    */
   eventListeners() {
     throw 'Not implemented';
   }
 
   /**
    * @param {!Protocol.Runtime.CallArgument} name
    * @param {function(string=)} callback
    */
   deleteProperty(name, callback) {
     throw 'Not implemented';
   }
 
   /**
    * @param {string|!Protocol.Runtime.CallArgument} name
    * @param {string} value
    * @param {function(string=)} callback
    */
   setPropertyValue(name, value, callback) {
     throw 'Not implemented';
   }
 
   /**
    * @param {function(this:Object, ...)} functionDeclaration
    * @param {!Array<!Protocol.Runtime.CallArgument>=} args
-   * @param {function(?WebInspector.RemoteObject, boolean=)=} callback
+   * @param {function(?SDK.RemoteObject, boolean=)=} callback
    */
   callFunction(functionDeclaration, args, callback) {
     throw 'Not implemented';
   }
 
   /**
    * @param {function(this:Object, ...)} functionDeclaration
    * @param {!Array<!Protocol.Runtime.CallArgument>=} args
-   * @return {!Promise<!WebInspector.CallFunctionResult>}
+   * @return {!Promise<!SDK.CallFunctionResult>}
    */
   callFunctionPromise(functionDeclaration, args) {
     return new Promise(promiseConstructor.bind(this));
 
     /**
-     * @param {function(!WebInspector.CallFunctionResult)} success
-     * @this {WebInspector.RemoteObject}
+     * @param {function(!SDK.CallFunctionResult)} success
+     * @this {SDK.RemoteObject}
      */
     function promiseConstructor(success) {
       this.callFunction(functionDeclaration, args, callFunctionCallback.bind(null, success));
     }
 
     /**
-     * @param {function(!WebInspector.CallFunctionResult)} callback
-     * @param {?WebInspector.RemoteObject} object
+     * @param {function(!SDK.CallFunctionResult)} callback
+     * @param {?SDK.RemoteObject} object
      * @param {boolean=} wasThrown
      */
     function callFunctionCallback(callback, object, wasThrown) {
       callback({object: object, wasThrown: wasThrown});
     }
   }
 
   /**
    * @template T
    * @param {function(this:Object, ...):T} functionDeclaration
    * @param {!Array<!Protocol.Runtime.CallArgument>|undefined} args
    * @param {function(T)} callback
    */
   callFunctionJSON(functionDeclaration, args, callback) {
     throw 'Not implemented';
   }
 
   /**
    * @param {function(this:Object, ...):T} functionDeclaration
    * @param {!Array<!Protocol.Runtime.CallArgument>|undefined} args
    * @return {!Promise<T>}
    * @template T
    */
   callFunctionJSONPromise(functionDeclaration, args) {
     return new Promise(promiseConstructor.bind(this));
 
     /**
-     * @this {WebInspector.RemoteObject}
+     * @this {SDK.RemoteObject}
      */
     function promiseConstructor(success) {
       this.callFunctionJSON(functionDeclaration, args, success);
     }
   }
 
   /**
-   * @return {!WebInspector.Target}
+   * @return {!SDK.Target}
    */
   target() {
     throw new Error('Target-less object');
   }
 
   /**
-   * @return {?WebInspector.DebuggerModel}
+   * @return {?SDK.DebuggerModel}
    */
   debuggerModel() {
     throw new Error('DebuggerModel-less object');
   }
 
   /**
    * @return {boolean}
    */
   isNode() {
     return false;
   }
 };
 
 
 /**
  * @unrestricted
  */
-WebInspector.RemoteObjectImpl = class extends WebInspector.RemoteObject {
+SDK.RemoteObjectImpl = class extends SDK.RemoteObject {
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    * @param {string|undefined} objectId
    * @param {string} type
    * @param {string|undefined} subtype
    * @param {*} value
    * @param {!Protocol.Runtime.UnserializableValue=} unserializableValue
    * @param {string=} description
    * @param {!Protocol.Runtime.ObjectPreview=} preview
    * @param {!Protocol.Runtime.CustomPreview=} customPreview
    */
   constructor(target, objectId, type, subtype, value, unserializableValue, description, preview, customPreview) {
     super();
 
     this._target = target;
     this._runtimeAgent = target.runtimeAgent();
-    this._debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
+    this._debuggerModel = SDK.DebuggerModel.fromTarget(target);
 
     this._type = type;
     this._subtype = subtype;
     if (objectId) {
       // handle
       this._objectId = objectId;
       this._description = description;
       this._hasChildren = (type !== 'symbol');
       this._preview = preview;
     } else {
@@ skipping 65 matching lines @@
 
   /**
    * @return {!Protocol.Runtime.ObjectPreview|undefined}
    */
   get preview() {
     return this._preview;
   }
 
   /**
    * @override
-   * @param {function(?Array.<!WebInspector.RemoteObjectProperty>, ?Array.<!WebInspector.RemoteObjectProperty>)} callback
+   * @param {function(?Array.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
    */
   getOwnProperties(callback) {
     this.doGetProperties(true, false, false, callback);
   }
 
   /**
    * @override
    * @param {boolean} accessorPropertiesOnly
-   * @param {function(?Array.<!WebInspector.RemoteObjectProperty>, ?Array.<!WebInspector.RemoteObjectProperty>)} callback
+   * @param {function(?Array.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
    */
   getAllProperties(accessorPropertiesOnly, callback) {
     this.doGetProperties(false, accessorPropertiesOnly, false, callback);
   }
 
   /**
    * @override
-   * @return {!Promise<?Array<!WebInspector.EventListener>>}
+   * @return {!Promise<?Array<!SDK.EventListener>>}
    */
   eventListeners() {
     return new Promise(eventListeners.bind(this));
     /**
      * @param {function(?)} fulfill
      * @param {function(*)} reject
-     * @this {WebInspector.RemoteObjectImpl}
+     * @this {SDK.RemoteObjectImpl}
      */
     function eventListeners(fulfill, reject) {
       if (!this.target().hasDOMCapability()) {
         // TODO(kozyatinskiy): figure out how this should work for |window| when there is no DOMDebugger.
         fulfill([]);
         return;
       }
 
       if (!this._objectId) {
         reject(new Error('No object id specified'));
         return;
       }
 
       this.target().domdebuggerAgent().getEventListeners(this._objectId, mycallback.bind(this));
 
       /**
-       * @this {WebInspector.RemoteObjectImpl}
+       * @this {SDK.RemoteObjectImpl}
        * @param {?Protocol.Error} error
        * @param {!Array<!Protocol.DOMDebugger.EventListener>} payloads
        */
       function mycallback(error, payloads) {
         if (error) {
           reject(new Error(error));
           return;
         }
         fulfill(payloads.map(createEventListener.bind(this)));
       }
 
       /**
-       * @this {WebInspector.RemoteObjectImpl}
+       * @this {SDK.RemoteObjectImpl}
        * @param {!Protocol.DOMDebugger.EventListener} payload
        */
       function createEventListener(payload) {
-        return new WebInspector.EventListener(
+        return new SDK.EventListener(
             this._target, this, payload.type, payload.useCapture, payload.passive, payload.once,
             payload.handler ? this.target().runtimeModel.createRemoteObject(payload.handler) : null,
             payload.originalHandler ? this.target().runtimeModel.createRemoteObject(payload.originalHandler) : null,
-            /** @type {!WebInspector.DebuggerModel.Location} */ (this._debuggerModel.createRawLocationByScriptId(
+            /** @type {!SDK.DebuggerModel.Location} */ (this._debuggerModel.createRawLocationByScriptId(
                 payload.scriptId, payload.lineNumber, payload.columnNumber)),
             payload.removeFunction ? this.target().runtimeModel.createRemoteObject(payload.removeFunction) : null);
       }
     }
   }
 
   /**
    * @param {!Array.<string>} propertyPath
-   * @param {function(?WebInspector.RemoteObject, boolean=)} callback
+   * @param {function(?SDK.RemoteObject, boolean=)} callback
    */
   getProperty(propertyPath, callback) {
     /**
      * @param {string} arrayStr
      * @suppressReceiverCheck
      * @this {Object}
      */
     function remoteFunction(arrayStr) {
       var result = this;
       var properties = JSON.parse(arrayStr);
       for (var i = 0, n = properties.length; i < n; ++i)
         result = result[properties[i]];
       return result;
     }
 
     var args = [{value: JSON.stringify(propertyPath)}];
     this.callFunction(remoteFunction, args, callback);
   }
 
   /**
    * @param {boolean} ownProperties
    * @param {boolean} accessorPropertiesOnly
    * @param {boolean} generatePreview
-   * @param {function(?Array.<!WebInspector.RemoteObjectProperty>, ?Array.<!WebInspector.RemoteObjectProperty>)} callback
+   * @param {function(?Array.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
    */
   doGetProperties(ownProperties, accessorPropertiesOnly, generatePreview, callback) {
     if (!this._objectId) {
       callback(null, null);
       return;
     }
 
     /**
      * @param {?Protocol.Error} error
      * @param {!Array.<!Protocol.Runtime.PropertyDescriptor>} properties
      * @param {!Array.<!Protocol.Runtime.InternalPropertyDescriptor>=} internalProperties
      * @param {?Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @this {WebInspector.RemoteObjectImpl}
+     * @this {SDK.RemoteObjectImpl}
      */
     function remoteObjectBinder(error, properties, internalProperties, exceptionDetails) {
       if (error) {
         callback(null, null);
         return;
       }
       if (exceptionDetails) {
         this._target.consoleModel.addMessage(
-            WebInspector.ConsoleMessage.fromException(this._target, exceptionDetails, undefined, undefined, undefined));
+            SDK.ConsoleMessage.fromException(this._target, exceptionDetails, undefined, undefined, undefined));
         callback(null, null);
         return;
       }
       var result = [];
       for (var i = 0; properties && i < properties.length; ++i) {
         var property = properties[i];
         var propertyValue = property.value ? this._target.runtimeModel.createRemoteObject(property.value) : null;
         var propertySymbol = property.symbol ? this._target.runtimeModel.createRemoteObject(property.symbol) : null;
-        var remoteProperty = new WebInspector.RemoteObjectProperty(
+        var remoteProperty = new SDK.RemoteObjectProperty(
             property.name, propertyValue, !!property.enumerable, !!property.writable, !!property.isOwn,
             !!property.wasThrown, propertySymbol);
 
         if (typeof property.value === 'undefined') {
           if (property.get && property.get.type !== 'undefined')
             remoteProperty.getter = this._target.runtimeModel.createRemoteObject(property.get);
           if (property.set && property.set.type !== 'undefined')
             remoteProperty.setter = this._target.runtimeModel.createRemoteObject(property.set);
         }
 
         result.push(remoteProperty);
       }
       var internalPropertiesResult = null;
       if (internalProperties) {
         internalPropertiesResult = [];
         for (var i = 0; i < internalProperties.length; i++) {
           var property = internalProperties[i];
           if (!property.value)
             continue;
           var propertyValue = this._target.runtimeModel.createRemoteObject(property.value);
           internalPropertiesResult.push(
-              new WebInspector.RemoteObjectProperty(property.name, propertyValue, true, false));
+              new SDK.RemoteObjectProperty(property.name, propertyValue, true, false));
         }
       }
       callback(result, internalPropertiesResult);
     }
     this._runtimeAgent.getProperties(
         this._objectId, ownProperties, accessorPropertiesOnly, generatePreview, remoteObjectBinder.bind(this));
   }
 
   /**
    * @override
    * @param {string|!Protocol.Runtime.CallArgument} name
    * @param {string} value
    * @param {function(string=)} callback
    */
   setPropertyValue(name, value, callback) {
     if (!this._objectId) {
       callback('Can\'t set a property of non-object.');
       return;
     }
 
     this._runtimeAgent.invoke_evaluate({expression: value, silent: true}, evaluatedCallback.bind(this));
 
     /**
      * @param {?Protocol.Error} error
      * @param {!Protocol.Runtime.RemoteObject} result
      * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @this {WebInspector.RemoteObject}
+     * @this {SDK.RemoteObject}
      */
     function evaluatedCallback(error, result, exceptionDetails) {
       if (error || !!exceptionDetails) {
         callback(error || (result.type !== 'string' ? result.description : /** @type {string} */ (result.value)));
         return;
       }
 
       if (typeof name === 'string')
-        name = WebInspector.RemoteObject.toCallArgument(name);
+        name = SDK.RemoteObject.toCallArgument(name);
 
       this.doSetObjectPropertyValue(result, name, callback);
 
       if (result.objectId)
         this._runtimeAgent.releaseObject(result.objectId);
     }
   }
 
   /**
    * @param {!Protocol.Runtime.RemoteObject} result
    * @param {!Protocol.Runtime.CallArgument} name
    * @param {function(string=)} callback
    */
   doSetObjectPropertyValue(result, name, callback) {
     // This assignment may be for a regular (data) property, and for an accessor property (with getter/setter).
     // Note the sensitive matter about accessor property: the property may be physically defined in some proto object,
     // but logically it is bound to the object in question. JavaScript passes this object to getters/setters, not the object
     // where property was defined; so do we.
     var setPropertyValueFunction = 'function(a, b) { this[a] = b; }';
 
-    var argv = [name, WebInspector.RemoteObject.toCallArgument(result)];
+    var argv = [name, SDK.RemoteObject.toCallArgument(result)];
     this._runtimeAgent.callFunctionOn(
         this._objectId, setPropertyValueFunction, argv, true, undefined, undefined, undefined, undefined,
         propertySetCallback);
 
     /**
      * @param {?Protocol.Error} error
      * @param {!Protocol.Runtime.RemoteObject} result
      * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
      */
     function propertySetCallback(error, result, exceptionDetails) {
@@ skipping 35 matching lines @@
         callback('Failed to delete property.');
       else
         callback();
     }
   }
 
   /**
    * @override
    * @param {function(this:Object, ...)} functionDeclaration
    * @param {!Array.<!Protocol.Runtime.CallArgument>=} args
-   * @param {function(?WebInspector.RemoteObject, boolean=)=} callback
+   * @param {function(?SDK.RemoteObject, boolean=)=} callback
    */
   callFunction(functionDeclaration, args, callback) {
     /**
      * @param {?Protocol.Error} error
      * @param {!Protocol.Runtime.RemoteObject} result
      * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @this {WebInspector.RemoteObjectImpl}
+     * @this {SDK.RemoteObjectImpl}
      */
     function mycallback(error, result, exceptionDetails) {
       if (!callback)
         return;
       if (error)
         callback(null, false);
       else
         callback(this.target().runtimeModel.createRemoteObject(result), !!exceptionDetails);
     }
 
@@ skipping 26 matching lines @@
     if (!this._objectId)
       return;
     this._runtimeAgent.releaseObject(this._objectId);
   }
 
   /**
    * @override
    * @return {number}
    */
   arrayLength() {
-    return WebInspector.RemoteObject.arrayLength(this);
+    return SDK.RemoteObject.arrayLength(this);
   }
 
   /**
    * @override
-   * @return {!WebInspector.Target}
+   * @return {!SDK.Target}
    */
   target() {
     return this._target;
   }
 
   /**
    * @override
-   * @return {?WebInspector.DebuggerModel}
+   * @return {?SDK.DebuggerModel}
    */
   debuggerModel() {
     return this._debuggerModel;
   }
 
   /**
    * @override
    * @return {boolean}
    */
   isNode() {
     return !!this._objectId && this.type === 'object' && this.subtype === 'node';
   }
 };
 
 
 /**
  * @unrestricted
  */
-WebInspector.ScopeRemoteObject = class extends WebInspector.RemoteObjectImpl {
+SDK.ScopeRemoteObject = class extends SDK.RemoteObjectImpl {
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    * @param {string|undefined} objectId
-   * @param {!WebInspector.ScopeRef} scopeRef
+   * @param {!SDK.ScopeRef} scopeRef
    * @param {string} type
    * @param {string|undefined} subtype
    * @param {*} value
    * @param {!Protocol.Runtime.UnserializableValue=} unserializableValue
    * @param {string=} description
    * @param {!Protocol.Runtime.ObjectPreview=} preview
    */
   constructor(target, objectId, scopeRef, type, subtype, value, unserializableValue, description, preview) {
     super(target, objectId, type, subtype, value, unserializableValue, description, preview);
     this._scopeRef = scopeRef;
     this._savedScopeProperties = undefined;
   }
 
   /**
    * @override
    * @param {boolean} ownProperties
    * @param {boolean} accessorPropertiesOnly
    * @param {boolean} generatePreview
-   * @param {function(?Array.<!WebInspector.RemoteObjectProperty>, ?Array.<!WebInspector.RemoteObjectProperty>)} callback
+   * @param {function(?Array.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
    */
   doGetProperties(ownProperties, accessorPropertiesOnly, generatePreview, callback) {
     if (accessorPropertiesOnly) {
       callback([], []);
       return;
     }
 
     if (this._savedScopeProperties) {
       // No need to reload scope variables, as the remote object never
       // changes its properties. If variable is updated, the properties
       // array is patched locally.
       callback(this._savedScopeProperties.slice(), []);
       return;
     }
 
     /**
-     * @param {?Array.<!WebInspector.RemoteObjectProperty>} properties
-     * @param {?Array.<!WebInspector.RemoteObjectProperty>} internalProperties
-     * @this {WebInspector.ScopeRemoteObject}
+     * @param {?Array.<!SDK.RemoteObjectProperty>} properties
+     * @param {?Array.<!SDK.RemoteObjectProperty>} internalProperties
+     * @this {SDK.ScopeRemoteObject}
      */
     function wrappedCallback(properties, internalProperties) {
       if (this._scopeRef && Array.isArray(properties)) {
         this._savedScopeProperties = properties.slice();
         if (!this._scopeRef.callFrameId) {
           for (var property of this._savedScopeProperties)
             property.writable = false;
         }
       }
       callback(properties, internalProperties);
     }
 
     // Scope objects always fetch preview.
     generatePreview = true;
 
     super.doGetProperties(ownProperties, accessorPropertiesOnly, generatePreview, wrappedCallback.bind(this));
   }
 
   /**
    * @override
    * @param {!Protocol.Runtime.RemoteObject} result
    * @param {!Protocol.Runtime.CallArgument} argumentName
    * @param {function(string=)} callback
    */
   doSetObjectPropertyValue(result, argumentName, callback) {
     var name = /** @type {string} */ (argumentName.value);
     this._debuggerModel.setVariableValue(
-        this._scopeRef.number, name, WebInspector.RemoteObject.toCallArgument(result), this._scopeRef.callFrameId,
+        this._scopeRef.number, name, SDK.RemoteObject.toCallArgument(result), this._scopeRef.callFrameId,
         setVariableValueCallback.bind(this));
 
     /**
      * @param {string=} error
-     * @this {WebInspector.ScopeRemoteObject}
+     * @this {SDK.ScopeRemoteObject}
      */
     function setVariableValueCallback(error) {
       if (error) {
         callback(error);
         return;
       }
       if (this._savedScopeProperties) {
         for (var i = 0; i < this._savedScopeProperties.length; i++) {
           if (this._savedScopeProperties[i].name === name)
             this._savedScopeProperties[i].value = this._target.runtimeModel.createRemoteObject(result);
         }
       }
       callback();
     }
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ScopeRef = class {
+SDK.ScopeRef = class {
   /**
    * @param {number} number
    * @param {string=} callFrameId
    */
   constructor(number, callFrameId) {
     this.number = number;
     this.callFrameId = callFrameId;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.RemoteObjectProperty = class {
+SDK.RemoteObjectProperty = class {
   /**
    * @param {string} name
-   * @param {?WebInspector.RemoteObject} value
+   * @param {?SDK.RemoteObject} value
    * @param {boolean=} enumerable
    * @param {boolean=} writable
    * @param {boolean=} isOwn
    * @param {boolean=} wasThrown
    * @param {boolean=} synthetic
-   * @param {?WebInspector.RemoteObject=} symbol
+   * @param {?SDK.RemoteObject=} symbol
    */
   constructor(name, value, enumerable, writable, isOwn, wasThrown, symbol, synthetic) {
     this.name = name;
     if (value !== null)
       this.value = value;
     this.enumerable = typeof enumerable !== 'undefined' ? enumerable : true;
     this.writable = typeof writable !== 'undefined' ? writable : true;
     this.isOwn = !!isOwn;
     this.wasThrown = !!wasThrown;
     if (symbol)
@@ skipping 11 matching lines @@
 
 // Below is a wrapper around a local object that implements the RemoteObject interface,
 // which can be used by the UI code (primarily ObjectPropertiesSection).
 // Note that only JSON-compliant objects are currently supported, as there's no provision
 // for traversing prototypes, extracting class names via constructor, handling properties
 // or functions.
 
 /**
  * @unrestricted
  */
-WebInspector.LocalJSONObject = class extends WebInspector.RemoteObject {
+SDK.LocalJSONObject = class extends SDK.RemoteObject {
   /**
    * @param {*} value
    */
   constructor(value) {
     super();
     this._value = value;
   }
 
   /**
    * @override
    * @return {string}
    */
   get description() {
     if (this._cachedDescription)
       return this._cachedDescription;
 
     /**
-     * @param {!WebInspector.RemoteObjectProperty} property
+     * @param {!SDK.RemoteObjectProperty} property
      * @return {string}
-     * @this {WebInspector.LocalJSONObject}
+     * @this {SDK.LocalJSONObject}
      */
     function formatArrayItem(property) {
       return this._formatValue(property.value);
     }
 
     /**
-     * @param {!WebInspector.RemoteObjectProperty} property
+     * @param {!SDK.RemoteObjectProperty} property
      * @return {string}
-     * @this {WebInspector.LocalJSONObject}
+     * @this {SDK.LocalJSONObject}
      */
     function formatObjectItem(property) {
       var name = property.name;
       if (/^\s|\s$|^$|\n/.test(name))
         name = '"' + name.replace(/\n/g, '\u21B5') + '"';
       return name + ': ' + this._formatValue(property.value);
     }
 
     if (this.type === 'object') {
       switch (this.subtype) {
@@ skipping 10 matching lines @@
           this._cachedDescription = this._concatenate('{', '}', formatObjectItem.bind(this));
       }
     } else {
       this._cachedDescription = String(this._value);
     }
 
     return this._cachedDescription;
   }
 
   /**
-   * @param {?WebInspector.RemoteObject} value
+   * @param {?SDK.RemoteObject} value
    * @return {string}
    */
   _formatValue(value) {
     if (!value)
       return 'undefined';
     var description = value.description || '';
     if (value.type === 'string')
       return '"' + description.replace(/\n/g, '\u21B5') + '"';
     return description;
   }
 
   /**
    * @param {string} prefix
    * @param {string} suffix
-   * @param {function(!WebInspector.RemoteObjectProperty)} formatProperty
+   * @param {function(!SDK.RemoteObjectProperty)} formatProperty
    * @return {string}
    */
   _concatenate(prefix, suffix, formatProperty) {
     var previewChars = 100;
 
     var buffer = prefix;
     var children = this._children();
     for (var i = 0; i < children.length; ++i) {
       var itemDescription = formatProperty(children[i]);
       if (buffer.length + itemDescription.length > previewChars) {
@@ skipping 38 matching lines @@
    * @return {boolean}
    */
   get hasChildren() {
     if ((typeof this._value !== 'object') || (this._value === null))
       return false;
     return !!Object.keys(/** @type {!Object} */ (this._value)).length;
   }
 
   /**
    * @override
-   * @param {function(?Array.<!WebInspector.RemoteObjectProperty>, ?Array.<!WebInspector.RemoteObjectProperty>)} callback
+   * @param {function(?Array.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
    */
   getOwnProperties(callback) {
     callback(this._children(), null);
   }
 
   /**
    * @override
    * @param {boolean} accessorPropertiesOnly
-   * @param {function(?Array.<!WebInspector.RemoteObjectProperty>, ?Array.<!WebInspector.RemoteObjectProperty>)} callback
+   * @param {function(?Array.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
    */
   getAllProperties(accessorPropertiesOnly, callback) {
     if (accessorPropertiesOnly)
       callback([], null);
     else
       callback(this._children(), null);
   }
 
   /**
-   * @return {!Array.<!WebInspector.RemoteObjectProperty>}
+   * @return {!Array.<!SDK.RemoteObjectProperty>}
    */
   _children() {
     if (!this.hasChildren)
       return [];
     var value = /** @type {!Object} */ (this._value);
 
     /**
      * @param {string} propName
-     * @return {!WebInspector.RemoteObjectProperty}
+     * @return {!SDK.RemoteObjectProperty}
      */
     function buildProperty(propName) {
       var propValue = value[propName];
-      if (!(propValue instanceof WebInspector.RemoteObject))
-        propValue = WebInspector.RemoteObject.fromLocalObject(propValue);
-      return new WebInspector.RemoteObjectProperty(propName, propValue);
+      if (!(propValue instanceof SDK.RemoteObject))
+        propValue = SDK.RemoteObject.fromLocalObject(propValue);
+      return new SDK.RemoteObjectProperty(propName, propValue);
     }
     if (!this._cachedChildren)
       this._cachedChildren = Object.keys(value).map(buildProperty);
     return this._cachedChildren;
   }
 
   /**
    * @return {boolean}
    */
   isError() {
     return false;
   }
 
   /**
    * @override
    * @return {number}
    */
   arrayLength() {
     return Array.isArray(this._value) ? this._value.length : 0;
   }
 
   /**
    * @override
    * @param {function(this:Object, ...)} functionDeclaration
    * @param {!Array.<!Protocol.Runtime.CallArgument>=} args
-   * @param {function(?WebInspector.RemoteObject, boolean=)=} callback
+   * @param {function(?SDK.RemoteObject, boolean=)=} callback
    */
   callFunction(functionDeclaration, args, callback) {
     var target = /** @type {?Object} */ (this._value);
     var rawArgs = args ? args.map(function(arg) {
       return arg.value;
     }) :
                          [];
 
     var result;
     var wasThrown = false;
     try {
       result = functionDeclaration.apply(target, rawArgs);
     } catch (e) {
       wasThrown = true;
     }
 
     if (!callback)
       return;
-    callback(WebInspector.RemoteObject.fromLocalObject(result), wasThrown);
+    callback(SDK.RemoteObject.fromLocalObject(result), wasThrown);
   }
 
   /**
    * @override
    * @param {function(this:Object)} functionDeclaration
    * @param {!Array.<!Protocol.Runtime.CallArgument>|undefined} args
    * @param {function(*)} callback
    */
   callFunctionJSON(functionDeclaration, args, callback) {
     var target = /** @type {?Object} */ (this._value);
     var rawArgs = args ? args.map(function(arg) {
       return arg.value;
     }) :
                          [];
 
     var result;
     try {
       result = functionDeclaration.apply(target, rawArgs);
     } catch (e) {
       result = null;
     }
 
     callback(result);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.RemoteArray = class {
+SDK.RemoteArray = class {
   /**
-   * @param {!WebInspector.RemoteObject} object
+   * @param {!SDK.RemoteObject} object
    */
   constructor(object) {
     this._object = object;
   }
 
   /**
-   * @param {?WebInspector.RemoteObject} object
-   * @return {!WebInspector.RemoteArray}
+   * @param {?SDK.RemoteObject} object
+   * @return {!SDK.RemoteArray}
    */
   static objectAsArray(object) {
     if (!object || object.type !== 'object' || (object.subtype !== 'array' && object.subtype !== 'typedarray'))
       throw new Error('Object is empty or not an array');
-    return new WebInspector.RemoteArray(object);
+    return new SDK.RemoteArray(object);
   }
 
   /**
-   * @param {!Array<!WebInspector.RemoteObject>} objects
-   * @return {!Promise<!WebInspector.RemoteArray>}
+   * @param {!Array<!SDK.RemoteObject>} objects
+   * @return {!Promise<!SDK.RemoteArray>}
    */
   static createFromRemoteObjects(objects) {
     if (!objects.length)
       throw new Error('Input array is empty');
     var objectArguments = [];
     for (var i = 0; i < objects.length; ++i)
-      objectArguments.push(WebInspector.RemoteObject.toCallArgument(objects[i]));
+      objectArguments.push(SDK.RemoteObject.toCallArgument(objects[i]));
     return objects[0].callFunctionPromise(createArray, objectArguments).then(returnRemoteArray);
 
     /**
      * @return {!Array<*>}
      */
     function createArray() {
       if (arguments.length > 1)
         return new Array(arguments);
       return [arguments[0]];
     }
 
     /**
-     * @param {!WebInspector.CallFunctionResult} result
-     * @return {!WebInspector.RemoteArray}
+     * @param {!SDK.CallFunctionResult} result
+     * @return {!SDK.RemoteArray}
      */
     function returnRemoteArray(result) {
       if (result.wasThrown || !result.object)
         throw new Error('Call function throws exceptions or returns empty value');
-      return WebInspector.RemoteArray.objectAsArray(result.object);
+      return SDK.RemoteArray.objectAsArray(result.object);
     }
   }
 
   /**
    * @param {number} index
-   * @return {!Promise<!WebInspector.RemoteObject>}
+   * @return {!Promise<!SDK.RemoteObject>}
    */
   at(index) {
     if (index < 0 || index > this._object.arrayLength())
       throw new Error('Out of range');
-    return this._object.callFunctionPromise(at, [WebInspector.RemoteObject.toCallArgument(index)])
+    return this._object.callFunctionPromise(at, [SDK.RemoteObject.toCallArgument(index)])
         .then(assertCallFunctionResult);
 
     /**
      * @suppressReceiverCheck
      * @param {number} index
      * @return {*}
      * @this {!Object}
      */
     function at(index) {
       return this[index];
     }
 
     /**
-     * @param {!WebInspector.CallFunctionResult} result
-     * @return {!WebInspector.RemoteObject}
+     * @param {!SDK.CallFunctionResult} result
+     * @return {!SDK.RemoteObject}
      */
     function assertCallFunctionResult(result) {
       if (result.wasThrown || !result.object)
         throw new Error('Exception in callFunction or result value is empty');
       return result.object;
     }
   }
 
   /**
    * @return {number}
    */
   length() {
     return this._object.arrayLength();
   }
 
   /**
-   * @param {function(!WebInspector.RemoteObject):!Promise<T>} func
+   * @param {function(!SDK.RemoteObject):!Promise<T>} func
    * @return {!Promise<!Array<T>>}
    * @template T
    */
   map(func) {
     var promises = [];
     for (var i = 0; i < this.length(); ++i)
       promises.push(this.at(i).then(func));
     return Promise.all(promises);
   }
 
   /**
-   * @return {!WebInspector.RemoteObject}
+   * @return {!SDK.RemoteObject}
    */
   object() {
     return this._object;
   }
 };
 
 
 /**
  * @unrestricted
  */
-WebInspector.RemoteFunction = class {
+SDK.RemoteFunction = class {
   /**
-   * @param {!WebInspector.RemoteObject} object
+   * @param {!SDK.RemoteObject} object
    */
   constructor(object) {
     this._object = object;
   }
 
   /**
-   * @param {?WebInspector.RemoteObject} object
-   * @return {!WebInspector.RemoteFunction}
+   * @param {?SDK.RemoteObject} object
+   * @return {!SDK.RemoteFunction}
    */
   static objectAsFunction(object) {
     if (!object || object.type !== 'function')
       throw new Error('Object is empty or not a function');
-    return new WebInspector.RemoteFunction(object);
+    return new SDK.RemoteFunction(object);
   }
 
   /**
-   * @return {!Promise<!WebInspector.RemoteObject>}
+   * @return {!Promise<!SDK.RemoteObject>}
    */
   targetFunction() {
     return this._object.getOwnPropertiesPromise().then(targetFunction.bind(this));
 
     /**
-     * @param {!{properties: ?Array<!WebInspector.RemoteObjectProperty>, internalProperties: ?Array<!WebInspector.RemoteObjectProperty>}} ownProperties
-     * @return {!WebInspector.RemoteObject}
-     * @this {WebInspector.RemoteFunction}
+     * @param {!{properties: ?Array<!SDK.RemoteObjectProperty>, internalProperties: ?Array<!SDK.RemoteObjectProperty>}} ownProperties
+     * @return {!SDK.RemoteObject}
+     * @this {SDK.RemoteFunction}
      */
     function targetFunction(ownProperties) {
       if (!ownProperties.internalProperties)
         return this._object;
       var internalProperties = ownProperties.internalProperties;
       for (var property of internalProperties) {
         if (property.name === '[[TargetFunction]]')
           return property.value;
       }
       return this._object;
     }
   }
 
   /**
-   * @return {!Promise<?WebInspector.DebuggerModel.FunctionDetails>}
+   * @return {!Promise<?SDK.DebuggerModel.FunctionDetails>}
    */
   targetFunctionDetails() {
     return this.targetFunction().then(functionDetails.bind(this));
 
     /**
-     * @param {!WebInspector.RemoteObject} targetFunction
-     * @return {!Promise<?WebInspector.DebuggerModel.FunctionDetails>}
-     * @this {WebInspector.RemoteFunction}
+     * @param {!SDK.RemoteObject} targetFunction
+     * @return {!Promise<?SDK.DebuggerModel.FunctionDetails>}
+     * @this {SDK.RemoteFunction}
      */
     function functionDetails(targetFunction) {
       var boundReleaseFunctionDetails =
           releaseTargetFunction.bind(null, this._object !== targetFunction ? targetFunction : null);
       return targetFunction.debuggerModel().functionDetailsPromise(targetFunction).then(boundReleaseFunctionDetails);
     }
 
     /**
-     * @param {?WebInspector.RemoteObject} targetFunction
-     * @param {?WebInspector.DebuggerModel.FunctionDetails} functionDetails
-     * @return {?WebInspector.DebuggerModel.FunctionDetails}
+     * @param {?SDK.RemoteObject} targetFunction
+     * @param {?SDK.DebuggerModel.FunctionDetails} functionDetails
+     * @return {?SDK.DebuggerModel.FunctionDetails}
      */
     function releaseTargetFunction(targetFunction, functionDetails) {
       if (targetFunction)
         targetFunction.release();
       return functionDetails;
     }
   }
 
   /**
-   * @return {!WebInspector.RemoteObject}
+   * @return {!SDK.RemoteObject}
    */
   object() {
     return this._object;
   }
 };