Redesign scope API, separate declarative and object scopes.

plugins/org.chromium.sdk.wipbackend.wk118685/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 462 matching lines @@
         return null;
       }
     };
   }
 
   static JsScope createScope(ScopeValue scopeData, WipValueLoader valueLoader) {
     JsScope.Type type = WIP_TO_SDK_SCOPE_TYPE.get(scopeData.type());
     if (type == null) {
       type = JsScope.Type.UNKNOWN;
     }
-    if (type == JsScope.Type.WITH) {
-      return new WithScopeImpl(scopeData, valueLoader);
+    if (type == JsScope.Type.WITH || type == JsScope.Type.GLOBAL) {
+      return new ObjectScopeImpl(scopeData, type, valueLoader);
     } else {
-      return new ScopeImpl(scopeData, type, valueLoader);
+      return new DeclarativeScopeImpl(scopeData, type, valueLoader);
     }
   }
 
-  private static class ScopeImpl implements JsScope {
+  private static class DeclarativeScopeImpl implements JsScope.Declarative {
     private final AsyncFutureRef<Getter<ScopeVariables>> propertiesRef =
         new AsyncFutureRef<Getter<ScopeVariables>>();
     private final String objectId;
     private final Type type;
     private final WipValueLoader valueLoader;
 
-    public ScopeImpl(ScopeValue scopeData, Type type, WipValueLoader valueLoader) {
+    public DeclarativeScopeImpl(ScopeValue scopeData, Type type, WipValueLoader valueLoader) {
       this.type = type;
       this.objectId = scopeData.object().objectId();
       this.valueLoader = valueLoader;
     }
 
-    @Override
-    public Type getType() {
+    @Override public Type getType() {
       return type;
     }
 
-    @Override
-    public WithScope asWithScope() {
+    @Override public Declarative asDeclarativeScope() {
+      return this;
+    }
+
+    @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 {
       int currentCacheState = valueLoader.getCacheState();
       if (propertiesRef.isInitialized()) {
         ScopeVariables result = propertiesRef.getSync().get();
         if (result.cacheState == currentCacheState) {
           return result.variables;
         }
         startLoadOperation(true, currentCacheState);
       } else {
@@ skipping 52 matching lines @@
         public Getter<ScopeVariables> forException(Exception exception) {
           return WipValueLoader.Getter.newFailure(exception);
         }
       };
       // This is blocking.
       valueLoader.loadPropertiesInFuture(objectId, processor, reload, currentCacheState,
           propertiesRef);
     }
   }
 
-  private static class WithScopeImpl implements JsScope.WithScope {
+  private static class ObjectScopeImpl implements JsScope.ObjectBased {
     private final JsValue jsValue;
+    private final JsScope.Type type;
 
-    WithScopeImpl(ScopeValue scopeData, WipValueLoader valueLoader) {
+    ObjectScopeImpl(ScopeValue scopeData, JsScope.Type type, WipValueLoader valueLoader) {
       jsValue = valueLoader.getValueBuilder().wrap(scopeData.object(), null);
+      this.type = type;
+    }
+
+    @Override public Type getType() {
+      return type;
+    }
+
+    @Override public Declarative asDeclarativeScope() {
+      return null;
+    }
+
+    @Override public ObjectBased asObjectBased() {
+      return this;
+    }
+
+    @Override public <R> R accept(Visitor<R> visitor) {
+      return visitor.visitObject(this);
     }
 
     @Override
-    public Type getType() {
-      return Type.WITH;
-    }
-
-    @Override
-    public WithScope asWithScope() {
-      return this;
-    }
-
-    @Override
-    public List<? extends JsVariable> getVariables() throws MethodIsBlockingException {
-      JsObject asObject = jsValue.asObject();
-      if (asObject == null) {
-        return Collections.emptyList();
+    public JsObject getScopeObject() throws MethodIsBlockingException {
+      JsObject jsObject = jsValue.asObject();
+      if (jsObject == null) {
+        throw new RuntimeException("Received scope object value is not an object");
       }
-      return new ArrayList<JsVariable>(asObject.getProperties());
-    }
-
-    @Override
-    public JsValue getWithArgument() {
-      return jsValue;
+      return jsObject;
     }
   }
 
   static final class GlobalEvaluateContext extends WipEvaluateContextBase<EvaluateData> {
 
     GlobalEvaluateContext(WipValueLoader valueLoader) {
       super(valueLoader);
     }
 
     @Override protected WipParamsWithResponse<EvaluateData> createRequestParams(String expression,
@@ skipping 59 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();
 }