Fix tests compilation

utils/org.chromium.sdk.tests.system/src/org/chromium/sdk/tests/system/Main.java

 // Copyright (c) 2010 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.tests.system;
 
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
 import org.chromium.sdk.Breakpoint;
 import org.chromium.sdk.CallFrame;
 import org.chromium.sdk.CallbackSemaphore;
 import org.chromium.sdk.ConnectionLogger;
 import org.chromium.sdk.ConnectionLogger.Factory;
 import org.chromium.sdk.DebugContext;
 import org.chromium.sdk.JavascriptVm;
 import org.chromium.sdk.JsEvaluateContext;
+import org.chromium.sdk.JsEvaluateContext.ResultOrException;
 import org.chromium.sdk.JsObject;
 import org.chromium.sdk.JsScope;
+import org.chromium.sdk.JsScope.Declarative;
+import org.chromium.sdk.JsScope.ObjectBased;
 import org.chromium.sdk.JsValue;
 import org.chromium.sdk.JsVariable;
 import org.chromium.sdk.RelayOk;
 import org.chromium.sdk.Script;
 import org.chromium.sdk.wip.WipBackend;
 import org.chromium.sdk.wip.WipBackendFactory;
 import org.chromium.sdk.wip.WipBrowser;
 import org.chromium.sdk.wip.WipBrowserFactory;
 
 /**
@@ skipping 65 matching lines @@
       stateManager.expectEvent(EXPECT_RESUMED_VISITOR);
     }
 
     // Second time check variables and expressions.
     {
       DebugContext context = stateManager.expectEvent(EXPECT_SUSPENDED_VISITOR);
 
       {
         // Check cache dropping.
         JsObject root = evaluateSync(context.getGlobalEvaluateContext(),
-            "(debug_value_1 = {a:2})").getValue().asObject();
+            "(debug_value_1 = {a:2})").asObject();
         if (root == null) {
           throw new RuntimeException();
         }
         String aValue;
         aValue = root.getProperty("a").getValue().getValueString();
         if (!"2".equals(aValue)) {
           throw new SmokeException();
         }
         evaluateSync(context.getGlobalEvaluateContext(), "debug_value_1.a = 3");
 
         root.getRemoteValueMapping().clearCaches();
 
         aValue = root.getProperty("a").getValue().getValueString();
         if (!"3".equals(aValue)) {
           throw new SmokeException();
         }
       }
 
       {
         // Check literals.
         for (LiteralTestCase literal : TEST_LITERALS) {
-          JsVariable resultVar = evaluateSync(context.getGlobalEvaluateContext(),
+          JsValue resultValue = evaluateSync(context.getGlobalEvaluateContext(),
               literal.javaScriptExpression);
-          JsValue resultValue = resultVar.getValue();
           if (resultValue.getType() != literal.expectedType) {
             throw new SmokeException("Unexpected type of '" + literal.javaScriptExpression +
                 "': " + resultValue.getType());
           }
           if (!literal.expectedDescription.equals(resultValue.getValueString())) {
             throw new SmokeException("Unexpected string value of '" +
                 literal.javaScriptExpression + "': " + resultValue.getValueString());
           }
         }
       }
@@ skipping 145 matching lines @@
         }
         return firstTab.attach(stateManager.getTabListener()).getJavascriptVm();
       }
     };
 
     public abstract JavascriptVm connect(InetSocketAddress address, StateManager stateManager,
         Factory connectionLoggerFactory) throws SmokeException, IOException;
   }
 
   private static JsVariable getVariable(JsScope scope, String name) throws SmokeException {
-    for (JsVariable var : scope.getVariables()) {
+    Collection<? extends JsVariable> variables = scope.accept(
+        new JsScope.Visitor<Collection<? extends JsVariable>>() {
+          @Override
+          public Collection<? extends JsVariable> visitDeclarative(Declarative declarativeScope) {
+            return declarativeScope.getVariables();
+          }
+          @Override
+          public Collection<? extends JsVariable> visitObject(ObjectBased objectScope) {
+            return objectScope.getScopeObject().getProperties();
+          }
+        });
+    for (JsVariable var : variables) {
       if (name.equals(var.getName())) {
         return var;
       }
     }
     throw new SmokeException("Failed to find variable " + name);
   }
 
   /**
    * Calls fibonacci expression in context for stack frame and checks the result value.
    */
   private static void checkExpression(CallFrame frame) throws SmokeException {
-    final ValueHolder<JsVariable> variableHolder = new ValueHolder<JsVariable>();
+    final ValueHolder<JsValue> variableHolder = new ValueHolder<JsValue>();
     JsEvaluateContext.EvaluateCallback callback = new JsEvaluateContext.EvaluateCallback() {
-      public void failure(String errorMessage) {
-        variableHolder.setException(new Exception(errorMessage));
+      @Override
+      public void success(ResultOrException result) {
+        result.accept(new ResultOrException.Visitor<Void>() {
+          @Override
+          public Void visitResult(JsValue value) {
+            variableHolder.setValue(value);
+            return null;
+          }
+
+          @Override
+          public Void visitException(JsValue exception) {
+            variableHolder.setException(
+                new Exception("Caught exception: " + exception.getValueString()));
+            return null;
+          }
+        });
       }
-      public void success(JsVariable variable) {
-        variableHolder.setValue(variable);
+
+      @Override public void failure(Exception cause) {
+        variableHolder.setException(new Exception(cause));
       }
     };
     frame.getEvaluateContext().evaluateSync(FIBONACCI_EXPRESSION, null, callback);
-    JsVariable variable = variableHolder.get();
-    String resString = variable.getValue().getValueString();
+    JsValue value = variableHolder.get();
+    String resString = value.getValueString();
     if (!"24".equals(resString)) {
       throw new SmokeException("Wrong expression value");
     }
   }
 
   private static class LiteralTestCase {
     final String javaScriptExpression;
     final JsValue.Type expectedType;
     final String expectedDescription;
 
@@ skipping 186 matching lines @@
     }
     T get() throws SmokeException {
       if (exception != null) {
         throw new SmokeException(exception);
       }
       return val;
     }
   }
 
   static class EvalCallbackImpl implements JsEvaluateContext.EvaluateCallback {
-    JsVariable variable = null;
-    String failure = null;
-    @Override
-    public void success(JsVariable variable) {
-      this.variable = variable;
+    JsValue value = null;
+    Exception failure = null;
+
+    JsValue get() {
+      if (failure != null) {
+        throw new RuntimeException("Failed to evaluate: " + failure);
+      }
+      return value;
     }
 
     @Override
-    public void failure(String errorMessage) {
-      this.failure = errorMessage;
+    public void success(ResultOrException result) {
+      result.accept(new ResultOrException.Visitor<Void>() {
+        @Override
+        public Void visitResult(JsValue value) {
+          EvalCallbackImpl.this.value = value;
+          return null;
+        }
+
+        @Override
+        public Void visitException(JsValue exception) {
+          failure = new Exception("JavaScript exception: " + exception.getValueString());
+          return null;
+        }
+      });
     }
-    JsVariable get() {
-      if (failure != null) {
-        throw new RuntimeException("Failed to evaluate: " + failure);
-      }
-      return variable;
+
+    @Override
+    public void failure(Exception cause) {
+      this.failure = cause;
     }
   }
 
-  private static JsVariable evaluateSync(JsEvaluateContext evaluateContext, String expression) {
+  private static JsValue evaluateSync(JsEvaluateContext evaluateContext, String expression) {
     EvalCallbackImpl callbackImpl = new EvalCallbackImpl();
     evaluateContext.evaluateSync(expression, null, callbackImpl);
     return callbackImpl.get();
   }
 }