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.net.Uri;
   9 import android.util.Log;
  10 import android.view.KeyEvent;
  11 import android.webkit.ValueCallback;
  12 import android.webkit.WebResourceResponse;
  13
  14 import java.util.ArrayList;
  15 import java.util.List;
  16 import java.util.concurrent.Callable;
  17 import java.util.concurrent.ConcurrentHashMap;
  18 import java.util.concurrent.CountDownLatch;
  19 import java.util.concurrent.TimeoutException;
  20
  21 import org.chromium.content.browser.test.util.CallbackHelper;
  22 import org.chromium.content.browser.test.util.Criteria;
  23 import org.chromium.content.browser.test.util.TestCallbackHelperContainer.OnPageFinishedHelper;
  24 import org.chromium.content.browser.test.util.TestCallbackHelperContainer.OnPageStartedHelper;
  25 import org.chromium.content.browser.test.util.TestCallbackHelperContainer.OnReceivedErrorHelper;
  26
  27 import org.xwalk.core.XWalkUIClient.LoadStatus;
  28 import org.xwalk.core.XWalkView;
  29
  30 class TestHelperBridge {
  31
  32     // Two new helper classes for testing new APIs.
  33     public class ShouldInterceptLoadRequestHelper extends CallbackHelper {
  34         private List<String> mShouldInterceptRequestUrls = new ArrayList<String>();
  35         private ConcurrentHashMap<String, WebResourceResponse> mReturnValuesByUrls
  36             = new ConcurrentHashMap<String, WebResourceResponse>();
  37         // This is read from the IO thread, so needs to be marked volatile.
  38         private volatile WebResourceResponse mResourceResponseReturnValue = null;
  39         private String mUrlToWaitFor;
  40
  41         void setReturnValue(WebResourceResponse value) {
  42             mResourceResponseReturnValue = value;
  43         }
  44
  45         void setReturnValueForUrl(String url, WebResourceResponse value) {
  46             mReturnValuesByUrls.put(url, value);
  47         }
  48
  49         public void setUrlToWaitFor(String url) {
  50             mUrlToWaitFor = url;
  51         }
  52
  53         public List<String> getUrls() {
  54             assert getCallCount() > 0;
  55             return mShouldInterceptRequestUrls;
  56         }
  57
  58         public WebResourceResponse getReturnValue(String url) {
  59             WebResourceResponse value = mReturnValuesByUrls.get(url);
  60             if (value != null) return value;
  61             return mResourceResponseReturnValue;
  62         }
  63
  64         public void notifyCalled(String url) {
  65             if (mUrlToWaitFor == null || mUrlToWaitFor.equals(url)) {
  66                 mShouldInterceptRequestUrls.add(url);
  67                 notifyCalled();
  68             }
  69         }
  70     }
  71
  72     public class OnLoadStartedHelper extends CallbackHelper {
  73         private String mUrl;
  74
  75         public String getUrl() {
  76             assert getCallCount() > 0;
  77             return mUrl;
  78         }
  79
  80         public void notifyCalled(String url) {
  81             mUrl = url;
  82             notifyCalled();
  83         }
  84     }
  85
  86     public class OnProgressChangedHelper extends CallbackHelper {
  87         private int mProgress;
  88
  89         public int getProgress() {
  90             assert getCallCount() > 0;
  91             return mProgress;
  92         }
  93
  94         public void notifyCalled(int progress) {
  95             mProgress = progress;
  96             notifyCalled();
  97         }
  98     }
  99
 100     class OnEvaluateJavaScriptResultHelper extends CallbackHelper {
 101         private String mJsonResult;
 102         public void evaluateJavascript(XWalkView xWalkView, String code) {
 103             ValueCallback<String> callback =
 104                 new ValueCallback<String>() {
 105                     @Override
 106                     public void onReceiveValue(String jsonResult) {
 107                         notifyCalled(jsonResult);
 108                     }
 109                 };
 110             xWalkView.evaluateJavascript(code, callback);
 111             mJsonResult = null;
 112         }
 113
 114         public boolean hasValue() {
 115             return mJsonResult != null;
 116         }
 117
 118         public boolean waitUntilHasValue() throws InterruptedException, TimeoutException {
 119             waitUntilCriteria(getHasValueCriteria());
 120             return hasValue();
 121         }
 122
 123         public String getJsonResultAndClear() {
 124             assert hasValue();
 125             String result = mJsonResult;
 126             mJsonResult = null;
 127             return result;
 128         }
 129
 130         public Criteria getHasValueCriteria() {
 131             return new Criteria() {
 132                 @Override
 133                 public boolean isSatisfied() {
 134                     return hasValue();
 135                 }
 136             };
 137         }
 138
 139         public void notifyCalled(String jsonResult) {
 140             assert !hasValue();
 141             mJsonResult = jsonResult;
 142             notifyCalled();
 143         }
 144     }
 145
 146     public class OnJavascriptCloseWindowHelper extends CallbackHelper {
 147         private boolean mCalled = false;
 148
 149         public boolean getCalled() {
 150             assert getCallCount() > 0;
 151             return mCalled;
 152         }
 153
 154         public void notifyCalled(boolean called) {
 155             mCalled = called;
 156             notifyCalled();
 157         }
 158     }
 159
 160     public class ShouldOverrideUrlLoadingHelper extends CallbackHelper {
 161         private String mShouldOverrideUrlLoadingUrl;
 162         private String mPreviousShouldOverrideUrlLoadingUrl;
 163         private boolean mShouldOverrideUrlLoadingReturnValue = false;
 164
 165         void setShouldOverrideUrlLoadingUrl(String url) {
 166             mShouldOverrideUrlLoadingUrl = url;
 167         }
 168
 169         void setPreviousShouldOverrideUrlLoadingUrl(String url) {
 170             mPreviousShouldOverrideUrlLoadingUrl = url;
 171         }
 172
 173         void setShouldOverrideUrlLoadingReturnValue(boolean value) {
 174             mShouldOverrideUrlLoadingReturnValue = value;
 175         }
 176
 177         public String getShouldOverrideUrlLoadingUrl() {
 178             assert getCallCount() > 0;
 179             return mShouldOverrideUrlLoadingUrl;
 180         }
 181
 182         public String getPreviousShouldOverrideUrlLoadingUrl() {
 183             assert getCallCount() > 1;
 184             return mPreviousShouldOverrideUrlLoadingUrl;
 185         }
 186
 187         public boolean getShouldOverrideUrlLoadingReturnValue() {
 188             return mShouldOverrideUrlLoadingReturnValue;
 189         }
 190
 191         public void notifyCalled(String url) {
 192             mPreviousShouldOverrideUrlLoadingUrl = mShouldOverrideUrlLoadingUrl;
 193             mShouldOverrideUrlLoadingUrl = url;
 194             notifyCalled();
 195         }
 196     }
 197
 198     public class OnScaleChangedHelper extends CallbackHelper {
 199         private float mScale;
 200
 201         public float getScale() {
 202             assert getCallCount() > 0;
 203             return mScale;
 204         }
 205
 206         public void notifyCalled(float scale) {
 207             mScale = scale;
 208             notifyCalled();
 209         }
 210     }
 211
 212     public class OnRequestFocusHelper extends CallbackHelper {
 213         private boolean mCalled = false;
 214
 215         public boolean getCalled() {
 216             assert getCallCount() > 0;
 217             return mCalled;
 218         }
 219
 220         public void notifyCalled(boolean called) {
 221             mCalled = called;
 222             notifyCalled();
 223         }
 224     }
 225
 226     public class OnJavascriptModalDialogHelper extends CallbackHelper {
 227         private String mMessage;
 228
 229         public String getMessage() {
 230             assert getCallCount() > 0;
 231             return mMessage;
 232         }
 233
 234         public void notifyCalled(String message) {
 235             mMessage = message;
 236             notifyCalled();
 237         }
 238     }
 239
 240     public class OpenFileChooserHelper extends CallbackHelper {
 241         private ValueCallback<Uri> mCallback;
 242
 243         public ValueCallback<Uri> getCallback() {
 244             assert getCallCount() > 0;
 245             return mCallback;
 246         }
 247
 248         public void notifyCalled(ValueCallback<Uri> callback) {
 249             mCallback = callback;
 250             notifyCalled();
 251         }
 252     }
 253
 254     public class OnFullscreenToggledHelper extends CallbackHelper {
 255         private boolean mEnterFullscreen = false;
 256
 257         public boolean getEnterFullscreen() {
 258             assert getCallCount() > 0;
 259             return mEnterFullscreen;
 260         }
 261
 262         public void notifyCalled(boolean enterFullscreen) {
 263             mEnterFullscreen = enterFullscreen;
 264             notifyCalled();
 265         }
 266     }
 267
 268     public class OverrideOrUnhandledKeyEventHelper extends CallbackHelper {
 269         private KeyEvent mEvent;
 270
 271         public KeyEvent getKeyEvent() {
 272             assert getCallCount() > 0;
 273             return mEvent;
 274         }
 275
 276         public void notifyCalled(KeyEvent event) {
 277             mEvent = event;
 278             notifyCalled();
 279         }
 280     }
 281
 282     private String mChangedTitle;
 283     private LoadStatus mLoadStatus;
 284     private final OnPageStartedHelper mOnPageStartedHelper;
 285     private final OnPageFinishedHelper mOnPageFinishedHelper;
 286     private final OnReceivedErrorHelper mOnReceivedErrorHelper;
 287
 288     private final OnEvaluateJavaScriptResultHelper mOnEvaluateJavaScriptResultHelper;
 289
 290     private final OnTitleUpdatedHelper mOnTitleUpdatedHelper;
 291     private final ShouldInterceptLoadRequestHelper mShouldInterceptLoadRequestHelper;
 292     private final OnLoadStartedHelper mOnLoadStartedHelper;
 293     private final OnJavascriptCloseWindowHelper mOnJavascriptCloseWindowHelper;
 294     private final OnProgressChangedHelper mOnProgressChangedHelper;
 295     private final ShouldOverrideUrlLoadingHelper mShouldOverrideUrlLoadingHelper;
 296     private final OnScaleChangedHelper mOnScaleChangedHelper;
 297     private final OnRequestFocusHelper mOnRequestFocusHelper;
 298     private final OnJavascriptModalDialogHelper mOnJavascriptModalDialogHelper;
 299     private final OpenFileChooserHelper mOpenFileChooserHelper;
 300     private final OnFullscreenToggledHelper mOnFullscreenToggledHelper;
 301     private final OverrideOrUnhandledKeyEventHelper mOverrideOrUnhandledKeyEventHelper;
 302
 303     public TestHelperBridge() {
 304         mOnPageStartedHelper = new OnPageStartedHelper();
 305         mOnPageFinishedHelper = new OnPageFinishedHelper();
 306         mOnReceivedErrorHelper = new OnReceivedErrorHelper();
 307         mOnEvaluateJavaScriptResultHelper = new OnEvaluateJavaScriptResultHelper();
 308         mOnTitleUpdatedHelper = new OnTitleUpdatedHelper();
 309         mShouldInterceptLoadRequestHelper = new ShouldInterceptLoadRequestHelper();
 310         mOnLoadStartedHelper = new OnLoadStartedHelper();
 311         mOnJavascriptCloseWindowHelper = new OnJavascriptCloseWindowHelper();
 312         mOnProgressChangedHelper = new OnProgressChangedHelper();
 313         mShouldOverrideUrlLoadingHelper = new ShouldOverrideUrlLoadingHelper();
 314         mOnScaleChangedHelper = new OnScaleChangedHelper();
 315         mOnRequestFocusHelper = new OnRequestFocusHelper();
 316         mOnJavascriptModalDialogHelper = new OnJavascriptModalDialogHelper();
 317         mOpenFileChooserHelper = new OpenFileChooserHelper();
 318         mOnFullscreenToggledHelper = new OnFullscreenToggledHelper();
 319         mOverrideOrUnhandledKeyEventHelper = new OverrideOrUnhandledKeyEventHelper();
 320     }
 321
 322     public OnPageStartedHelper getOnPageStartedHelper() {
 323         return mOnPageStartedHelper;
 324     }
 325
 326     public OnPageFinishedHelper getOnPageFinishedHelper() {
 327         return mOnPageFinishedHelper;
 328     }
 329
 330     public OnReceivedErrorHelper getOnReceivedErrorHelper() {
 331         return mOnReceivedErrorHelper;
 332     }
 333
 334     public OnEvaluateJavaScriptResultHelper getOnEvaluateJavaScriptResultHelper() {
 335         return mOnEvaluateJavaScriptResultHelper;
 336     }
 337
 338     public OnTitleUpdatedHelper getOnTitleUpdatedHelper() {
 339         return mOnTitleUpdatedHelper;
 340     }
 341
 342     public ShouldInterceptLoadRequestHelper getShouldInterceptLoadRequestHelper() {
 343         return mShouldInterceptLoadRequestHelper;
 344     }
 345
 346     public OnLoadStartedHelper getOnLoadStartedHelper() {
 347         return mOnLoadStartedHelper;
 348     }
 349
 350     public OnJavascriptCloseWindowHelper getOnJavascriptCloseWindowHelper() {
 351         return mOnJavascriptCloseWindowHelper;
 352     }
 353
 354     public OnProgressChangedHelper getOnProgressChangedHelper() {
 355         return mOnProgressChangedHelper;
 356     }
 357
 358     public ShouldOverrideUrlLoadingHelper getShouldOverrideUrlLoadingHelper() {
 359         return mShouldOverrideUrlLoadingHelper;
 360     }
 361
 362     public OnScaleChangedHelper getOnScaleChangedHelper() {
 363         return mOnScaleChangedHelper;
 364     }
 365
 366     public OnRequestFocusHelper getOnRequestFocusHelper() {
 367         return mOnRequestFocusHelper;
 368     }
 369
 370     public OnJavascriptModalDialogHelper getOnJavascriptModalDialogHelper() {
 371         return mOnJavascriptModalDialogHelper;
 372     }
 373
 374     public OpenFileChooserHelper getOpenFileChooserHelper() {
 375         return mOpenFileChooserHelper;
 376     }
 377
 378     public OnFullscreenToggledHelper getOnFullscreenToggledHelper() {
 379         return mOnFullscreenToggledHelper;
 380     }
 381
 382     public OverrideOrUnhandledKeyEventHelper getOverrideOrUnhandledKeyEventHelper() {
 383         return mOverrideOrUnhandledKeyEventHelper;
 384     }
 385
 386     public void onTitleChanged(String title) {
 387         mChangedTitle = title;
 388         mOnTitleUpdatedHelper.notifyCalled(title);
 389     }
 390
 391     public String getChangedTitle() {
 392         return mChangedTitle;
 393     }
 394
 395     public void onPageStarted(String url) {
 396         mOnPageStartedHelper.notifyCalled(url);
 397     }
 398
 399     public void onPageFinished(String url, LoadStatus status) {
 400         mLoadStatus = status;
 401         mOnPageFinishedHelper.notifyCalled(url);
 402     }
 403
 404     public LoadStatus getLoadStatus() {
 405         return mLoadStatus;
 406     }
 407
 408     public void onReceivedLoadError(int errorCode, String description, String failingUrl) {
 409         mOnReceivedErrorHelper.notifyCalled(errorCode, description, failingUrl);
 410     }
 411
 412     public WebResourceResponse shouldInterceptLoadRequest(String url) {
 413         WebResourceResponse response = mShouldInterceptLoadRequestHelper.getReturnValue(url);
 414         mShouldInterceptLoadRequestHelper.notifyCalled(url);
 415         return response;
 416     }
 417
 418     public void onLoadStarted(String url) {
 419         mOnLoadStartedHelper.notifyCalled(url);
 420     }
 421
 422     public void onJavascriptCloseWindow() {
 423         mOnJavascriptCloseWindowHelper.notifyCalled(true);
 424     }
 425
 426     public void onProgressChanged(int progress) {
 427         mOnProgressChangedHelper.notifyCalled(progress);
 428     }
 429
 430     public boolean shouldOverrideUrlLoading(String url) {
 431         boolean returnValue =
 432             mShouldOverrideUrlLoadingHelper.getShouldOverrideUrlLoadingReturnValue();
 433         mShouldOverrideUrlLoadingHelper.notifyCalled(url);
 434         return returnValue;
 435     }
 436
 437     public void onScaleChanged(float scale) {
 438         mOnScaleChangedHelper.notifyCalled(scale);
 439     }
 440
 441     public void onRequestFocus() {
 442         mOnRequestFocusHelper.notifyCalled(true);
 443     }
 444
 445     public boolean onJavascriptModalDialog(String message) {
 446         mOnJavascriptModalDialogHelper.notifyCalled(message);
 447         return true;
 448     }
 449
 450     public void openFileChooser(ValueCallback<Uri> uploadFile) {
 451         mOpenFileChooserHelper.notifyCalled(uploadFile);
 452     }
 453
 454     public void onFullscreenToggled(boolean enterFullscreen) {
 455         mOnFullscreenToggledHelper.notifyCalled(enterFullscreen);
 456     }
 457
 458     public boolean overrideOrUnhandledKeyEvent(KeyEvent event) {
 459         mOverrideOrUnhandledKeyEventHelper.notifyCalled(event);
 460         return true;
 461     }
 462 }