// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Copyright (c) 2013 Intel Corporation. All rights reserved.
+// Copyright (c) 2013-2014 Intel Corporation. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import android.app.Activity;
import android.content.Context;
+import android.net.Uri;
import android.test.ActivityInstrumentationTestCase2;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.webkit.ValueCallback;
+import android.webkit.WebResourceResponse;
import java.io.InputStream;
import java.io.IOException;
import junit.framework.Assert;
-import org.chromium.content.browser.LoadUrlParams;
+import org.chromium.content_public.browser.LoadUrlParams;
import org.chromium.content.browser.test.util.CallbackHelper;
import org.chromium.content.browser.test.util.Criteria;
import org.chromium.content.browser.test.util.CriteriaHelper;
-import org.chromium.content.browser.test.util.TestCallbackHelperContainer.OnEvaluateJavaScriptResultHelper;
-import org.xwalk.core.XWalkClient;
-import org.xwalk.core.XWalkContent;
-import org.xwalk.core.XWalkContentsClient;
-import org.xwalk.core.XWalkSettings;
+
+import org.xwalk.core.XWalkJavascriptResult;
+import org.xwalk.core.XWalkNavigationHistory;
+import org.xwalk.core.XWalkNavigationItem;
+import org.xwalk.core.XWalkResourceClient;
+import org.xwalk.core.XWalkUIClient;
import org.xwalk.core.XWalkView;
-import org.xwalk.core.XWalkWebChromeClient;
public class XWalkViewTestBase
extends ActivityInstrumentationTestCase2<XWalkViewTestRunnerActivity> {
protected final static int WAIT_TIMEOUT_SECONDS = 15;
+ protected final static long WAIT_TIMEOUT_MS = 2000;
+ private final static int CHECK_INTERVAL = 100;
+ private final static String TAG = "XWalkViewTestBase";
private XWalkView mXWalkView;
- final TestXWalkViewContentsClient mTestContentsClient = new TestXWalkViewContentsClient();
-
- static class ViewPair {
- private final XWalkContent content0;
- private final TestXWalkViewContentsClient client0;
- private final XWalkContent content1;
- private final TestXWalkViewContentsClient client1;
-
- ViewPair(XWalkContent content0, TestXWalkViewContentsClient client0,
- XWalkContent content1, TestXWalkViewContentsClient client1) {
- this.content0 = content0;
- this.client0 = client0;
- this.content1 = content1;
- this.client1 = client1;
+ final TestHelperBridge mTestHelperBridge = new TestHelperBridge();
+
+ class TestXWalkUIClientBase extends XWalkUIClient {
+ TestHelperBridge mInnerContentsClient;
+ public TestXWalkUIClientBase(TestHelperBridge client) {
+ super(getXWalkView());
+ mInnerContentsClient = client;
+ }
+
+ @Override
+ public void onPageLoadStarted(XWalkView view, String url) {
+ mInnerContentsClient.onPageStarted(url);
+ }
+
+ @Override
+ public void onPageLoadStopped(XWalkView view, String url, LoadStatus status) {
+ mInnerContentsClient.onPageFinished(url, status);
+ }
+
+ @Override
+ public void onReceivedTitle(XWalkView view, String title) {
+ mInnerContentsClient.onTitleChanged(title);
+ }
+
+ @Override
+ public void onJavascriptCloseWindow(XWalkView view) {
+ mInnerContentsClient.onJavascriptCloseWindow();
+ }
+
+ @Override
+ public void onScaleChanged(XWalkView view, float oldScale, float newScale) {
+ mInnerContentsClient.onScaleChanged(newScale);
+ }
+
+ @Override
+ public void onRequestFocus(XWalkView view) {
+ mInnerContentsClient.onRequestFocus();
+ }
+
+ @Override
+ public boolean onJavascriptModalDialog(XWalkView view,
+ XWalkUIClient.JavascriptMessageType type, String url, String message,
+ String defaultValue, XWalkJavascriptResult result) {
+ return mInnerContentsClient.onJavascriptModalDialog(message);
+ }
+
+ @Override
+ public void openFileChooser(XWalkView view, ValueCallback<Uri> uploadFile,
+ String acceptType, String capture) {
+ mInnerContentsClient.openFileChooser(uploadFile);
+ }
+
+ @Override
+ public void onFullscreenToggled(XWalkView view, boolean enterFullscreen) {
+ mInnerContentsClient.onFullscreenToggled(enterFullscreen);
+ }
+
+ @Override
+ public boolean shouldOverrideKeyEvent(XWalkView view, KeyEvent event) {
+ return mInnerContentsClient.overrideOrUnhandledKeyEvent(event);
+ }
+ }
+
+ class TestXWalkUIClient extends TestXWalkUIClientBase {
+ public TestXWalkUIClient() {
+ super(mTestHelperBridge);
}
+ }
- XWalkContent getContent0() {
- return content0;
+ class TestXWalkResourceClientBase extends XWalkResourceClient {
+ TestHelperBridge mInnerContentsClient;
+ public TestXWalkResourceClientBase(TestHelperBridge client) {
+ super(mXWalkView);
+ mInnerContentsClient = client;
}
- TestXWalkViewContentsClient getClient0() {
- return client0;
+ @Override
+ public void onLoadStarted(XWalkView view, String url) {
+ mInnerContentsClient.onLoadStarted(url);
}
- XWalkContent getContent1() {
- return content1;
+ @Override
+ public void onReceivedLoadError(XWalkView view, int errorCode, String description, String failingUrl) {
+ mInnerContentsClient.onReceivedLoadError(errorCode, description, failingUrl);
}
- TestXWalkViewContentsClient getClient1() {
- return client1;
+ @Override
+ public WebResourceResponse shouldInterceptLoadRequest(XWalkView view,
+ String url) {
+ return mInnerContentsClient.shouldInterceptLoadRequest(url);
+ }
+
+ @Override
+ public void onProgressChanged(XWalkView view, int progressInPercent) {
+ mTestHelperBridge.onProgressChanged(progressInPercent);
+ }
+
+ @Override
+ public boolean shouldOverrideUrlLoading(XWalkView view, String url) {
+ return mTestHelperBridge.shouldOverrideUrlLoading(url);
}
}
+ class TestXWalkResourceClient extends TestXWalkResourceClientBase {
+ public TestXWalkResourceClient() {
+ super(mTestHelperBridge);
+ }
+ }
+
+ void setUIClient(final XWalkUIClient client) {
+ getInstrumentation().runOnMainSync(new Runnable() {
+ @Override
+ public void run() {
+ getXWalkView().setUIClient(client);
+ }
+ });
+ }
+
+ void setResourceClient(final XWalkResourceClient client) {
+ getInstrumentation().runOnMainSync(new Runnable() {
+ @Override
+ public void run() {
+ getXWalkView().setResourceClient(client);
+ }
+ });
+ }
+
public XWalkViewTestBase() {
super(XWalkViewTestRunnerActivity.class);
}
public void run() {
mXWalkView = new XWalkView(activity, activity);
getActivity().addView(mXWalkView);
- mXWalkView.getXWalkViewContentForTest().installWebContentsObserverForTest(mTestContentsClient);
+ mXWalkView.setUIClient(new TestXWalkUIClient());
+ mXWalkView.setResourceClient(new TestXWalkResourceClient());
+ // mXWalkView.getXWalkViewContentForTest().installWebContentsObserverForTest(mTestHelperBridge);
}
});
}
});
}
+ protected void loadJavaScriptUrl(final String url) throws Exception {
+ if (!url.startsWith("javascript:")) {
+ Log.w(TAG, "loadJavascriptUrl only accepts javascript: url");
+ return;
+ }
+ loadUrlAsync(url);
+ }
+
protected void loadUrlSync(final String url) throws Exception {
- CallbackHelper pageFinishedHelper = mTestContentsClient.getOnPageFinishedHelper();
+ CallbackHelper pageFinishedHelper = mTestHelperBridge.getOnPageFinishedHelper();
int currentCallCount = pageFinishedHelper.getCallCount();
loadUrlAsync(url);
getInstrumentation().runOnMainSync(new Runnable() {
@Override
public void run() {
- mXWalkView.loadUrl(url);
+ mXWalkView.load(url, null);
}
});
}
- protected void loadDataSync(final String data, final String mimeType,
+ protected void loadDataSync(final String url, final String data, final String mimeType,
final boolean isBase64Encoded) throws Exception {
- CallbackHelper pageFinishedHelper = mTestContentsClient.getOnPageFinishedHelper();
+ CallbackHelper pageFinishedHelper = mTestHelperBridge.getOnPageFinishedHelper();
int currentCallCount = pageFinishedHelper.getCallCount();
- loadDataAsync(data, mimeType, isBase64Encoded);
+ loadDataAsync(url, data, mimeType, isBase64Encoded);
pageFinishedHelper.waitForCallback(currentCallCount, 1, WAIT_TIMEOUT_SECONDS,
TimeUnit.SECONDS);
}
- protected void loadDataAsync(final String data, final String mimeType,
+ protected void loadDataAsync(final String url, final String data, final String mimeType,
final boolean isBase64Encoded) throws Exception {
getInstrumentation().runOnMainSync(new Runnable() {
@Override
public void run() {
- mXWalkView.getXWalkViewContentForTest().getContentViewCoreForTest(
- ).loadUrl(LoadUrlParams.createLoadDataParams(
- data, mimeType, isBase64Encoded));
+ mXWalkView.load(url, data);
}
});
}
- protected void loadUrlSyncByContent(final XWalkContent xWalkContent,
- final TestXWalkViewContentsClient contentsClient,
+ protected void loadUrlSyncByContent(final XWalkView xWalkContent,
+ final TestHelperBridge contentsClient,
final String url) throws Exception {
CallbackHelper pageFinishedHelper = contentsClient.getOnPageFinishedHelper();
int currentCallCount = pageFinishedHelper.getCallCount();
TimeUnit.SECONDS);
}
- protected void loadUrlAsyncByContent(final XWalkContent xWalkContent,
+ protected void loadUrlAsyncByContent(final XWalkView xWalkContent,
final String url) throws Exception {
getInstrumentation().runOnMainSync(new Runnable() {
@Override
public void run() {
- xWalkContent.loadUrl(url);
+ xWalkContent.load(url, null);
}
});
}
}
}
- protected String getTitleOnUiThreadByContent(final XWalkContent xWalkContent) throws Exception {
+ protected String getTitleOnUiThreadByContent(final XWalkView xWalkContent) throws Exception {
return runTestOnUiThreadAndGetResult(new Callable<String>() {
@Override
public String call() throws Exception {
- String title = xWalkContent.getContentViewCoreForTest().getTitle();
+ String title = xWalkContent.getTitle();
return title;
}
});
}
- protected XWalkSettings getXWalkSettingsOnUiThreadByContent(
- final XWalkContent xwalkContent) throws Exception {
- return runTestOnUiThreadAndGetResult(new Callable<XWalkSettings>() {
- @Override
- public XWalkSettings call() throws Exception {
- return xwalkContent.getSettings();
- }
- });
- }
-
protected XWalkView createXWalkViewContainerOnMainSync(
final Context context,
- final XWalkContentsClient contentClient,
- final XWalkClient xWalkClient,
- final XWalkWebChromeClient xWlkWebChromeClient) throws Exception {
+ final XWalkUIClient uiClient,
+ final XWalkResourceClient resourceClient) throws Exception {
final AtomicReference<XWalkView> xWalkViewContainer =
new AtomicReference<XWalkView>();
getInstrumentation().runOnMainSync(new Runnable() {
public void run() {
xWalkViewContainer.set(new XWalkView(context, getActivity()));
getActivity().addView(xWalkViewContainer.get());
- xWalkViewContainer.get().getXWalkViewContentForTest().installWebContentsObserverForTest(contentClient);
- xWalkViewContainer.get().setXWalkClient(xWalkClient);
- xWalkViewContainer.get().setXWalkWebChromeClient(xWlkWebChromeClient);
+ xWalkViewContainer.get().setUIClient(uiClient);
+ xWalkViewContainer.get().setResourceClient(resourceClient);
}
});
return xWalkViewContainer.get();
}
- protected XWalkContent getXWalkContentOnMainSync(final XWalkView view) throws Exception {
- final AtomicReference<XWalkContent> xWalkContent =
- new AtomicReference<XWalkContent>();
- getInstrumentation().runOnMainSync(new Runnable() {
- @Override
- public void run() {
- xWalkContent.set(view.getXWalkViewContentForTest());
- }
- });
-
- return xWalkContent.get();
- }
-
- protected ViewPair createViewsOnMainSync(final TestXWalkViewContentsClient contentClient0,
- final TestXWalkViewContentsClient contentClient1, final XWalkClient viewClient0,
- final XWalkClient viewClient1, final XWalkWebChromeClient chromeClient0,
- final XWalkWebChromeClient chromeClient1, final Context context) throws Throwable {
- final XWalkView walkView0 = createXWalkViewContainerOnMainSync(context, contentClient0,
- viewClient0, chromeClient0);
- final XWalkView walkView1 = createXWalkViewContainerOnMainSync(context, contentClient1,
- viewClient1, chromeClient1);
- final AtomicReference<ViewPair> viewPair = new AtomicReference<ViewPair>();
-
- getInstrumentation().runOnMainSync(new Runnable() {
- @Override
- public void run() {
- XWalkContent content0 = walkView0.getXWalkViewContentForTest();
- XWalkContent content1 = walkView1.getXWalkViewContentForTest();
- viewPair.set(new ViewPair(content0, contentClient0, content1, contentClient1));
- }
- });
-
- return viewPair.get();
- }
-
protected void loadAssetFile(String fileName) throws Exception {
String fileContent = getFileContent(fileName);
- loadDataSync(fileContent, "text/html", false);
+ loadDataSync(fileName, fileContent, "text/html", false);
}
public void loadAssetFileAndWaitForTitle(String fileName) throws Exception {
- CallbackHelper getTitleHelper = mTestContentsClient.getOnTitleUpdatedHelper();
+ CallbackHelper getTitleHelper = mTestHelperBridge.getOnTitleUpdatedHelper();
int currentCallCount = getTitleHelper.getCallCount();
String fileContent = getFileContent(fileName);
- loadDataSync(fileContent, "text/html", false);
+ loadDataSync(fileName, fileContent, "text/html", false);
getTitleHelper.waitForCallback(currentCallCount, 1, WAIT_TIMEOUT_SECONDS,
TimeUnit.SECONDS);
}
protected void runTestWaitPageFinished(Runnable runnable) throws Exception{
- CallbackHelper pageFinishedHelper = mTestContentsClient.getOnPageFinishedHelper();
+ CallbackHelper pageFinishedHelper = mTestHelperBridge.getOnPageFinishedHelper();
int currentCallCount = pageFinishedHelper.getCallCount();
runnable.run();
pageFinishedHelper.waitForCallback(currentCallCount, 1, WAIT_TIMEOUT_SECONDS,
TimeUnit.SECONDS);
}
- protected void reloadSync() throws Exception {
+ protected void reloadSync(final int mode) throws Exception {
runTestWaitPageFinished(new Runnable(){
@Override
public void run() {
getInstrumentation().runOnMainSync(new Runnable() {
@Override
public void run() {
- mXWalkView.reload();
+ mXWalkView.reload(mode);
}
});
}
getInstrumentation().runOnMainSync(new Runnable() {
@Override
public void run() {
- mXWalkView.goBack();
+ mXWalkView.getNavigationHistory().navigate(
+ XWalkNavigationHistory.Direction.BACKWARD, 1);
}
});
}
getInstrumentation().runOnMainSync(new Runnable() {
@Override
public void run() {
- mXWalkView.goForward();
+ mXWalkView.getNavigationHistory().navigate(
+ XWalkNavigationHistory.Direction.FORWARD, 1);
}
});
}
getInstrumentation().runOnMainSync(new Runnable() {
@Override
public void run() {
- mXWalkView.clearHistory();
+ mXWalkView.getNavigationHistory().clear();
}
});
}
return runTestOnUiThreadAndGetResult(new Callable<Boolean>() {
@Override
public Boolean call() {
- return mXWalkView.canGoBack();
+ return mXWalkView.getNavigationHistory().canGoBack();
}
});
}
return runTestOnUiThreadAndGetResult(new Callable<Boolean>() {
@Override
public Boolean call() {
- return mXWalkView.canGoForward();
+ return mXWalkView.getNavigationHistory().canGoForward();
+ }
+ });
+ }
+
+ protected int historySizeOnUiThread() throws Throwable {
+ return runTestOnUiThreadAndGetResult(new Callable<Integer>() {
+ @Override
+ public Integer call() {
+ return mXWalkView.getNavigationHistory().size();
+ }
+ });
+ }
+
+ protected boolean hasItemAtOnUiThread(final int index) throws Throwable {
+ return runTestOnUiThreadAndGetResult(new Callable<Boolean>() {
+ @Override
+ public Boolean call() {
+ return mXWalkView.getNavigationHistory().hasItemAt(index);
+ }
+ });
+ }
+
+ protected XWalkNavigationItem getItemAtOnUiThread(final int index) throws Throwable {
+ return runTestOnUiThreadAndGetResult(new Callable<XWalkNavigationItem>() {
+ @Override
+ public XWalkNavigationItem call() {
+ return mXWalkView.getNavigationHistory().getItemAt(index);
+ }
+ });
+ }
+
+ protected XWalkNavigationItem getCurrentItemOnUiThread() throws Throwable {
+ return runTestOnUiThreadAndGetResult(new Callable<XWalkNavigationItem>() {
+ @Override
+ public XWalkNavigationItem call() {
+ return mXWalkView.getNavigationHistory().getCurrentItem();
}
});
}
protected String executeJavaScriptAndWaitForResult(final String code) throws Exception {
- final OnEvaluateJavaScriptResultHelper helper = mTestContentsClient.getOnEvaluateJavaScriptResultHelper();
+
+ final TestHelperBridge.OnEvaluateJavaScriptResultHelper helper =
+ mTestHelperBridge.getOnEvaluateJavaScriptResultHelper();
getInstrumentation().runOnMainSync(new Runnable() {
@Override
public void run() {
- XWalkContent content = mXWalkView.getXWalkViewContentForTest();
- helper.evaluateJavaScript(content.getContentViewCoreForTest(), code);
+ helper.evaluateJavascript(mXWalkView, code);
}
});
helper.waitUntilHasValue();
Assert.assertTrue("Failed to retrieve JavaScript evaluation results.", helper.hasValue());
return helper.getJsonResultAndClear();
}
+
+ protected String getUrlOnUiThread() throws Exception {
+ return runTestOnUiThreadAndGetResult(new Callable<String>() {
+ @Override
+ public String call() throws Exception {
+ return mXWalkView.getUrl();
+ }
+ });
+ }
+
+ protected void clearCacheOnUiThread(final boolean includeDiskFiles) throws Exception {
+ getInstrumentation().runOnMainSync(new Runnable() {
+ @Override
+ public void run() {
+ mXWalkView.clearCache(includeDiskFiles);
+ }
+ });
+ }
+
+ protected String getAPIVersionOnUiThread() throws Exception {
+ return runTestOnUiThreadAndGetResult(new Callable<String>() {
+ @Override
+ public String call() throws Exception {
+ return mXWalkView.getAPIVersion();
+ }
+ });
+ }
+
+ protected String getXWalkVersionOnUiThread() throws Exception {
+ return runTestOnUiThreadAndGetResult(new Callable<String>() {
+ @Override
+ public String call() throws Exception {
+ return mXWalkView.getXWalkVersion();
+ }
+ });
+ }
+
+ public void clickOnElementId(final String id, String frameName) throws Exception {
+ String str;
+ if (frameName != null) {
+ str = "top.window." + "LeftFrame" + ".document.getElementById('" + id + "')";
+ } else {
+ str = "document.getElementById('" + id + "')";
+ }
+ final String script1 = str + " != null";
+ final String script2 = str + ".dispatchEvent(evObj);";
+ Assert.assertTrue(CriteriaHelper.pollForCriteria(new Criteria() {
+ @Override
+ public boolean isSatisfied() {
+ try {
+ String idIsNotNull = executeJavaScriptAndWaitForResult(script1);
+ return idIsNotNull.equals("true");
+ } catch (Throwable t) {
+ t.printStackTrace();
+ Assert.fail("Failed to check if DOM is loaded: " + t.toString());
+ return false;
+ }
+ }
+ }, WAIT_TIMEOUT_MS, CHECK_INTERVAL));
+
+ try {
+ String result = executeJavaScriptAndWaitForResult(
+ "var evObj = document.createEvent('Events'); " +
+ "evObj.initEvent('click', true, false); " +
+ script2 +
+ "console.log('element with id [" + id + "] clicked');");
+ } catch (Throwable t) {
+ t.printStackTrace();
+ }
+ }
+
+ public void simulateKeyAction(final int action) {
+ new Thread(new Runnable() {
+ public void run() {
+ try {
+ getInstrumentation().sendKeySync(new KeyEvent(action,
+ KeyEvent.KEYCODE_DPAD_CENTER));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }).start();
+ }
+
+ protected void stopLoading() throws Exception {
+ getInstrumentation().runOnMainSync(new Runnable() {
+ @Override
+ public void run() {
+ mXWalkView.stopLoading();
+ }
+ });
+ }
}
projects / platform / framework / web / crosswalk.git / blobdiff