Support set variable value for WebKit protocol

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;
@@ skipping 15 matching lines @@
 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;
 import org.chromium.sdk.SyncCallback;
 import org.chromium.sdk.TextStreamPosition;
 import org.chromium.sdk.internal.wip.WipValueLoader.Getter;
 import org.chromium.sdk.internal.wip.WipValueLoader.ObjectProperties;
+import org.chromium.sdk.internal.wip.protocol.input.WipCommandResponse.Success;
 import org.chromium.sdk.internal.wip.protocol.input.debugger.FunctionDetailsValue;
 import org.chromium.sdk.internal.wip.protocol.input.debugger.LocationValue;
 import org.chromium.sdk.internal.wip.protocol.input.debugger.ScopeValue;
 import org.chromium.sdk.internal.wip.protocol.input.runtime.PropertyDescriptorValue;
 import org.chromium.sdk.internal.wip.protocol.input.runtime.RemoteObjectValue;
+import org.chromium.sdk.internal.wip.protocol.output.debugger.SetVariableValueParams;
 import org.chromium.sdk.internal.wip.protocol.output.runtime.CallArgumentParam;
 import org.chromium.sdk.util.AsyncFutureRef;
+import org.chromium.sdk.util.GenericCallback;
 import org.chromium.sdk.util.JavaScriptExpressionBuilder;
 import org.chromium.sdk.util.MethodIsBlockingException;
 
 /**
  * A builder for implementations of {@link JsValue} and {@link JsVariable}.
  * It works in pair with {@link WipValueLoader}.
  */
 class WipValueBuilder {
   private static final Logger LOGGER = Logger.getLogger(WipValueBuilder.class.getName());
 
@@ skipping 35 matching lines @@
         throw new IllegalArgumentException("Incorrect argument type " + value.getClass());
       }
       return (JsValueBase) value;
     }
   }
 
   public JsObjectProperty createObjectProperty(final PropertyDescriptorValue propertyDescriptor,
       final String hostObjectRefId, String name) {
     JsValue jsValue = wrap(propertyDescriptor.value());
 
-    final JsValue getter = wrapPropertyDescriptorFunction(propertyDescriptor.get(), "getter");
+    final JsValue getter = wrap(propertyDescriptor.get());
 
-    final JsValue setter = wrapPropertyDescriptorFunction(propertyDescriptor.set(), "setter");
+    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 + ")";
     };
   }
 
-  private JsValue wrapPropertyDescriptorFunction(RemoteObjectValue value, String symbolicName) {
-    return wrap(value);
-  }
+  public JsVariable createVariable(RemoteObjectValue valueData, String name,
+      final WipContextBuilder.ScopeParams scopeParams) {
+    JsValue jsValue = wrap(valueData);
 
-  public JsVariable createVariable(RemoteObjectValue valueData, String name) {
-    JsValue jsValue = wrap(valueData);
-    return createVariable(jsValue, name);
+    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);
   }
 
   public JsValue wrap(RemoteObjectValue valueData) {
     if (valueData == null) {
       return null;
     }
     return getValueType(valueData).build(valueData, valueLoader);
   }
 
-  public static JsVariable createVariable(JsValue jsValue, String name) {
-    return new VariableImpl(jsValue, name);
-  }
-
   private static ValueType getValueType(RemoteObjectValue valueData) {
     RemoteObjectValue.Type protocolType = valueData.type();
     ValueType result = getSafe(PROTOCOL_TYPE_TO_VALUE_TYPE, protocolType);
 
     if (result == null) {
       LOGGER.severe("Unexpected value type: " + protocolType);
       result = DEFAULT_VALUE_TYPE;
     }
     return result;
   }
@@ skipping 384 matching lines @@
         };
       }
 
       @Override
       public List<? extends JsScope> getScopes() {
         List<ScopeValue> data = getFunctionDetails().scopeChain();
         if (data == null) {
           return Collections.emptyList();
         }
         List<JsScope> result = new ArrayList<JsScope>(data.size());
-        for (ScopeValue scopeValue : data) {
-          result.add(WipContextBuilder.createScope(scopeValue, getRemoteValueMapping()));
+        WipContextBuilder.ScopeHolderParams holderParams =
+            new WipContextBuilder.ScopeHolderParams(null, getRefId());
+        for (int i = 0; i < data.size(); i++) {
+          ScopeValue scopeValue = data.get(i);
+          result.add(WipContextBuilder.createScope(scopeValue, getRemoteValueMapping(),
+              holderParams, i));
         }
         return result;
       }
 
       private FunctionDetailsValue getFunctionDetails() throws MethodIsBlockingException {
         if (!loadedPositionRef.isInitialized()) {
           getRemoteValueMapping().loadFunctionLocationInFuture(getValueData().objectId(),
               loadedPositionRef);
         }
         return loadedPositionRef.getSync().get();
       }
     }
   }
 
   private interface FunctionScopeAccess {
     List<? extends JsScope> getScopes();
   }
 
   static final FunctionScopeExtension FUNCTION_SCOPE_EXTENSION = new FunctionScopeExtension() {
     @Override
     public List<? extends JsScope> getScopes(JsFunction function)
         throws MethodIsBlockingException {
       FunctionScopeAccess functionScopeAccess = (FunctionScopeAccess) function;
       return functionScopeAccess.getScopes();
     }
   };
 
   private static abstract class VariableBase implements JsVariable {
-    private final JsValue jsValue;
     private final String name;
 
-    VariableBase(JsValue jsValue, String name) {
-      this.jsValue = jsValue;
+    VariableBase(String name) {
       this.name = name;
     }
 
     @Override
     public boolean isReadable() {
       return true;
     }
 
     @Override
-    public JsValue getValue() {
-      return jsValue;
-    }
-
-    @Override
     public String getName() {
       return name;
     }
-
-    @Override
-    public boolean isMutable() {
-      return false;
-    }
-
-    @Override
-    public RelayOk setValue(JsValue newValue, SetValueCallback callback,
-        SyncCallback syncCallback) throws UnsupportedOperationException {
-      throw new UnsupportedOperationException();
-    }
   }
 
   private static class VariableImpl extends VariableBase {
-    VariableImpl(JsValue jsValue, String name) {
-      super(jsValue, name);
+    private final VariableValueChanger valueChanger;
+    private volatile JsValue jsValue;
+
+    VariableImpl(String name, JsValue jsValue, VariableValueChanger valueChanger) {
+      super(name);
+      this.jsValue = jsValue;
+      this.valueChanger = valueChanger;
     }
 
     @Override public JsObjectProperty asObjectProperty() {
       return null;
     }
+    @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;
+          if (callback != null) {
+            callback.success();
+          }
+        }
+
+        @Override
+        public void failure(Exception exception) {
+          if (callback != null) {
+            callback.failure(exception);
+          }
+        }
+      };
+      return valueChanger.setValue(getName(), newValue, rawCallback, syncCallback);
+    }
+  }
+
+  static abstract class VariableValueChanger {
+    abstract RelayOk setValue(String variableName, JsValue newValue,
+        GenericCallback<JsValue> callback, SyncCallback syncCallback)
+        throws UnsupportedOperationException;
   }
 
   private static abstract class ObjectPropertyBase
       extends VariableBase implements JsObjectProperty {
+    private final JsValue jsValue;
+
     ObjectPropertyBase(JsValue jsValue, String name) {
-      super(jsValue, name);
+      super(name);
+      this.jsValue = jsValue;
     }
 
+    @Override public JsValue getValue() {
+      return jsValue;
+    }
     @Override public JsObjectProperty asObjectProperty() {
       return this;
     }
   }
 
   private static class ObjectType extends ValueType {
     @Override
     JsValue build(RemoteObjectValue valueData, WipValueLoader valueLoader) {
       ValueType secondLevelValueType =
           getSafe(PROTOCOL_SUBTYPE_TO_VALUE_TYPE, valueData.subtype());
@@ skipping 40 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);
 }