DevTools: Allow setting -0 value to object property

Source/core/inspector/InjectedScriptSource.js

 /*
  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  * Copyright (C) 2013 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 75 matching lines @@
     return bound;
 }
 
 /**
  * @constructor
  */
 var InjectedScript = function()
 {
     /** @type {number} */
     this._lastBoundObjectId = 1;
-    /** @type {!Object.<number, Object>} */
+    /** @type {!Object.<number, *>} */
     this._idToWrappedObject = {};
     /** @type {!Object.<number, string>} */
     this._idToObjectGroupName = {};
     /** @type {!Object.<string, Array.<number>>} */
     this._objectGroups = {};
     /** @type {!Object.<string, Object>} */
     this._modules = {};
 }
 
 /**
@@ skipping 21 matching lines @@
     /**
      * @param {*} object
      * @param {string} groupName
      * @param {boolean} canAccessInspectedWindow
      * @param {boolean} generatePreview
      * @return {!RuntimeAgent.RemoteObject}
      */
     wrapObject: function(object, groupName, canAccessInspectedWindow, generatePreview)
     {
         if (canAccessInspectedWindow)
-            return this._wrapObject(object, groupName, false, generatePreview);
+            return this._wrapObject(object, groupName, false, false, generatePreview);
         return this._fallbackWrapper(object);
     },
 
     /**
      * @param {*} object
      * @return {!RuntimeAgent.RemoteObject}
      */
     _fallbackWrapper: function(object)
     {
         var result = {};
@@ skipping 16 matching lines @@
         if (!canAccessInspectedWindow)
             return this._fallbackWrapper(table);
         var columnNames = null;
         if (typeof columns === "string")
             columns = [columns];
         if (InjectedScriptHost.type(columns) == "array") {
             columnNames = [];
             for (var i = 0; i < columns.length; ++i)
                 columnNames.push(toString(columns[i]));
         }
-        return this._wrapObject(table, "console", false, true, columnNames, true);
+        return this._wrapObject(table, "console", false, false, true, columnNames, true);
     },
 
     /**
      * @param {*} object
      */
     inspectNode: function(object)
     {
         this._inspect(object);
     },
 
@@ skipping 23 matching lines @@
         }
         InjectedScriptHost.inspect(objectId, hints);
         return object;
     },
 
     /**
      * This method cannot throw.
      * @param {*} object
      * @param {string=} objectGroupName
      * @param {boolean=} forceValueType
+     * @param {boolean=} forceObjectId
      * @param {boolean=} generatePreview
      * @param {?Array.<string>=} columnNames
      * @param {boolean=} isTable
      * @return {!RuntimeAgent.RemoteObject}
      * @suppress {checkTypes}
      */
-    _wrapObject: function(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable)
+    _wrapObject: function(object, objectGroupName, forceValueType, forceObjectId, generatePreview, columnNames, isTable)
     {
         try {
-            return new InjectedScript.RemoteObject(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable);
+            return new InjectedScript.RemoteObject(object, objectGroupName, forceValueType, forceObjectId, generatePreview, columnNames, isTable);
         } catch (e) {
             try {
                 var description = injectedScript._describe(e);
             } catch (ex) {
                 var description = "<failed to convert exception to string>";
             }
             return new InjectedScript.RemoteObject(description);
         }
     },
 
     /**
-     * @param {Object} object
+     * @param {*} object
      * @param {string=} objectGroupName
      * @return {string}
      */
     _bind: function(object, objectGroupName)
     {
         var id = this._lastBoundObjectId++;
         this._idToWrappedObject[id] = object;
         var objectId = "{\"injectedScriptId\":" + injectedScriptId + ",\"id\":" + id + "}";
         if (objectGroupName) {
             var group = this._objectGroups[objectGroupName];
             if (!group) {
                 group = [];
                 this._objectGroups[objectGroupName] = group;
             }
             group.push(id);
             this._idToObjectGroupName[id] = objectGroupName;
         }
         return objectId;
     },
 
     /**
      * @param {string} objectId
-     * @return {Object}
+     * @return {{injectedScriptId: number, id: number}}
      */
     _parseObjectId: function(objectId)
     {
         return InjectedScriptHost.evaluate("(" + objectId + ")");
     },
 
     /**
      * @param {string} objectGroupName
      */
     releaseObjectGroup: function(objectGroupName)
@@ skipping 24 matching lines @@
 
     /**
      * @param {string} objectId
      * @param {boolean} ownProperties
      * @param {boolean} accessorPropertiesOnly
      * @return {Array.<RuntimeAgent.PropertyDescriptor>|boolean}
      */
     getProperties: function(objectId, ownProperties, accessorPropertiesOnly)
     {
         var parsedObjectId = this._parseObjectId(objectId);
-        var object = this._objectForId(parsedObjectId);
+        var object = this._objectForId(parsedObjectId.id);
         var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
 
         if (!this._isDefined(object))
             return false;
-        var descriptors = this._propertyDescriptors(object, ownProperties, accessorPropertiesOnly);
+        var descriptors = this._propertyDescriptors(/** @type {!Object} */ (object), ownProperties, accessorPropertiesOnly);
 
         // Go over properties, wrap object values.
         for (var i = 0; i < descriptors.length; ++i) {
             var descriptor = descriptors[i];
             if ("get" in descriptor)
                 descriptor.get = this._wrapObject(descriptor.get, objectGroupName);
             if ("set" in descriptor)
                 descriptor.set = this._wrapObject(descriptor.set, objectGroupName);
             if ("value" in descriptor)
                 descriptor.value = this._wrapObject(descriptor.value, objectGroupName);
             if (!("configurable" in descriptor))
                 descriptor.configurable = false;
             if (!("enumerable" in descriptor))
                 descriptor.enumerable = false;
         }
         return descriptors;
     },
 
     /**
      * @param {string} objectId
      * @return {Array.<Object>|boolean}
      */
     getInternalProperties: function(objectId, ownProperties)
     {
         var parsedObjectId = this._parseObjectId(objectId);
-        var object = this._objectForId(parsedObjectId);
+        var object = this._objectForId(parsedObjectId.id);
         var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
         if (!this._isDefined(object))
             return false;
         var descriptors = [];
         var internalProperties = InjectedScriptHost.getInternalProperties(object);
         if (internalProperties) {
             for (var i = 0; i < internalProperties.length; i++) {
                 var property = internalProperties[i];
                 var descriptor = {
                     name: property.name,
                     value: this._wrapObject(property.value, objectGroupName)
                 };
                 descriptors.push(descriptor);
             }
         }
         return descriptors;
     },
 
     /**
      * @param {string} functionId
      * @return {!DebuggerAgent.FunctionDetails|string}
      */
     getFunctionDetails: function(functionId)
     {
         var parsedFunctionId = this._parseObjectId(functionId);
-        var func = this._objectForId(parsedFunctionId);
+        var func = this._objectForId(parsedFunctionId.id);
         if (typeof func !== "function")
             return "Cannot resolve function by id.";
         var details = InjectedScriptHost.functionDetails(func);
         if ("rawScopes" in details) {
             var objectGroupName = this._idToObjectGroupName[parsedFunctionId.id];
             var rawScopes = details.rawScopes;
             var scopes = [];
             delete details.rawScopes;
             for (var i = 0; i < rawScopes.length; i++)
                 scopes.push(InjectedScript.CallFrameProxy._createScopeJson(rawScopes[i].type, rawScopes[i].object, objectGroupName));
@@ skipping 90 matching lines @@
         }
 
         return descriptors;
     },
 
     /**
      * @param {string} expression
      * @param {string} objectGroup
      * @param {boolean} injectCommandLineAPI
      * @param {boolean} returnByValue
+     * @param {boolean} forceObjectId
      * @param {boolean} generatePreview
      * @return {*}
      */
-    evaluate: function(expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview)
+    evaluate: function(expression, objectGroup, injectCommandLineAPI, returnByValue, forceObjectId, generatePreview)
     {
-        return this._evaluateAndWrap(InjectedScriptHost.evaluate, InjectedScriptHost, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview);
+        return this._evaluateAndWrap(InjectedScriptHost.evaluate, InjectedScriptHost, expression, objectGroup, false, injectCommandLineAPI, returnByValue, forceObjectId, generatePreview);
     },
 
     /**
      * @param {string} objectId
      * @param {string} expression
      * @param {boolean} returnByValue
+     * @param {boolean} forceObjectId
      * @return {Object|string}
      */
-    callFunctionOn: function(objectId, expression, args, returnByValue)
+    callFunctionOn: function(objectId, expression, args, returnByValue, forceObjectId)
     {
         var parsedObjectId = this._parseObjectId(objectId);
-        var object = this._objectForId(parsedObjectId);
+        var object = this._objectForId(parsedObjectId.id);
         if (!this._isDefined(object))
             return "Could not find object with given id";
 
         if (args) {
             var resolvedArgs = [];
             args = InjectedScriptHost.evaluate(args);
             for (var i = 0; i < args.length; ++i) {
                 var resolvedCallArgument;
                 try {
                     resolvedCallArgument = this._resolveCallArgument(args[i]);
                 } catch (e) {
                     return toString(e);
                 }
                 resolvedArgs.push(resolvedCallArgument)
             }
         }
 
         try {
             var objectGroup = this._idToObjectGroupName[parsedObjectId.id];
             var func = InjectedScriptHost.evaluate("(" + expression + ")");
             if (typeof func !== "function")
                 return "Given expression does not evaluate to a function";
 
             return { wasThrown: false,
-                     result: this._wrapObject(func.apply(object, resolvedArgs), objectGroup, returnByValue) };
+                     result: this._wrapObject(func.apply(object, resolvedArgs), objectGroup, returnByValue, forceObjectId) };
         } catch (e) {
             return this._createThrownValue(e, objectGroup);
         }
     },
 
     /**
      * Resolves a value from CallArgument description.
      * @param {RuntimeAgent.CallArgument} callArgumentJson
      * @return {*} resolved value
      * @throws {string} error message
      */
     _resolveCallArgument: function(callArgumentJson) {
         var objectId = callArgumentJson.objectId;
         if (objectId) {
             var parsedArgId = this._parseObjectId(objectId);
-            if (!parsedArgId || parsedArgId["injectedScriptId"] !== injectedScriptId)
+            if (!parsedArgId || parsedArgId.injectedScriptId !== injectedScriptId)
                 throw "Arguments should belong to the same JavaScript world as the target object.";
-
-            var resolvedArg = this._objectForId(parsedArgId);
-            if (!this._isDefined(resolvedArg))
+            if (!this._hasObjectForId(parsedArgId.id))
                 throw "Could not find object with given id";
-
-            return resolvedArg;
-        } else if ("value" in callArgumentJson)
+            return this._objectForId(parsedArgId.id);
+        } else if ("value" in callArgumentJson) {
             return callArgumentJson.value;
-        else
-            return undefined;
+        }
+        return undefined;
     },
 
     /**
      * @param {Function} evalFunction
      * @param {Object} object
      * @param {string} objectGroup
      * @param {boolean} isEvalOnCallFrame
      * @param {boolean} injectCommandLineAPI
      * @param {boolean} returnByValue
+     * @param {boolean} forceObjectId
      * @param {boolean} generatePreview
      * @return {*}
      */
-    _evaluateAndWrap: function(evalFunction, object, expression, objectGroup, isEvalOnCallFrame, injectCommandLineAPI, returnByValue, generatePreview)
+    _evaluateAndWrap: function(evalFunction, object, expression, objectGroup, isEvalOnCallFrame, injectCommandLineAPI, returnByValue, forceObjectId, generatePreview)
     {
         try {
             return { wasThrown: false,
-                     result: this._wrapObject(this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI), objectGroup, returnByValue, generatePreview) };
+                     result: this._wrapObject(this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI), objectGroup, returnByValue, forceObjectId, generatePreview) };
         } catch (e) {
             return this._createThrownValue(e, objectGroup);
         }
     },
 
     /**
      * @param {*} value
      * @param {string} objectGroup
      * @return {Object}
      */
@@ skipping 55 matching lines @@
         return result;
     },
 
     /**
      * @param {Object} topCallFrame
      * @param {string} callFrameId
      * @param {string} expression
      * @param {string} objectGroup
      * @param {boolean} injectCommandLineAPI
      * @param {boolean} returnByValue
+     * @param {boolean} forceObjectId
      * @param {boolean} generatePreview
      * @return {*}
      */
-    evaluateOnCallFrame: function(topCallFrame, callFrameId, expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview)
+    evaluateOnCallFrame: function(topCallFrame, callFrameId, expression, objectGroup, injectCommandLineAPI, returnByValue, forceObjectId, generatePreview)
     {
         var callFrame = this.callFrameForId(topCallFrame, callFrameId);
         if (!callFrame)
             return "Could not find call frame with given id";
-        return this._evaluateAndWrap(callFrame.evaluate, callFrame, expression, objectGroup, true, injectCommandLineAPI, returnByValue, generatePreview);
+        return this._evaluateAndWrap(callFrame.evaluate, callFrame, expression, objectGroup, true, injectCommandLineAPI, returnByValue, forceObjectId, generatePreview);
     },
 
     /**
      * @param {Object} topCallFrame
      * @param {string} callFrameId
      * @return {*}
      */
     restartFrame: function(topCallFrame, callFrameId)
     {
         var callFrame = this.callFrameForId(topCallFrame, callFrameId);
@@ skipping 34 matching lines @@
     setVariableValue: function(topCallFrame, callFrameId, functionObjectId, scopeNumber, variableName, newValueJsonString)
     {
         var setter;
         if (typeof callFrameId === "string") {
             var callFrame = this.callFrameForId(topCallFrame, callFrameId);
             if (!callFrame)
                 return "Could not find call frame with given id";
             setter = callFrame.setVariableValue.bind(callFrame);
         } else {
             var parsedFunctionId = this._parseObjectId(/** @type {string} */ (functionObjectId));
-            var func = this._objectForId(parsedFunctionId);
+            var func = this._objectForId(parsedFunctionId.id);
             if (typeof func !== "function")
                 return "Cannot resolve function by id.";
             setter = InjectedScriptHost.setFunctionVariableValue.bind(InjectedScriptHost, func);
         }
         var newValueJson;
         try {
             newValueJson = InjectedScriptHost.evaluate("(" + newValueJsonString + ")");
         } catch (e) {
             return "Failed to parse new value JSON " + newValueJsonString + " : " + e;
         }
@@ skipping 20 matching lines @@
     {
         var parsedCallFrameId = InjectedScriptHost.evaluate("(" + callFrameId + ")");
         var ordinal = parsedCallFrameId["ordinal"];
         var callFrame = topCallFrame;
         while (--ordinal >= 0 && callFrame)
             callFrame = callFrame.caller;
         return callFrame;
     },
 
     /**
-     * @param {Object} objectId
-     * @return {Object}
+     * @param {number} objectId
+     * @return {*}
      */
     _objectForId: function(objectId)
     {
-        return this._idToWrappedObject[objectId.id];
+        return this._idToWrappedObject[objectId];
+    },
+
+    /**
+     * @param {number} objectId
+     * @return {boolean}
+     */
+    _hasObjectForId: function(objectId)
+    {
+        return (objectId in this._idToWrappedObject);
     },
 
     /**
      * @param {string} objectId
-     * @return {Object}
+     * @return {*}
      */
     findObjectById: function(objectId)
     {
         var parsedObjectId = this._parseObjectId(objectId);
-        return this._objectForId(parsedObjectId);
+        return this._objectForId(parsedObjectId.id);
     },
 
     /**
      * @param {string} objectId
      * @return {Node}
      */
     nodeForObjectId: function(objectId)
     {
         var object = this.findObjectById(objectId);
         if (!object || this._subtype(object) !== "node")
@@ skipping 27 matching lines @@
         this._modules[name] = module;
         return module;
     },
 
     /**
      * @param {*} object
      * @return {boolean}
      */
     _isDefined: function(object)
     {
-        return !!object || this._isHTMLAllCollection(object);
+        return (!!object && !InjectedScript.primitiveTypes[typeof object]) || this._isHTMLAllCollection(object);
     },
 
     /**
      * @param {*} object
      * @return {boolean}
      */
     _isHTMLAllCollection: function(object)
     {
         // document.all is reported as undefined, but we still want to process it.
         return (typeof object === "undefined") && InjectedScriptHost.isHTMLAllCollection(object);
@@ skipping 90 matching lines @@
  * @type {!InjectedScript}
  * @const
  */
 var injectedScript = new InjectedScript();
 
 /**
  * @constructor
  * @param {*} object
  * @param {string=} objectGroupName
  * @param {boolean=} forceValueType
+ * @param {boolean=} forceObjectId
  * @param {boolean=} generatePreview
  * @param {?Array.<string>=} columnNames
  * @param {boolean=} isTable
  */
-InjectedScript.RemoteObject = function(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable)
+InjectedScript.RemoteObject = function(object, objectGroupName, forceValueType, forceObjectId, generatePreview, columnNames, isTable)
 {
     this.type = typeof object;
     if (injectedScript.isPrimitiveValue(object) || object === null || forceValueType) {
         // We don't send undefined values over JSON.
         if (this.type !== "undefined")
             this.value = object;
 
         // Null object is object with 'null' subtype.
         if (object === null)
             this.subtype = "null";
 
         // Provide user-friendly number values.
         if (this.type === "number")
             this.description = toString(object);
+
+        if (forceObjectId)
+            this.objectId = injectedScript._bind(object, objectGroupName);
         return;
     }
 
     object = /** @type {Object} */ (object);
 
     this.objectId = injectedScript._bind(object, objectGroupName);
     var subtype = injectedScript._subtype(object);
     if (subtype)
         this.subtype = subtype;
     this.className = InjectedScriptHost.internalConstructorName(object);
@@ skipping 525 matching lines @@
      */
     _logEvent: function(event)
     {
         inspectedWindow.console.log(event.type, event);
     }
 }
 
 injectedScript._commandLineAPIImpl = new CommandLineAPIImpl();
 return injectedScript;
 })