Move setValue operation into a separate JsDeclarativeVariable interface

plugins/org.chromium.sdk.wipbackend.dev/src/org/chromium/sdk/internal/wip/WipValueBuilder.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.List;
 import java.util.Map;
 import java.util.SortedMap;
 import java.util.TreeMap;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.logging.Logger;
 
 import org.chromium.sdk.FunctionScopeExtension;
 import org.chromium.sdk.JsArray;
+import org.chromium.sdk.JsDeclarativeVariable;
 import org.chromium.sdk.JsEvaluateContext.EvaluateCallback;
 import org.chromium.sdk.JsFunction;
 import org.chromium.sdk.JsObject;
 import org.chromium.sdk.JsObjectProperty;
 import org.chromium.sdk.JsScope;
 import org.chromium.sdk.JsValue;
 import org.chromium.sdk.JsValue.Type;
 import org.chromium.sdk.JsVariable;
 import org.chromium.sdk.RelayOk;
 import org.chromium.sdk.Script;
@@ skipping 64 matching lines @@
 
   public JsObjectProperty createObjectProperty(final PropertyDescriptorValue propertyDescriptor,
       final String hostObjectRefId, String name) {
     JsValue jsValue = wrap(propertyDescriptor.value());
 
     final JsValue getter = wrap(propertyDescriptor.get());
 
     final JsValue setter = wrap(propertyDescriptor.set());
 
     return new ObjectPropertyBase(jsValue, name) {
-
-      @Override public boolean isMutable() {
-        return false;
-      }
       @Override public boolean isWritable() {
         return propertyDescriptor.writable();
       }
       @Override public JsValue getGetter() {
         return getter;
       }
       @Override public JsValue getSetter() {
         return setter;
       }
       @Override public boolean isConfigurable() {
         return propertyDescriptor.configurable();
       }
       @Override public boolean isEnumerable() {
         return propertyDescriptor.enumerable();
       }
 
       @Override
       public JsFunction getGetterAsFunction() {
         JsObject getterObject = getter.asObject();
         if (getterObject == null) {
           return null;
         }
         return getterObject.asFunction();
       }
 
       @Override
-      public RelayOk setValue(JsValue newValue, SetValueCallback callback,
-          SyncCallback syncCallback) throws UnsupportedOperationException {
-        throw new UnsupportedOperationException();
-      }
-
-      @Override
       public RelayOk evaluateGet(EvaluateCallback callback, SyncCallback syncCallback) {
         WipContextBuilder.GlobalEvaluateContext evaluateContext =
             new WipContextBuilder.GlobalEvaluateContext(valueLoader);
 
         JsFunction getterFunction = getGetterAsFunction();
         if (getterFunction == null) {
           throw new RuntimeException("Getter is not a function");
         }
 
         Map<String, SerializableValue> context = new HashMap<String, SerializableValue>(2);
         context.put(GETTER_VAR_NAME, (SerializableValue) getterFunction);
         context.put(OBJECT_VAR_NAME, SerializableValue.Util.wrapRefId(hostObjectRefId));
 
         return evaluateContext.evaluateAsyncImpl(EVALUATE_EXPRESSION,
             context, valueLoader, callback, syncCallback);
       }
       private static final String GETTER_VAR_NAME = "gttr";
       private static final String OBJECT_VAR_NAME = "obj";
       private static final String EVALUATE_EXPRESSION =
           GETTER_VAR_NAME + ".call(" + OBJECT_VAR_NAME + ")";
     };
   }
 
-  public JsVariable createVariable(RemoteObjectValue valueData, String name,
+  public JsVariable createVariable(RemoteObjectValue valueData, String name) {
+    return new VariableImpl(name, wrap(valueData));
+  }
+
+  public JsDeclarativeVariable createDeclarativeVariable(RemoteObjectValue valueData, String name,
       final WipContextBuilder.ScopeParams scopeParams) {
     JsValue jsValue = wrap(valueData);
-
-    VariableValueChanger valueChanger;
-    if (scopeParams == null) {
-      valueChanger = null;
-    } else {
-      valueChanger = new VariableValueChanger() {
-        @Override
-        RelayOk setValue(String variableName, JsValue newValue,
-            final GenericCallback<JsValue> callback, SyncCallback syncCallback)
-            throws UnsupportedOperationException {
-          final JsValueBase jsValueBase = JsValueBase.cast(newValue);
-          SetVariableValueParams params = new SetVariableValueParams(scopeParams.getScopeNumber(),
-              variableName, jsValueBase.createCallArgumentParam(), scopeParams.getCallFrameId(),
-              scopeParams.getFunctionId());
-          WipCommandCallback rawCallback = new WipCommandCallback.Default() {
-            @Override protected void onSuccess(Success success) {
-              callback.success(jsValueBase);
-            }
-            @Override protected void onError(String message) {
-              callback.failure(new Exception(message));
-            }
-          };
-          return valueLoader.getTabImpl().getCommandProcessor().send(params,
-              rawCallback, syncCallback);
-        }
-      };
-    }
-
-    return new VariableImpl(name, jsValue, valueChanger);
+    VariableValueChanger valueChanger = new VariableValueChanger() {
+          @Override
+          RelayOk setValue(String variableName, JsValue newValue,
+              final GenericCallback<JsValue> callback, SyncCallback syncCallback)
+                  throws UnsupportedOperationException {
+            final JsValueBase jsValueBase = JsValueBase.cast(newValue);
+            SetVariableValueParams params = new SetVariableValueParams(scopeParams.getScopeNumber(),
+                variableName, jsValueBase.createCallArgumentParam(), scopeParams.getCallFrameId(),
+                scopeParams.getFunctionId());
+            WipCommandCallback rawCallback = new WipCommandCallback.Default() {
+              @Override protected void onSuccess(Success success) {
+                callback.success(jsValueBase);
+              }
+              @Override protected void onError(String message) {
+                callback.failure(new Exception(message));
+              }
+            };
+            return valueLoader.getTabImpl().getCommandProcessor().send(params,
+                rawCallback, syncCallback);
+          }
+        };
+    return new DeclarativeVariable(name, jsValue, valueChanger);
   }
 
   public JsValue wrap(RemoteObjectValue valueData) {
     if (valueData == null) {
       return null;
     }
     return getValueType(valueData).build(valueData, valueLoader);
   }
 
   private static ValueType getValueType(RemoteObjectValue valueData) {
@@ skipping 433 matching lines @@
     }
   };
 
   private static abstract class VariableBase implements JsVariable {
     private final String name;
 
     VariableBase(String name) {
       this.name = name;
     }
 
-    @Override
-    public boolean isReadable() {
-      return true;
-    }
-
-    @Override
-    public String getName() {
+    @Override public String getName() {
       return name;
     }
   }
 
   private static class VariableImpl extends VariableBase {
+    private final JsValue jsValue;
+
+    VariableImpl(String name, JsValue jsValue) {
+      super(name);
+      this.jsValue = jsValue;
+    }
+
+    @Override public JsObjectProperty asObjectProperty() {
+      return null;
+    }
+    @Override public JsDeclarativeVariable asDeclarativeVariable() {
+      return null;
+    }
+    @Override public JsValue getValue() {
+      return jsValue;
+    }
+  }
+
+  private static class DeclarativeVariable extends VariableBase implements JsDeclarativeVariable {
     private final VariableValueChanger valueChanger;
     private volatile JsValue jsValue;
 
-    VariableImpl(String name, JsValue jsValue, VariableValueChanger valueChanger) {
+    DeclarativeVariable(String name, JsValue jsValue, VariableValueChanger valueChanger) {
       super(name);
       this.jsValue = jsValue;
       this.valueChanger = valueChanger;
     }
 
     @Override public JsObjectProperty asObjectProperty() {
       return null;
     }
+    @Override public JsDeclarativeVariable asDeclarativeVariable() {
+      return this;
+    }
     @Override public boolean isMutable() {
       return valueChanger != null;
     }
     @Override public JsValue getValue() {
       return jsValue;
     }
 
     @Override
     public RelayOk setValue(JsValue newValue, final SetValueCallback callback,
         SyncCallback syncCallback) throws UnsupportedOperationException {
       if (valueChanger == null) {
         throw new UnsupportedOperationException();
       }
       GenericCallback<JsValue> rawCallback = new GenericCallback<JsValue>() {
         @Override
         public void success(JsValue value) {
-          VariableImpl.this.jsValue = value;
+          DeclarativeVariable.this.jsValue = value;
           if (callback != null) {
             callback.success();
           }
         }
 
         @Override
         public void failure(Exception exception) {
           if (callback != null) {
             callback.failure(exception);
           }
@@ skipping 17 matching lines @@
       super(name);
       this.jsValue = jsValue;
     }
 
     @Override public JsValue getValue() {
       return jsValue;
     }
     @Override public JsObjectProperty asObjectProperty() {
       return this;
     }
+    @Override public JsDeclarativeVariable asDeclarativeVariable() {
+      return null;
+    }
   }
 
   private static class ObjectType extends ValueType {
     @Override
     JsValue build(RemoteObjectValue valueData, WipValueLoader valueLoader) {
       ValueType secondLevelValueType =
           getSafe(PROTOCOL_SUBTYPE_TO_VALUE_TYPE, valueData.subtype());
 
       if (secondLevelValueType == null) {
         LOGGER.severe("Unexpected value type: " + valueData.type() + " " + valueData.subtype());
@@ skipping 37 matching lines @@
         new SingletonPrimitiveType(JsValue.Type.TYPE_UNDEFINED, "undefined"));
 
     PROTOCOL_TYPE_TO_VALUE_TYPE.put(RemoteObjectValue.Type.OBJECT, new ObjectType());
     PROTOCOL_TYPE_TO_VALUE_TYPE.put(RemoteObjectValue.Type.FUNCTION, new FunctionType());
 
     assert PROTOCOL_TYPE_TO_VALUE_TYPE.size() == RemoteObjectValue.Type.values().length;
   }
 
   private static final ValueType DEFAULT_VALUE_TYPE = new ObjectSubtype(JsValue.Type.TYPE_OBJECT);
 }