src/xwalk/test/android/core/javatests/src/org/xwalk/core/xwview/test/TestHelperBridge.java

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Copyright (c) 2014 Intel Corporation. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5
   6 package org.xwalk.core.xwview.test;
   7
   8 import android.util.Log;
   9 import android.webkit.ValueCallback;
  10 import android.webkit.WebResourceResponse;
  11
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import java.util.concurrent.Callable;
  15 import java.util.concurrent.ConcurrentHashMap;
  16 import java.util.concurrent.CountDownLatch;
  17 import java.util.concurrent.TimeoutException;
  18
  19 import org.chromium.content.browser.test.util.CallbackHelper;
  20 import org.chromium.content.browser.test.util.Criteria;
  21 import org.chromium.content.browser.test.util.TestCallbackHelperContainer.OnPageFinishedHelper;
  22 import org.chromium.content.browser.test.util.TestCallbackHelperContainer.OnPageStartedHelper;
  23 import org.chromium.content.browser.test.util.TestCallbackHelperContainer.OnReceivedErrorHelper;
  24
  25 import org.xwalk.core.XWalkView;
  26
  27 class TestHelperBridge {
  28
  29     // Two new helper classes for testing new APIs.
  30     public class ShouldInterceptLoadRequestHelper extends CallbackHelper {
  31         private List<String> mShouldInterceptRequestUrls = new ArrayList<String>();
  32         private ConcurrentHashMap<String, WebResourceResponse> mReturnValuesByUrls
  33             = new ConcurrentHashMap<String, WebResourceResponse>();
  34         // This is read from the IO thread, so needs to be marked volatile.
  35         private volatile WebResourceResponse mResourceResponseReturnValue = null;
  36         private String mUrlToWaitFor;
  37
  38         void setReturnValue(WebResourceResponse value) {
  39             mResourceResponseReturnValue = value;
  40         }
  41
  42         void setReturnValueForUrl(String url, WebResourceResponse value) {
  43             mReturnValuesByUrls.put(url, value);
  44         }
  45
  46         public void setUrlToWaitFor(String url) {
  47             mUrlToWaitFor = url;
  48         }
  49
  50         public List<String> getUrls() {
  51             assert getCallCount() > 0;
  52             return mShouldInterceptRequestUrls;
  53         }
  54
  55         public WebResourceResponse getReturnValue(String url) {
  56             WebResourceResponse value = mReturnValuesByUrls.get(url);
  57             if (value != null) return value;
  58             return mResourceResponseReturnValue;
  59         }
  60
  61         public void notifyCalled(String url) {
  62             if (mUrlToWaitFor == null || mUrlToWaitFor.equals(url)) {
  63                 mShouldInterceptRequestUrls.add(url);
  64                 notifyCalled();
  65             }
  66         }
  67     }
  68
  69     public class OnLoadStartedHelper extends CallbackHelper {
  70         private String mUrl;
  71
  72         public String getUrl() {
  73             assert getCallCount() > 0;
  74             return mUrl;
  75         }
  76
  77         public void notifyCalled(String url) {
  78             mUrl = url;
  79             notifyCalled();
  80         }
  81     }
  82
  83     public class OnProgressChangedHelper extends CallbackHelper {
  84         private int mProgress;
  85
  86         public int getProgress() {
  87             assert getCallCount() > 0;
  88             return mProgress;
  89         }
  90
  91         public void notifyCalled(int progress) {
  92             mProgress = progress;
  93             notifyCalled();
  94         }
  95     }
  96
  97     class OnEvaluateJavaScriptResultHelper extends CallbackHelper {
  98         private String mJsonResult;
  99         public void evaluateJavascript(XWalkView xWalkView, String code) {
 100             ValueCallback<String> callback =
 101                 new ValueCallback<String>() {
 102                     @Override
 103                     public void onReceiveValue(String jsonResult) {
 104                         notifyCalled(jsonResult);
 105                     }
 106                 };
 107             xWalkView.evaluateJavascript(code, callback);
 108             mJsonResult = null;
 109         }
 110
 111         public boolean hasValue() {
 112             return mJsonResult != null;
 113         }
 114
 115         public boolean waitUntilHasValue() throws InterruptedException, TimeoutException {
 116             waitUntilCriteria(getHasValueCriteria());
 117             return hasValue();
 118         }
 119
 120         public String getJsonResultAndClear() {
 121             assert hasValue();
 122             String result = mJsonResult;
 123             mJsonResult = null;
 124             return result;
 125         }
 126
 127         public Criteria getHasValueCriteria() {
 128             return new Criteria() {
 129                 @Override
 130                 public boolean isSatisfied() {
 131                     return hasValue();
 132                 }
 133             };
 134         }
 135
 136         public void notifyCalled(String jsonResult) {
 137             assert !hasValue();
 138             mJsonResult = jsonResult;
 139             notifyCalled();
 140         }
 141     }
 142
 143     public class OnJavascriptCloseWindowHelper extends CallbackHelper {
 144         private boolean mCalled = false;
 145
 146         public boolean getCalled() {
 147             assert getCallCount() > 0;
 148             return mCalled;
 149         }
 150
 151         public void notifyCalled(boolean called) {
 152             mCalled = called;
 153             notifyCalled();
 154         }
 155     }
 156
 157     public class ShouldOverrideUrlLoadingHelper extends CallbackHelper {
 158         private String mShouldOverrideUrlLoadingUrl;
 159         private String mPreviousShouldOverrideUrlLoadingUrl;
 160         private boolean mShouldOverrideUrlLoadingReturnValue = false;
 161
 162         void setShouldOverrideUrlLoadingUrl(String url) {
 163             mShouldOverrideUrlLoadingUrl = url;
 164         }
 165
 166         void setPreviousShouldOverrideUrlLoadingUrl(String url) {
 167             mPreviousShouldOverrideUrlLoadingUrl = url;
 168         }
 169
 170         void setShouldOverrideUrlLoadingReturnValue(boolean value) {
 171             mShouldOverrideUrlLoadingReturnValue = value;
 172         }
 173
 174         public String getShouldOverrideUrlLoadingUrl() {
 175             assert getCallCount() > 0;
 176             return mShouldOverrideUrlLoadingUrl;
 177         }
 178
 179         public String getPreviousShouldOverrideUrlLoadingUrl() {
 180             assert getCallCount() > 1;
 181             return mPreviousShouldOverrideUrlLoadingUrl;
 182         }
 183
 184         public boolean getShouldOverrideUrlLoadingReturnValue() {
 185             return mShouldOverrideUrlLoadingReturnValue;
 186         }
 187
 188         public void notifyCalled(String url) {
 189             mPreviousShouldOverrideUrlLoadingUrl = mShouldOverrideUrlLoadingUrl;
 190             mShouldOverrideUrlLoadingUrl = url;
 191             notifyCalled();
 192         }
 193     }
 194
 195     public class OnScaleChangedHelper extends CallbackHelper {
 196         private float mScale;
 197
 198         public float getScale() {
 199             assert getCallCount() > 0;
 200             return mScale;
 201         }
 202
 203         public void notifyCalled(float scale) {
 204             mScale = scale;
 205             notifyCalled();
 206         }
 207     }
 208
 209     private String mChangedTitle;
 210     private final OnPageStartedHelper mOnPageStartedHelper;
 211     private final OnPageFinishedHelper mOnPageFinishedHelper;
 212     private final OnReceivedErrorHelper mOnReceivedErrorHelper;
 213
 214     private final OnEvaluateJavaScriptResultHelper mOnEvaluateJavaScriptResultHelper;
 215
 216     private final OnTitleUpdatedHelper mOnTitleUpdatedHelper;
 217     private final ShouldInterceptLoadRequestHelper mShouldInterceptLoadRequestHelper;
 218     private final OnLoadStartedHelper mOnLoadStartedHelper;
 219     private final OnJavascriptCloseWindowHelper mOnJavascriptCloseWindowHelper;
 220     private final OnProgressChangedHelper mOnProgressChangedHelper;
 221     private final ShouldOverrideUrlLoadingHelper mShouldOverrideUrlLoadingHelper;
 222     private final OnScaleChangedHelper mOnScaleChangedHelper;
 223
 224     public TestHelperBridge() {
 225         mOnPageStartedHelper = new OnPageStartedHelper();
 226         mOnPageFinishedHelper = new OnPageFinishedHelper();
 227         mOnReceivedErrorHelper = new OnReceivedErrorHelper();
 228         mOnEvaluateJavaScriptResultHelper = new OnEvaluateJavaScriptResultHelper();
 229         mOnTitleUpdatedHelper = new OnTitleUpdatedHelper();
 230         mShouldInterceptLoadRequestHelper = new ShouldInterceptLoadRequestHelper();
 231         mOnLoadStartedHelper = new OnLoadStartedHelper();
 232         mOnJavascriptCloseWindowHelper = new OnJavascriptCloseWindowHelper();
 233         mOnProgressChangedHelper = new OnProgressChangedHelper();
 234         mShouldOverrideUrlLoadingHelper = new ShouldOverrideUrlLoadingHelper();
 235         mOnScaleChangedHelper = new OnScaleChangedHelper();
 236     }
 237
 238     public OnPageStartedHelper getOnPageStartedHelper() {
 239         return mOnPageStartedHelper;
 240     }
 241
 242     public OnPageFinishedHelper getOnPageFinishedHelper() {
 243         return mOnPageFinishedHelper;
 244     }
 245
 246     public OnReceivedErrorHelper getOnReceivedErrorHelper() {
 247         return mOnReceivedErrorHelper;
 248     }
 249
 250     public OnEvaluateJavaScriptResultHelper getOnEvaluateJavaScriptResultHelper() {
 251         return mOnEvaluateJavaScriptResultHelper;
 252     }
 253
 254     public OnTitleUpdatedHelper getOnTitleUpdatedHelper() {
 255         return mOnTitleUpdatedHelper;
 256     }
 257
 258     public ShouldInterceptLoadRequestHelper getShouldInterceptLoadRequestHelper() {
 259         return mShouldInterceptLoadRequestHelper;
 260     }
 261
 262     public OnLoadStartedHelper getOnLoadStartedHelper() {
 263         return mOnLoadStartedHelper;
 264     }
 265
 266     public OnJavascriptCloseWindowHelper getOnJavascriptCloseWindowHelper() {
 267         return mOnJavascriptCloseWindowHelper;
 268     }
 269
 270     public OnProgressChangedHelper getOnProgressChangedHelper() {
 271         return mOnProgressChangedHelper;
 272     }
 273
 274     public ShouldOverrideUrlLoadingHelper getShouldOverrideUrlLoadingHelper() {
 275         return mShouldOverrideUrlLoadingHelper;
 276     }
 277
 278     public OnScaleChangedHelper getOnScaleChangedHelper() {
 279         return mOnScaleChangedHelper;
 280     }
 281
 282     public void onTitleChanged(String title) {
 283         mChangedTitle = title;
 284         mOnTitleUpdatedHelper.notifyCalled(title);
 285     }
 286
 287     public String getChangedTitle() {
 288         return mChangedTitle;
 289     }
 290
 291     public void onPageStarted(String url) {
 292         mOnPageStartedHelper.notifyCalled(url);
 293     }
 294
 295     public void onPageFinished(String url) {
 296         mOnPageFinishedHelper.notifyCalled(url);
 297     }
 298
 299     public void onReceivedLoadError(int errorCode, String description, String failingUrl) {
 300         mOnReceivedErrorHelper.notifyCalled(errorCode, description, failingUrl);
 301     }
 302
 303     public WebResourceResponse shouldInterceptLoadRequest(String url) {
 304         WebResourceResponse response = mShouldInterceptLoadRequestHelper.getReturnValue(url);
 305         mShouldInterceptLoadRequestHelper.notifyCalled(url);
 306         return response;
 307     }
 308
 309     public void onLoadStarted(String url) {
 310         mOnLoadStartedHelper.notifyCalled(url);
 311     }
 312
 313     public void onJavascriptCloseWindow() {
 314         mOnJavascriptCloseWindowHelper.notifyCalled(true);
 315     }
 316
 317     public void onProgressChanged(int progress) {
 318         mOnProgressChangedHelper.notifyCalled(progress);
 319     }
 320
 321     public boolean shouldOverrideUrlLoading(String url) {
 322         boolean returnValue =
 323             mShouldOverrideUrlLoadingHelper.getShouldOverrideUrlLoadingReturnValue();
 324         mShouldOverrideUrlLoadingHelper.notifyCalled(url);
 325         return returnValue;
 326     }
 327
 328     public void onScaleChanged(float scale) {
 329         mOnScaleChangedHelper.notifyCalled(scale);
 330     }
 331 }