[DevTools] Migrate usages of Target to RuntimeModel where makes sense

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 14 matching lines @@
  * 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: ?SDK.RemoteObject, wasThrown: (boolean|undefined)}}
  */
 SDK.CallFunctionResult;
 
-/**
- * @unrestricted
- */
 SDK.RemoteObject = class {
   /**
    * This may not be an interface due to "instanceof SDK.RemoteObject" checks in the code.
    */
 
   /**
    * @param {*} value
    * @return {!SDK.RemoteObject}
    */
   static fromLocalObject(value) {
@@ skipping 72 matching lines @@
       return {value: object};
     }
     if (type === 'string' || type === 'boolean')
       return {value: object};
 
     if (!object)
       return {value: null};
 
     if (typeof object.unserializableValue !== 'undefined')
       return {unserializableValue: object.unserializableValue};
-    if (typeof object._unserializableValue !== 'undefined')
+    if (object instanceof SDK.RemoteObjectImpl && typeof object._unserializableValue !== 'undefined')
       return {unserializableValue: object._unserializableValue};
 
     if (typeof object.objectId !== 'undefined')
       return {objectId: object.objectId};
-    if (typeof object._objectId !== 'undefined')
-      return {objectId: object._objectId};
 
     return {value: object.value};
   }
 
   /**
    * @param {!SDK.RemoteObject} object
    * @param {boolean} generatePreview
    * @param {function(?Array.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
    */
   static loadFromObjectPerProto(object, generatePreview, callback) {
@@ skipping 56 matching lines @@
     object.getOwnProperties(generatePreview, ownPropertiesCallback);
   }
 
   /**
    * @return {?Protocol.Runtime.CustomPreview}
    */
   customPreview() {
     return null;
   }
 
+  /** @return {!Protocol.Runtime.RemoteObjectId|undefined} */
+  get objectId() {
+    return 'Not implemented';
+  }
+
   /** @return {string} */
   get type() {
     throw 'Not implemented';
   }
 
   /** @return {string|undefined} */
   get subtype() {
     throw 'Not implemented';
   }
 
+  /** @return {*} */
+  get value() {
+    throw 'Not implemented';
+  }
+
   /** @return {string|undefined} */
   get description() {
     throw 'Not implemented';
   }
 
   /** @return {boolean} */
   get hasChildren() {
     throw 'Not implemented';
   }
 
   /**
+   * @return {!Protocol.Runtime.ObjectPreview|undefined}
+   */
+  get preview() {
+    return undefined;
+  }
+
+  /**
    * @return {number}
    */
   arrayLength() {
     throw 'Not implemented';
   }
 
   /**
    * @param {boolean} generatePreview
    * @param {function(?Array.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
    */
@@ skipping 55 matching lines @@
      * @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});
     }
   }
 
   /**
+   * @param {!Array.<string>} propertyPath
+   * @param {function(?SDK.RemoteObject, boolean=)} callback
+   */
+  getProperty(propertyPath, callback) {
+    throw 'Not implemented';
+  }
+
+  /**
    * @return {!Promise<?Array<!SDK.EventListener>>}
    */
   eventListeners() {
     throw 'Not implemented';
   }
 
   /**
    * @param {!Protocol.Runtime.CallArgument} name
    * @param {function(string=)} callback
    */
@@ skipping 65 matching lines @@
     return new Promise(promiseConstructor.bind(this));
 
     /**
      * @this {SDK.RemoteObject}
      */
     function promiseConstructor(success) {
       this.callFunctionJSON(functionDeclaration, args, success);
     }
   }
 
-  /**
-   * @return {!SDK.Target}
-   */
-  target() {
-    throw new Error('Target-less object');
+  release() {
   }
 
   /**
-   * @return {?SDK.DebuggerModel}
+   * @return {!SDK.DebuggerModel}
    */
   debuggerModel() {
     throw new Error('DebuggerModel-less object');
   }
 
   /**
+   * @return {!SDK.RuntimeModel}
+   */
+  runtimeModel() {
+    throw new Error('RuntimeModel-less object');
+  }
+
+  /**
    * @return {boolean}
    */
   isNode() {
     return false;
   }
 };
 
 
-/**
- * @unrestricted
- */
 SDK.RemoteObjectImpl = class extends SDK.RemoteObject {
   /**
-   * @param {!SDK.Target} target
+   * @param {!SDK.RuntimeModel} runtimeModel
    * @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) {
+  constructor(runtimeModel, objectId, type, subtype, value, unserializableValue, description, preview, customPreview) {
     super();
 
-    this._target = target;
-    this._runtimeAgent = target.runtimeAgent();
-    this._debuggerModel = SDK.DebuggerModel.fromTarget(target);
+    this._runtimeModel = runtimeModel;
+    this._runtimeAgent = runtimeModel.target().runtimeAgent();
 
     this._type = type;
     this._subtype = subtype;
     if (objectId) {
       // handle
       this._objectId = objectId;
       this._description = description;
       this._hasChildren = (type !== 'symbol');
       this._preview = preview;
     } else {
       this._description = description;
       if (!this._description && (typeof value !== 'object' || value === null))
         this._description = value + '';
       this._hasChildren = false;
       if (typeof unserializableValue !== 'undefined') {
         this._unserializableValue = unserializableValue;
         if (unserializableValue === Protocol.Runtime.UnserializableValue.Infinity ||
             unserializableValue === Protocol.Runtime.UnserializableValue.NegativeInfinity ||
             unserializableValue === Protocol.Runtime.UnserializableValue.Negative0 ||
             unserializableValue === Protocol.Runtime.UnserializableValue.NaN)
-          this.value = Number(unserializableValue);
+          this._value = Number(unserializableValue);
         else
-          this.value = unserializableValue;
+          this._value = unserializableValue;
 
       } else {
-        this.value = value;
+        this._value = value;
       }
     }
     this._customPreview = customPreview || null;
   }
 
   /**
    * @override
    * @return {?Protocol.Runtime.CustomPreview}
    */
   customPreview() {
     return this._customPreview;
   }
 
-  /** @return {!Protocol.Runtime.RemoteObjectId} */
+  /**
+   * @override
+   * @return {!Protocol.Runtime.RemoteObjectId|undefined}
+   */
   get objectId() {
     return this._objectId;
   }
 
   /**
    * @override
    * @return {string}
    */
   get type() {
     return this._type;
   }
 
   /**
    * @override
    * @return {string|undefined}
    */
   get subtype() {
     return this._subtype;
   }
 
   /**
    * @override
+   * @return {*}
+   */
+  get value() {
+    return this._value;
+  }
+
+  /**
+   * @override
    * @return {string|undefined}
    */
   get description() {
     return this._description;
   }
 
   /**
    * @override
    * @return {boolean}
    */
   get hasChildren() {
     return this._hasChildren;
   }
 
   /**
+   * @override
    * @return {!Protocol.Runtime.ObjectPreview|undefined}
    */
   get preview() {
     return this._preview;
   }
 
   /**
    * @override
    * @param {boolean} generatePreview
    * @param {function(?Array.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
@@ skipping 17 matching lines @@
    * @return {!Promise<?Array<!SDK.EventListener>>}
    */
   eventListeners() {
     return new Promise(eventListeners.bind(this));
     /**
      * @param {function(?)} fulfill
      * @param {function(*)} reject
      * @this {SDK.RemoteObjectImpl}
      */
     function eventListeners(fulfill, reject) {
-      if (!this.target().hasDOMCapability()) {
+      if (!this._runtimeModel.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, undefined, undefined, mycallback.bind(this));
+      this._runtimeModel.target().domdebuggerAgent().getEventListeners(
+          this._objectId, undefined, undefined, mycallback.bind(this));
 
       /**
        * @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 {SDK.RemoteObjectImpl}
        * @param {!Protocol.DOMDebugger.EventListener} payload
        */
       function createEventListener(payload) {
         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 {!SDK.DebuggerModel.Location} */ (this._debuggerModel.createRawLocationByScriptId(
+            this._runtimeModel, this, payload.type, payload.useCapture, payload.passive, payload.once,
+            payload.handler ? this._runtimeModel.createRemoteObject(payload.handler) : null,
+            payload.originalHandler ? this._runtimeModel.createRemoteObject(payload.originalHandler) : null,
+            /** @type {!SDK.DebuggerModel.Location} */
+            (this.debuggerModel().createRawLocationByScriptId(
                 payload.scriptId, payload.lineNumber, payload.columnNumber)),
             null);
       }
     }
   }
 
   /**
+   * @override
    * @param {!Array.<string>} propertyPath
    * @param {function(?SDK.RemoteObject, boolean=)} callback
    */
   getProperty(propertyPath, callback) {
     /**
      * @param {string} arrayStr
      * @suppressReceiverCheck
      * @this {Object}
      */
     function remoteFunction(arrayStr) {
@@ skipping 26 matching lines @@
      * @param {!Array.<!Protocol.Runtime.InternalPropertyDescriptor>=} internalProperties
      * @param {?Protocol.Runtime.ExceptionDetails=} exceptionDetails
      * @this {SDK.RemoteObjectImpl}
      */
     function remoteObjectBinder(error, properties, internalProperties, exceptionDetails) {
       if (error) {
         callback(null, null);
         return;
       }
       if (exceptionDetails) {
-        this.target().runtimeModel.exceptionThrown(Date.now(), exceptionDetails);
+        this._runtimeModel.exceptionThrown(Date.now(), exceptionDetails);
         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 propertyValue = property.value ? this._runtimeModel.createRemoteObject(property.value) : null;
+        var propertySymbol = property.symbol ? this._runtimeModel.createRemoteObject(property.symbol) : null;
         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);
+            remoteProperty.getter = this._runtimeModel.createRemoteObject(property.get);
           if (property.set && property.set.type !== 'undefined')
-            remoteProperty.setter = this._target.runtimeModel.createRemoteObject(property.set);
+            remoteProperty.setter = this._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);
+          var propertyValue = this._runtimeModel.createRemoteObject(property.value);
           internalPropertiesResult.push(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 {SDK.RemoteObject}
+     * @this {SDK.RemoteObjectImpl}
      */
     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 = SDK.RemoteObject.toCallArgument(name);
 
@@ skipping 80 matching lines @@
      * @param {!Protocol.Runtime.RemoteObject} result
      * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
      * @this {SDK.RemoteObjectImpl}
      */
     function mycallback(error, result, exceptionDetails) {
       if (!callback)
         return;
       if (error)
         callback(null, false);
       else
-        callback(this.target().runtimeModel.createRemoteObject(result), !!exceptionDetails);
+        callback(this._runtimeModel.createRemoteObject(result), !!exceptionDetails);
     }
 
     this._runtimeAgent.callFunctionOn(
         this._objectId, functionDeclaration.toString(), args, true, undefined, undefined, undefined, undefined,
         mycallback.bind(this));
   }
 
   /**
    * @override
    * @param {function(this:Object)} functionDeclaration
    * @param {!Array.<!Protocol.Runtime.CallArgument>|undefined} args
    * @param {function(*)} callback
    */
   callFunctionJSON(functionDeclaration, args, callback) {
     /**
      * @param {?Protocol.Error} error
      * @param {!Protocol.Runtime.RemoteObject} result
      * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
      */
     function mycallback(error, result, exceptionDetails) {
       callback((error || !!exceptionDetails) ? null : result.value);
     }
 
     this._runtimeAgent.callFunctionOn(
         this._objectId, functionDeclaration.toString(), args, true, true, false, undefined, undefined, mycallback);
   }
 
+  /**
+   * @override
+   */
   release() {
     if (!this._objectId)
       return;
     this._runtimeAgent.releaseObject(this._objectId);
   }
 
   /**
    * @override
    * @return {number}
    */
   arrayLength() {
     return SDK.RemoteObject.arrayLength(this);
   }
 
   /**
    * @override
-   * @return {!SDK.Target}
+   * @return {!SDK.DebuggerModel}
    */
-  target() {
-    return this._target;
+  debuggerModel() {
+    return this._runtimeModel.debuggerModel();
   }
 
   /**
    * @override
-   * @return {?SDK.DebuggerModel}
+   * @return {!SDK.RuntimeModel}
    */
-  debuggerModel() {
-    return this._debuggerModel;
+  runtimeModel() {
+    return this._runtimeModel;
   }
 
   /**
    * @override
    * @return {boolean}
    */
   isNode() {
     return !!this._objectId && this.type === 'object' && this.subtype === 'node';
   }
 };
 
 
-/**
- * @unrestricted
- */
 SDK.ScopeRemoteObject = class extends SDK.RemoteObjectImpl {
   /**
-   * @param {!SDK.Target} target
+   * @param {!SDK.RuntimeModel} runtimeModel
    * @param {string|undefined} objectId
    * @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);
+  constructor(runtimeModel, objectId, scopeRef, type, subtype, value, unserializableValue, description, preview) {
+    super(runtimeModel, 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.<!SDK.RemoteObjectProperty>, ?Array.<!SDK.RemoteObjectProperty>)} callback
@@ skipping 35 matching lines @@
   }
 
   /**
    * @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.debuggerModel().setVariableValue(
         this._scopeRef.number, name, SDK.RemoteObject.toCallArgument(result), this._scopeRef.callFrameId,
         setVariableValueCallback.bind(this));
 
     /**
      * @param {string=} error
      * @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);
+            this._savedScopeProperties[i].value = this._runtimeModel.createRemoteObject(result);
         }
       }
       callback();
     }
   }
 };
 
-/**
- * @unrestricted
- */
 SDK.ScopeRef = class {
   /**
    * @param {number} number
    * @param {string=} callFrameId
    */
   constructor(number, callFrameId) {
     this.number = number;
     this.callFrameId = callFrameId;
   }
 };
@@ skipping 32 matching lines @@
     return !!(this.getter || this.setter);
   }
 };
 
 // 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
- */
 SDK.LocalJSONObject = class extends SDK.RemoteObject {
   /**
    * @param {*} value
    */
   constructor(value) {
     super();
     this._value = value;
+    /** @type {string} */
+    this._cachedDescription;
+    /** @type {!Array<!SDK.RemoteObjectProperty>} */
+    this._cachedChildren;
   }
 
   /**
+   * @override
+   * @return {!Protocol.Runtime.RemoteObjectId|undefined}
+   * */
+  get objectId() {
+    return undefined;
+  }
+
+  /**
+   * @override
+   * @return {*}
+   */
+  get value() {
+    return this._value;
+  }
+
+  /**
    * @override
    * @return {string}
    */
   get description() {
     if (this._cachedDescription)
       return this._cachedDescription;
 
     /**
      * @param {!SDK.RemoteObjectProperty} property
      * @return {string}
@@ skipping 212 matching lines @@
     try {
       result = functionDeclaration.apply(target, rawArgs);
     } catch (e) {
       result = null;
     }
 
     callback(result);
   }
 };
 
-/**
- * @unrestricted
- */
 SDK.RemoteArray = class {
   /**
    * @param {!SDK.RemoteObject} object
    */
   constructor(object) {
     this._object = object;
   }
 
   /**
    * @param {?SDK.RemoteObject} object
@@ skipping 89 matching lines @@
 
   /**
    * @return {!SDK.RemoteObject}
    */
   object() {
     return this._object;
   }
 };
 
 
-/**
- * @unrestricted
- */
 SDK.RemoteFunction = class {
   /**
    * @param {!SDK.RemoteObject} object
    */
   constructor(object) {
     this._object = object;
   }
 
   /**
    * @param {?SDK.RemoteObject} object
@@ skipping 69 matching lines @@
  * @const
  * @type {!RegExp}
  */
 SDK.RemoteObject._descriptionLengthParenRegex = /\(([0-9]+)\)/;
 
 /**
  * @const
  * @type {!RegExp}
  */
 SDK.RemoteObject._descriptionLengthSquareRegex = /\[([0-9]+)\]/;