Support re-reading scope variables in protocol and on backed.

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 321 matching lines @@
         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)
     {
@@ skipping 55 matching lines @@
                     var descriptor = Object.getOwnPropertyDescriptor(/** @type {!Object} */ (o), name);
                     if (descriptor) {
                         if (accessorPropertiesOnly && !("get" in descriptor || "set" in descriptor))
                             continue;
                     } else {
                         // Not all bindings provide proper descriptors. Fall back to the writable, configurable property.
                         if (accessorPropertiesOnly)
                             continue;
                         try {
                             descriptor = { name: name, value: o[name], writable: false, configurable: false, enumerable: false};
-                            if (o === object) 
+                            if (o === object)
                                 descriptor.isOwn = true;
                             descriptors.push(descriptor);
                         } catch (e) {
                             // Silent catch.
                         }
                         continue;
                     }
                 } catch (e) {
                     if (accessorPropertiesOnly)
                         continue;
                     var descriptor = {};
                     descriptor.value = e;
                     descriptor.wasThrown = true;
                 }
 
                 descriptor.name = name;
-                if (o === object) 
+                if (o === object)
                     descriptor.isOwn = true;
                 descriptors.push(descriptor);
             }
             if (ownProperties) {
                 if (object.__proto__ && !accessorPropertiesOnly)
                     descriptors.push({ name: "__proto__", value: object.__proto__, writable: true, configurable: true, enumerable: false, isOwn: true});
                 break;
             }
         }
         return descriptors;
@@ skipping 44 matching lines @@
             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) };
         } 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);
@@ skipping 117 matching lines @@
      * @param {string} callFrameId
      * @return {*}
      */
     restartFrame: function(topCallFrame, callFrameId)
     {
         var callFrame = this._callFrameForId(topCallFrame, callFrameId);
         if (!callFrame)
             return "Could not find call frame with given id";
         var result = callFrame.restart();
         if (result === false)
-            result = "Restart frame is not supported"; 
+            result = "Restart frame is not supported";
         return result;
     },
 
     /**
      * Either callFrameId or functionObjectId must be specified.
      * @param {Object} topCallFrame
      * @param {string|boolean} callFrameId or false
      * @param {string|boolean} functionObjectId or false
      * @param {number} scopeNumber
      * @param {string} variableName
-     * @param {string} newValueJsonString RuntimeAgent.CallArgument structure serialized as string 
-     * @return {string|undefined} undefined if success or an error message 
+     * @param {string} newValueJsonString RuntimeAgent.CallArgument structure serialized as string
+     * @return {string|undefined} undefined if success or an error message
      */
     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);    
+            setter = callFrame.setVariableValue.bind(callFrame);
         } else {
             var parsedFunctionId = this._parseObjectId(/** @type {string} */ (functionObjectId));
             var func = this._objectForId(parsedFunctionId);
             if (typeof func !== "function")
                 return "Cannot resolve function by id.";
-            setter = InjectedScriptHost.setFunctionVariableValue.bind(InjectedScriptHost, func); 
+            setter = InjectedScriptHost.setFunctionVariableValue.bind(InjectedScriptHost, func);
         }
         var newValueJson;
         try {
             newValueJson = InjectedScriptHost.evaluate("(" + newValueJsonString + ")");
         } catch (e) {
             return "Failed to parse new value JSON " + newValueJsonString + " : " + e;
         }
         var resolvedValue;
         try {
             resolvedValue = this._resolveCallArgument(newValueJson);
         } catch (e) {
             return String(e);
         }
         try {
             setter(scopeNumber, variableName, resolvedValue);
         } catch (e) {
             return "Failed to change variable value: " + e;
         }
         return undefined;
     },
 
+    getCallFrameScopes: function(topCallFrame, callFrameId)
+    {
+        var callFrame = this._callFrameForId(topCallFrame, callFrameId);
+        if (!callFrame)
+            return "Could not find call frame with given id";
+        callFrame.rereadScopes();
+        return InjectedScript.CallFrameProxy._wrapScopeChain(callFrame);
+    },
+
     /**
      * @param {Object} topCallFrame
      * @param {string} callFrameId
      * @return {Object}
      */
     _callFrameForId: function(topCallFrame, callFrameId)
     {
         var parsedCallFrameId = InjectedScriptHost.evaluate("(" + callFrameId + ")");
         var ordinal = parsedCallFrameId["ordinal"];
         var callFrame = topCallFrame;
@@ skipping 29 matching lines @@
     {
         var object = this.findObjectById(objectId);
         if (!object || this._subtype(object) !== "node")
             return null;
         return /** @type {Node} */ (object);
     },
 
     /**
      * @param {string} name
      * @return {Object}
-     */ 
+     */
     module: function(name)
     {
         return this._modules[name];
     },
 
     /**
      * @param {string} name
      * @param {string} source
      * @return {Object}
-     */ 
+     */
     injectModule: function(name, source)
     {
         delete this._modules[name];
         var moduleFunction = InjectedScriptHost.evaluate("(" + source + ")");
         if (typeof moduleFunction !== "function") {
             inspectedWindow.console.error("Web Inspector error: A function was expected for module %s evaluation", name);
             return null;
         }
         var module = moduleFunction.call(inspectedWindow, InjectedScriptHost, inspectedWindow, injectedScriptId, this);
         this._modules[name] = module;
@@ skipping 212 matching lines @@
                 if (!("value" in descriptor) || !descriptor.enumerable) {
                     preview.lossless = false;
                     continue;
                 }
 
                 var value = descriptor.value;
                 if (value === null) {
                     this._appendPropertyPreview(preview, { name: name, type: "object", value: "null" }, propertiesThreshold);
                     continue;
                 }
-    
+
                 const maxLength = 100;
                 var type = typeof value;
 
                 if (InjectedScript.primitiveTypes[type]) {
                     if (type === "string") {
                         if (value.length > maxLength) {
                             value = this._abbreviateString(value, maxLength, true);
                             preview.lossless = false;
                         }
                         value = value.replace(/\n/g, "\u21B5");
@@ skipping 64 matching lines @@
 /**
  * @constructor
  * @param {number} ordinal
  * @param {Object} callFrame
  */
 InjectedScript.CallFrameProxy = function(ordinal, callFrame)
 {
     this.callFrameId = "{\"ordinal\":" + ordinal + ",\"injectedScriptId\":" + injectedScriptId + "}";
     this.functionName = (callFrame.type === "function" ? callFrame.functionName : "");
     this.location = { scriptId: String(callFrame.sourceID), lineNumber: callFrame.line, columnNumber: callFrame.column };
-    this.scopeChain = this._wrapScopeChain(callFrame);
+    this.scopeChain = InjectedScript.CallFrameProxy._wrapScopeChain(callFrame);
     this.this = injectedScript._wrapObject(callFrame.thisObject, "backtrace");
 }
 
 InjectedScript.CallFrameProxy.prototype = {
-    /**
-     * @param {Object} callFrame
-     * @return {!Array.<DebuggerAgent.Scope>}
-     */
-    _wrapScopeChain: function(callFrame)
-    {
-        var scopeChain = callFrame.scopeChain;
-        var scopeChainProxy = [];
-        for (var i = 0; i < scopeChain.length; i++) {
-            var scope = InjectedScript.CallFrameProxy._createScopeJson(callFrame.scopeType(i), scopeChain[i], "backtrace");
-            scopeChainProxy.push(scope);
-        }
-        return scopeChainProxy;
+}
+
+/**
+ * @param {Object} callFrame
+ * @return {!Array.<DebuggerAgent.Scope>}
+ */
+InjectedScript.CallFrameProxy._wrapScopeChain = function(callFrame)
+{
+    var scopeChain = callFrame.scopeChain;
+    var scopeChainProxy = [];
+    for (var i = 0; i < scopeChain.length; i++) {
+        var scope = InjectedScript.CallFrameProxy._createScopeJson(callFrame.scopeType(i), scopeChain[i], "backtrace");
+        scopeChainProxy.push(scope);
     }
-}
+    return scopeChainProxy;
+};
 
 /**
  * @param {number} scopeTypeCode
  * @param {*} scopeObject
  * @param {string} groupId
  * @return {!DebuggerAgent.Scope}
  */
 InjectedScript.CallFrameProxy._createScopeJson = function(scopeTypeCode, scopeObject, groupId) {
     const GLOBAL_SCOPE = 0;
     const LOCAL_SCOPE = 1;
@@ skipping 297 matching lines @@
      */
     _logEvent: function(event)
     {
         inspectedWindow.console.log(event.type, event);
     }
 }
 
 injectedScript._commandLineAPIImpl = new CommandLineAPIImpl();
 return injectedScript;
 })