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(jsValue, name, 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(JsValue jsValue, String name, VariableValueChanger valueChanger) {

[apavlov, 2013/02/18 11:34:08]

While we are here, it is a good idea to swap the JsValue and String arguments,
since typically the leftmost arguments are passed into the super constructor to
improve readability (like, "the first arguments are the most important ones.
Important enough to go into the superclass").

[Peter Rybin, 2013/02/18 23:32:52]

Done.

+      super(name);
+      this.jsValue = jsValue;
+      this.valueChanger = valueChanger;
     }
 
     @Override public JsObjectProperty asObjectProperty() {
       return null;
     }
+    @Override public boolean isMutable() {

[apavlov, 2013/02/18 11:34:08]

Blank line

[Peter Rybin, 2013/02/18 23:32:52]

We usually keep trivial and really simple methods as 3-liners and together with
each other packed without spaces.

+      return valueChanger != null;
+    }
+    @Override public JsValue getValue() {

[apavlov, 2013/02/18 11:34:08]

Ditto

[Peter Rybin, 2013/02/18 23:32:52]

Same

+      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() {

[apavlov, 2013/02/18 11:34:08]

Ditto

[Peter Rybin, 2013/02/18 23:32:52]

The same

       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 39 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);
 }