Support set variable value for WebKit protocol

plugins/org.chromium.sdk.wipbackend.dev/src/org/chromium/sdk/internal/wip/WipContextBuilder.java

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.sdk.internal.wip;
 
 import static org.chromium.sdk.util.BasicUtil.getSafe;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ skipping 311 matching lines @@
         functionName = frameData.functionName();
         id = frameData.callFrameId();
         sourceId = frameData.location().scriptId();
         final List<ScopeValue> scopeDataList = frameData.scopeChain();
 
         scopeData = LazyConstructable.create(new LazyConstructable.Factory<List<JsScope>>() {
           @Override
           public List<JsScope> construct() {
             final List<JsScope> scopes = new ArrayList<JsScope>(scopeDataList.size());
 
+            ScopeHolderParams holderParams = new ScopeHolderParams(id, null);
+
             for (int i = 0; i < scopeDataList.size(); i++) {
               ScopeValue scopeData = scopeDataList.get(i);
-              scopes.add(createScope(scopeData, valueLoader));
+              scopes.add(createScope(scopeData, valueLoader, holderParams, i));
             }
             return scopes;
           }
         });
 
         RemoteObjectValue thisObjectData = frameData.getThis();
         if (thisObjectData == null) {
           LOGGER.log(Level.SEVERE, "Missing local scope", new Exception());
           thisObject = null;
         } else {
@@ skipping 58 matching lines @@
       public String getFunctionName() {
         return functionName;
       }
 
       @Override
       public JsEvaluateContext getEvaluateContext() {
         return evaluateContext;
       }
 
       private JsVariable createSimpleNameVariable(String name, RemoteObjectValue thisObjectData) {
-        return valueLoader.getValueBuilder().createVariable(thisObjectData, name);
+        return valueLoader.getValueBuilder().createVariable(thisObjectData, name, null);
       }
 
       private final WipEvaluateContextBase<?> evaluateContext =
           new WipEvaluateContextBase<EvaluateOnCallFrameData>(getValueLoader()) {
         @Override
         protected WipParamsWithResponse<EvaluateOnCallFrameData> createRequestParams(
             String expression, WipValueLoader destinationValueLoader) {
           return new EvaluateOnCallFrameParams(id, expression,
               destinationValueLoader.getObjectGroupId(), false, null, false, null);
         }
@@ skipping 132 matching lines @@
       return callFrameImpl.restart(callback, syncCallback);
     }
 
     @Override
     public boolean canRestartFrame(CallFrame callFrame) {
       return callFrame.getScript() != null;
     }
   };
 
 
-  static JsScope createScope(ScopeValue scopeData, WipValueLoader valueLoader) {
+  static JsScope createScope(ScopeValue scopeData, WipValueLoader valueLoader,
+      ScopeHolderParams holderParams, int scopeIndex) {
     JsScope.Type type = WIP_TO_SDK_SCOPE_TYPE.get(scopeData.type());
     if (type == null) {
       type = JsScope.Type.UNKNOWN;
     }
     if (type == JsScope.Type.WITH || type == JsScope.Type.GLOBAL) {
       return new ObjectScopeImpl(scopeData, type, valueLoader);
     } else {
-      return new DeclarativeScopeImpl(scopeData, type, valueLoader);
+      ScopeParams scopeParams = new ScopeParams(holderParams, scopeIndex);
+      return new DeclarativeScopeImpl(scopeData, scopeParams, type, valueLoader);
     }
   }
 
   private static class DeclarativeScopeImpl implements JsScope.Declarative {
     private final AsyncFutureRef<Getter<ScopeVariables>> propertiesRef =
         new AsyncFutureRef<Getter<ScopeVariables>>();
     private final String objectId;
+    private final ScopeParams scopeParams;
     private final Type type;
     private final WipValueLoader valueLoader;
 
-    public DeclarativeScopeImpl(ScopeValue scopeData, Type type, WipValueLoader valueLoader) {
+    public DeclarativeScopeImpl(ScopeValue scopeData, ScopeParams scopeParams, Type type,
+        WipValueLoader valueLoader) {
       this.type = type;
+      this.scopeParams = scopeParams;
       this.objectId = scopeData.object().objectId();
       this.valueLoader = valueLoader;
     }
 
     @Override public Type getType() {
       return type;
     }
 
     @Override public Declarative asDeclarativeScope() {
       return this;
@@ skipping 37 matching lines @@
         @Override
         public Getter<ScopeVariables> process(List<? extends PropertyDescriptorValue> propertyList,
             List<? extends InternalPropertyDescriptorValue> internalPropertyList,
             int currentCacheState) {
           final List<JsVariable> properties = new ArrayList<JsVariable>(propertyList.size());
 
           WipValueBuilder valueBuilder = valueLoader.getValueBuilder();
           for (PropertyDescriptorValue property : propertyList) {
             final String name = property.name();
 
-            JsVariable variable;
-            if (objectId == null) {
-              variable = valueBuilder.createVariable(property.value(), name);
-            } else {
-              variable = valueBuilder.createObjectProperty(property, objectId, name);
-            }
+            JsVariable variable = valueBuilder.createVariable(property.value(), name, scopeParams);
             properties.add(variable);
           }
           final ScopeVariables scopeVariables = new ScopeVariables(properties, currentCacheState);
           return new Getter<ScopeVariables>() {
             @Override
             ScopeVariables get() {
               return scopeVariables;
             }
           };
         }
 
         @Override
         public Getter<ScopeVariables> getEmptyResult() {
           return EMPTY_SCOPE_VARIABLES_OPTIONAL;
         }
 
         @Override
         public Getter<ScopeVariables> forException(Exception exception) {
           return WipValueLoader.Getter.newFailure(exception);
         }
       };
       // This is blocking.
       valueLoader.loadPropertiesInFuture(objectId, processor, reload, currentCacheState,
           propertiesRef);
     }
   }
 
+  static class ScopeHolderParams {
+    private final String callFrameId;
+    private final String functionId;
+
+    ScopeHolderParams(String callFrameId, String functionId) {
+      this.callFrameId = callFrameId;
+      this.functionId = functionId;
+    }
+  }
+
+  static class ScopeParams {
+    private final ScopeHolderParams scopeHolder;
+    private final int scopeIndex;
+
+    private ScopeParams(ScopeHolderParams scopeHolder, int scopeIndex) {
+      this.scopeHolder = scopeHolder;
+      this.scopeIndex = scopeIndex;
+    }
+    String getCallFrameId() {
+      return scopeHolder.callFrameId;
+    }
+    String getFunctionId() {
+      return scopeHolder.functionId;
+    }
+    int getScopeNumber() {
+      return scopeIndex;
+    }
+  }
+
   private static class ObjectScopeImpl implements JsScope.ObjectBased {
     private final JsValue jsValue;
     private final JsScope.Type type;
 
     ObjectScopeImpl(ScopeValue scopeData, JsScope.Type type, WipValueLoader valueLoader) {
       this.jsValue = valueLoader.getValueBuilder().wrap(scopeData.object());
       this.type = type;
     }
 
     @Override public Type getType() {
@@ skipping 91 matching lines @@
     default:
       throw new RuntimeException();
     }
   }
 
   private static final ResumeParams RESUME_PARAMS = new ResumeParams();
   private static final StepIntoParams STEP_INTO_PARAMS = new StepIntoParams();
   private static final StepOutParams STEP_OUT_PARAMS = new StepOutParams();
   private static final StepOverParams STEP_OVER_PARAMS = new StepOverParams();
 }