Move setValue operation into a separate JsDeclarativeVariable interface

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;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import org.chromium.sdk.Breakpoint;
 import org.chromium.sdk.CallFrame;
 import org.chromium.sdk.DebugContext;
 import org.chromium.sdk.DebugContext.StepAction;
 import org.chromium.sdk.ExceptionData;
 import org.chromium.sdk.JavascriptVm;
+import org.chromium.sdk.JsDeclarativeVariable;
 import org.chromium.sdk.JsEvaluateContext;
 import org.chromium.sdk.JsObject;
 import org.chromium.sdk.JsScope;
 import org.chromium.sdk.JsValue;
 import org.chromium.sdk.JsVariable;
 import org.chromium.sdk.RelayOk;
 import org.chromium.sdk.RemoteValueMapping;
 import org.chromium.sdk.RestartFrameExtension;
 import org.chromium.sdk.SyncCallback;
 import org.chromium.sdk.TextStreamPosition;
@@ skipping 368 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, null);
+        return valueLoader.getValueBuilder().createVariable(thisObjectData, name);
       }
 
       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 179 matching lines @@
 
     @Override public ObjectBased asObjectBased() {
       return null;
     }
 
     @Override public <R> R accept(Visitor<R> visitor) {
       return visitor.visitDeclarative(this);
     }
 
     @Override
-    public List<? extends JsVariable> getVariables() throws MethodIsBlockingException {
+    public List<? extends JsDeclarativeVariable> getVariables() throws MethodIsBlockingException {
       int currentCacheState = valueLoader.getCacheState();
       if (propertiesRef.isInitialized()) {
         ScopeVariables result = propertiesRef.getSync().get();
         if (result.cacheState == currentCacheState) {
           return result.variables;
         }
         startLoadOperation(true, currentCacheState);
       } else {
         startLoadOperation(false, currentCacheState);
       }
 
       // This is blocking.
       return propertiesRef.getSync().get().variables;
     }
 
     /**
      * Starts load operation that works synchronously, i.e. it may block the calling method.
      * This is done because some thread must take post-processing anyway and it shouldn't
      * be the Dispatch thread.
      * The method may not be blocking, if another thread is already doing the same operation.
      */
     private void startLoadOperation(boolean reload, int currentCacheState)
         throws MethodIsBlockingException {
       WipValueLoader.LoadPostprocessor<Getter<ScopeVariables>> processor =
           new WipValueLoader.LoadPostprocessor<Getter<ScopeVariables>>() {
         @Override
         public Getter<ScopeVariables> process(List<? extends PropertyDescriptorValue> propertyList,
             List<? extends InternalPropertyDescriptorValue> internalPropertyList,
             int currentCacheState) {
-          final List<JsVariable> properties = new ArrayList<JsVariable>(propertyList.size());
+          final List<JsDeclarativeVariable> properties =
+              new ArrayList<JsDeclarativeVariable>(propertyList.size());
 
           WipValueBuilder valueBuilder = valueLoader.getValueBuilder();
           for (PropertyDescriptorValue property : propertyList) {
             final String name = property.name();
 
-            JsVariable variable = valueBuilder.createVariable(property.value(), name, scopeParams);
+            JsDeclarativeVariable variable =
+                valueBuilder.createDeclarativeVariable(property.value(), name, scopeParams);
             properties.add(variable);
           }
           final ScopeVariables scopeVariables = new ScopeVariables(properties, currentCacheState);
           return new Getter<ScopeVariables>() {
             @Override
             ScopeVariables get() {
               return scopeVariables;
             }
           };
         }
@@ skipping 107 matching lines @@
     WIP_TO_SDK_SCOPE_TYPE.put(ScopeValue.Type.GLOBAL, JsScope.Type.GLOBAL);
     WIP_TO_SDK_SCOPE_TYPE.put(ScopeValue.Type.LOCAL, JsScope.Type.LOCAL);
     WIP_TO_SDK_SCOPE_TYPE.put(ScopeValue.Type.WITH, JsScope.Type.WITH);
     WIP_TO_SDK_SCOPE_TYPE.put(ScopeValue.Type.CLOSURE, JsScope.Type.CLOSURE);
     WIP_TO_SDK_SCOPE_TYPE.put(ScopeValue.Type.CATCH, JsScope.Type.CATCH);
 
     assert WIP_TO_SDK_SCOPE_TYPE.size() == ScopeValue.Type.values().length;
   }
 
   private static class ScopeVariables {
-    final List<JsVariable> variables;
+    final List<JsDeclarativeVariable> variables;
     final int cacheState;
 
-    ScopeVariables(List<JsVariable> variables, int cacheState) {
+    ScopeVariables(List<JsDeclarativeVariable> variables, int cacheState) {
       this.variables = variables;
       this.cacheState = cacheState;
     }
   }
 
   private static final Getter<ScopeVariables> EMPTY_SCOPE_VARIABLES_OPTIONAL =
       new Getter<ScopeVariables>() {
         private final ScopeVariables value =
-          new ScopeVariables(Collections.<JsVariable>emptyList(), Integer.MAX_VALUE);
+          new ScopeVariables(Collections.<JsDeclarativeVariable>emptyList(), Integer.MAX_VALUE);
 
         @Override ScopeVariables get() {
           return value;
         }
       };
 
 
   private WipParams sdkStepToProtocolStep(StepAction stepAction) {
     switch (stepAction) {
     case CONTINUE:
       return RESUME_PARAMS;
     case IN:
       return STEP_INTO_PARAMS;
     case OUT:
       return STEP_OUT_PARAMS;
     case OVER:
       return STEP_OVER_PARAMS;
     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();
 }