/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.dumprendertree2;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.net.http.SslError;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.os.Process;
import android.os.RemoteException;
import android.util.Log;
import android.view.Window;
import android.webkit.ConsoleMessage;
import android.webkit.GeolocationPermissions;
import android.webkit.HttpAuthHandler;
import android.webkit.JsPromptResult;
import android.webkit.JsResult;
import android.webkit.SslErrorHandler;
import android.webkit.WebChromeClient;
import android.webkit.WebSettings;
import android.webkit.WebStorage;
import android.webkit.WebStorage.QuotaUpdater;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* This activity executes the test. It contains WebView and logic of LayoutTestController
* functions. It runs in a separate process and sends the results of running the test
* to ManagerService. The reason why is to handle crashing (test that crashes brings down
* whole process with it).
*/
public class LayoutTestsExecutor extends Activity {
private enum CurrentState {
IDLE,
RENDERING_PAGE,
WAITING_FOR_ASYNCHRONOUS_TEST,
OBTAINING_RESULT;
public boolean isRunningState() {
return this == CurrentState.RENDERING_PAGE ||
this == CurrentState.WAITING_FOR_ASYNCHRONOUS_TEST;
}
}
private static final String LOG_TAG = "LayoutTestsExecutor";
public static final String EXTRA_TESTS_FILE = "TestsList";
public static final String EXTRA_TEST_INDEX = "TestIndex";
private static final int MSG_ACTUAL_RESULT_OBTAINED = 0;
private static final int MSG_TEST_TIMED_OUT = 1;
private static final int DEFAULT_TIME_OUT_MS = 15 * 1000;
/** A list of tests that remain to run since last crash */
private List<String> mTestsList;
/**
* This is a number of currently running test. It is 0-based and doesn't reset after
* the crash. Initial index is passed to LayoutTestsExecuter in the intent that starts
* it.
*/
private int mCurrentTestIndex;
/** The total number of tests to run, doesn't reset after crash */
private int mTotalTestCount;
private WebView mCurrentWebView;
private String mCurrentTestRelativePath;
private String mCurrentTestUri;
private CurrentState mCurrentState = CurrentState.IDLE;
private boolean mCurrentTestTimedOut;
private AbstractResult mCurrentResult;
private AdditionalTextOutput mCurrentAdditionalTextOutput;
private LayoutTestController mLayoutTestController = new LayoutTestController(this);
private boolean mCanOpenWindows;
private boolean mDumpDatabaseCallbacks;
private boolean mIsGeolocationPermissionSet;
private boolean mGeolocationPermission;
private Map<GeolocationPermissions.Callback, String> mPendingGeolocationPermissionCallbacks;
private EventSender mEventSender = new EventSender();
private WakeLock mScreenDimLock;
/** COMMUNICATION WITH ManagerService */
private Messenger mManagerServiceMessenger;
private ServiceConnection mServiceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mManagerServiceMessenger = new Messenger(service);
startTests();
}
@Override
public void onServiceDisconnected(ComponentName name) {
/** TODO */
}
};
private final Handler mResultHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_ACTUAL_RESULT_OBTAINED:
onActualResultsObtained();
break;
case MSG_TEST_TIMED_OUT:
onTestTimedOut();
break;
default:
break;
}
}
};
/** WEBVIEW CONFIGURATION */
private WebViewClient mWebViewClient = new WebViewClient() {
@Override
public void onPageFinished(WebView view, String url) {
/** Some tests fire up many page loads, we don't want to detect them */
if (!url.equals(mCurrentTestUri)) {
return;
}
if (mCurrentState == CurrentState.RENDERING_PAGE) {
onTestFinished();
}
}
@Override
public void onReceivedHttpAuthRequest(WebView view, HttpAuthHandler handler,
String host, String realm) {
if (handler.useHttpAuthUsernamePassword() && view != null) {
String[] credentials = view.getHttpAuthUsernamePassword(host, realm);
if (credentials != null && credentials.length == 2) {
handler.proceed(credentials[0], credentials[1]);
return;
}
}
handler.cancel();
}
@Override
public void onReceivedSslError(WebView view, SslErrorHandler handler, SslError error) {
// We ignore SSL errors. In particular, the certificate used by the LayoutTests server
// produces an error as it lacks a CN field.
handler.proceed();
}
};
private WebChromeClient mWebChromeClient = new WebChromeClient() {
@Override
public void onExceededDatabaseQuota(String url, String databaseIdentifier,
long currentQuota, long estimatedSize, long totalUsedQuota,
QuotaUpdater quotaUpdater) {
/** TODO: This should be recorded as part of the text result */
/** TODO: The quota should also probably be reset somehow for every test? */
if (mDumpDatabaseCallbacks) {
getCurrentAdditionalTextOutput().appendExceededDbQuotaMessage(url,
databaseIdentifier);
}
quotaUpdater.updateQuota(currentQuota + 5 * 1024 * 1024);
}
@Override
public boolean onJsAlert(WebView view, String url, String message, JsResult result) {
getCurrentAdditionalTextOutput().appendJsAlert(message);
result.confirm();
return true;
}
@Override
public boolean onJsConfirm(WebView view, String url, String message, JsResult result) {
getCurrentAdditionalTextOutput().appendJsConfirm(message);
result.confirm();
return true;
}
@Override
public boolean onJsPrompt(WebView view, String url, String message, String defaultValue,
JsPromptResult result) {
getCurrentAdditionalTextOutput().appendJsPrompt(message, defaultValue);
result.confirm();
return true;
}
@Override
public boolean onConsoleMessage(ConsoleMessage consoleMessage) {
getCurrentAdditionalTextOutput().appendConsoleMessage(consoleMessage);
return true;
}
@Override
public boolean onCreateWindow(WebView view, boolean dialog, boolean userGesture,
Message resultMsg) {
WebView.WebViewTransport transport = (WebView.WebViewTransport)resultMsg.obj;
/** By default windows cannot be opened, so just send null back. */
WebView newWindowWebView = null;
if (mCanOpenWindows) {
/**
* We never display the new window, just create the view and allow it's content to
* execute and be recorded by the executor.
*/
newWindowWebView = createWebViewWithJavascriptInterfaces();
setupWebView(newWindowWebView);
}
transport.setWebView(newWindowWebView);
resultMsg.sendToTarget();
return true;
}
@Override
public void onGeolocationPermissionsShowPrompt(String origin,
GeolocationPermissions.Callback callback) {
if (mIsGeolocationPermissionSet) {
callback.invoke(origin, mGeolocationPermission, false);
return;
}
if (mPendingGeolocationPermissionCallbacks == null) {
mPendingGeolocationPermissionCallbacks =
new HashMap<GeolocationPermissions.Callback, String>();
}
mPendingGeolocationPermissionCallbacks.put(callback, origin);
}
};
/** IMPLEMENTATION */
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
/**
* It detects the crash by catching all the uncaught exceptions. However, we
* still have to kill the process, because after catching the exception the
* activity remains in a strange state, where intents don't revive it.
* However, we send the message to the service to speed up the rebooting
* (we don't have to wait for time-out to kick in).
*/
Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread thread, Throwable e) {
Log.w(LOG_TAG,
"onTestCrashed(): " + mCurrentTestRelativePath + " thread=" + thread, e);
try {
Message serviceMsg =
Message.obtain(null, ManagerService.MSG_CURRENT_TEST_CRASHED);
mManagerServiceMessenger.send(serviceMsg);
} catch (RemoteException e2) {
Log.e(LOG_TAG, "mCurrentTestRelativePath=" + mCurrentTestRelativePath, e2);
}
Process.killProcess(Process.myPid());
}
});
requestWindowFeature(Window.FEATURE_PROGRESS);
Intent intent = getIntent();
mTestsList = FsUtils.loadTestListFromStorage(intent.getStringExtra(EXTRA_TESTS_FILE));
mCurrentTestIndex = intent.getIntExtra(EXTRA_TEST_INDEX, -1);
mTotalTestCount = mCurrentTestIndex + mTestsList.size();
PowerManager pm = (PowerManager)getSystemService(Context.POWER_SERVICE);
mScreenDimLock = pm.newWakeLock(PowerManager.SCREEN_DIM_WAKE_LOCK
| PowerManager.ON_AFTER_RELEASE, "WakeLock in LayoutTester");
mScreenDimLock.acquire();
bindService(new Intent(this, ManagerService.class), mServiceConnection,
Context.BIND_AUTO_CREATE);
}
private void reset() {
WebView previousWebView = mCurrentWebView;
resetLayoutTestController();
mCurrentTestTimedOut = false;
mCurrentResult = null;
mCurrentAdditionalTextOutput = null;
mCurrentWebView = createWebViewWithJavascriptInterfaces();
// When we create the first WebView, we need to pause to wait for the WebView thread to spin
// and up and for it to register its message handlers.
if (previousWebView == null) {
try {
Thread.currentThread().sleep(1000);
} catch (Exception e) {}
}
setupWebView(mCurrentWebView);
mEventSender.reset(mCurrentWebView);
setContentView(mCurrentWebView);
if (previousWebView != null) {
Log.d(LOG_TAG + "::reset", "previousWebView != null");
previousWebView.destroy();
}
}
private static class WebViewWithJavascriptInterfaces extends WebView {
public WebViewWithJavascriptInterfaces(
Context context, Map<String, Object> javascriptInterfaces) {
super(context,
null, // attribute set
0, // default style resource ID
javascriptInterfaces,
false); // is private browsing
}
}
private WebView createWebViewWithJavascriptInterfaces() {
Map<String, Object> javascriptInterfaces = new HashMap<String, Object>();
javascriptInterfaces.put("layoutTestController", mLayoutTestController);
javascriptInterfaces.put("eventSender", mEventSender);
return new WebViewWithJavascriptInterfaces(this, javascriptInterfaces);
}
private void setupWebView(WebView webView) {
webView.setWebViewClient(mWebViewClient);
webView.setWebChromeClient(mWebChromeClient);
/**
* Setting a touch interval of -1 effectively disables the optimisation in WebView
* that stops repeated touch events flooding WebCore. The Event Sender only sends a
* single event rather than a stream of events (like what would generally happen in
* a real use of touch events in a WebView) and so if the WebView drops the event,
* the test will fail as the test expects one callback for every touch it synthesizes.
*/
webView.setTouchInterval(-1);
webView.clearCache(true);
WebSettings webViewSettings = webView.getSettings();
webViewSettings.setAppCacheEnabled(true);
webViewSettings.setAppCachePath(getApplicationContext().getCacheDir().getPath());
// Use of larger values causes unexplained AppCache database corruption.
// TODO: Investigate what's really going on here.
webViewSettings.setAppCacheMaxSize(100 * 1024 * 1024);
webViewSettings.setJavaScriptEnabled(true);
webViewSettings.setJavaScriptCanOpenWindowsAutomatically(true);
webViewSettings.setSupportMultipleWindows(true);
webViewSettings.setLayoutAlgorithm(WebSettings.LayoutAlgorithm.NORMAL);
webViewSettings.setDatabaseEnabled(true);
webViewSettings.setDatabasePath(getDir("databases", 0).getAbsolutePath());
webViewSettings.setDomStorageEnabled(true);
webViewSettings.setWorkersEnabled(false);
webViewSettings.setXSSAuditorEnabled(false);
webViewSettings.setPageCacheCapacity(0);
// This is asynchronous, but it gets processed by WebCore before it starts loading pages.
mCurrentWebView.useMockDeviceOrientation();
// Must do this after setting the AppCache path.
WebStorage.getInstance().deleteAllData();
}
private void startTests() {
// This is called when the tests are started and after each crash.
// We only send the reset message in the former case.
if (mCurrentTestIndex <= 0) {
sendResetMessage();
}
if (mCurrentTestIndex == 0) {
sendFirstTestMessage();
}
runNextTest();
}
private void sendResetMessage() {
try {
Message serviceMsg = Message.obtain(null, ManagerService.MSG_RESET);
mManagerServiceMessenger.send(serviceMsg);
} catch (RemoteException e) {
Log.e(LOG_TAG, "Error sending message to manager service:", e);
}
}
private void sendFirstTestMessage() {
try {
Message serviceMsg = Message.obtain(null, ManagerService.MSG_FIRST_TEST);
Bundle bundle = new Bundle();
bundle.putString("firstTest", mTestsList.get(0));
bundle.putInt("index", mCurrentTestIndex);
serviceMsg.setData(bundle);
mManagerServiceMessenger.send(serviceMsg);
} catch (RemoteException e) {
Log.e(LOG_TAG, "Error sending message to manager service:", e);
}
}
private void runNextTest() {
assert mCurrentState == CurrentState.IDLE : "mCurrentState = " + mCurrentState.name();
if (mTestsList.isEmpty()) {
onAllTestsFinished();
return;
}
mCurrentTestRelativePath = mTestsList.remove(0);
Log.i(LOG_TAG, "runNextTest(): Start: " + mCurrentTestRelativePath +
" (" + mCurrentTestIndex + ")");
mCurrentTestUri = FileFilter.getUrl(mCurrentTestRelativePath, true).toString();
reset();
/** Start time-out countdown and the test */
mCurrentState = CurrentState.RENDERING_PAGE;
mResultHandler.sendEmptyMessageDelayed(MSG_TEST_TIMED_OUT, DEFAULT_TIME_OUT_MS);
mCurrentWebView.loadUrl(mCurrentTestUri);
}
private void onTestTimedOut() {
assert mCurrentState.isRunningState() : "mCurrentState = " + mCurrentState.name();
Log.w(LOG_TAG, "onTestTimedOut(): " + mCurrentTestRelativePath);
mCurrentTestTimedOut = true;
/**
* While it is theoretically possible that the test times out because
* of webview becoming unresponsive, it is very unlikely. Therefore it's
* assumed that obtaining results (that calls various webview methods)
* will not itself hang.
*/
obtainActualResultsFromWebView();
}
private void onTestFinished() {
assert mCurrentState.isRunningState() : "mCurrentState = " + mCurrentState.name();
Log.i(LOG_TAG, "onTestFinished(): " + mCurrentTestRelativePath);
mResultHandler.removeMessages(MSG_TEST_TIMED_OUT);
obtainActualResultsFromWebView();
}
private void obtainActualResultsFromWebView() {
/**
* If the result has not been set by the time the test finishes we create
* a default type of result.
*/
if (mCurrentResult == null) {
/** TODO: Default type should be RenderTreeResult. We don't support it now. */
mCurrentResult = new TextResult(mCurrentTestRelativePath);
}
mCurrentState = CurrentState.OBTAINING_RESULT;
if (mCurrentTestTimedOut) {
mCurrentResult.setDidTimeOut();
}
mCurrentResult.obtainActualResults(mCurrentWebView,
mResultHandler.obtainMessage(MSG_ACTUAL_RESULT_OBTAINED));
}
private void onActualResultsObtained() {
assert mCurrentState == CurrentState.OBTAINING_RESULT
: "mCurrentState = " + mCurrentState.name();
Log.i(LOG_TAG, "onActualResultsObtained(): " + mCurrentTestRelativePath);
mCurrentState = CurrentState.IDLE;
reportResultToService();
mCurrentTestIndex++;
updateProgressBar();
runNextTest();
}
private void reportResultToService() {
if (mCurrentAdditionalTextOutput != null) {
mCurrentResult.setAdditionalTextOutputString(mCurrentAdditionalTextOutput.toString());
}
try {
Message serviceMsg =
Message.obtain(null, ManagerService.MSG_PROCESS_ACTUAL_RESULTS);
Bundle bundle = mCurrentResult.getBundle();
bundle.putInt("testIndex", mCurrentTestIndex);
if (!mTestsList.isEmpty()) {
bundle.putString("nextTest", mTestsList.get(0));
}
serviceMsg.setData(bundle);
mManagerServiceMessenger.send(serviceMsg);
} catch (RemoteException e) {
Log.e(LOG_TAG, "mCurrentTestRelativePath=" + mCurrentTestRelativePath, e);
}
}
private void updateProgressBar() {
getWindow().setFeatureInt(Window.FEATURE_PROGRESS,
mCurrentTestIndex * Window.PROGRESS_END / mTotalTestCount);
setTitle(mCurrentTestIndex * 100 / mTotalTestCount + "% " +
"(" + mCurrentTestIndex + "/" + mTotalTestCount + ")");
}
private void onAllTestsFinished() {
mScreenDimLock.release();
try {
Message serviceMsg =
Message.obtain(null, ManagerService.MSG_ALL_TESTS_FINISHED);
mManagerServiceMessenger.send(serviceMsg);
} catch (RemoteException e) {
Log.e(LOG_TAG, "mCurrentTestRelativePath=" + mCurrentTestRelativePath, e);
}
unbindService(mServiceConnection);
}
private AdditionalTextOutput getCurrentAdditionalTextOutput() {
if (mCurrentAdditionalTextOutput == null) {
mCurrentAdditionalTextOutput = new AdditionalTextOutput();
}
return mCurrentAdditionalTextOutput;
}
/** LAYOUT TEST CONTROLLER */
private static final int MSG_WAIT_UNTIL_DONE = 0;
private static final int MSG_NOTIFY_DONE = 1;
private static final int MSG_DUMP_AS_TEXT = 2;
private static final int MSG_DUMP_CHILD_FRAMES_AS_TEXT = 3;
private static final int MSG_SET_CAN_OPEN_WINDOWS = 4;
private static final int MSG_DUMP_DATABASE_CALLBACKS = 5;
private static final int MSG_SET_GEOLOCATION_PERMISSION = 6;
private static final int MSG_OVERRIDE_PREFERENCE = 7;
private static final int MSG_SET_XSS_AUDITOR_ENABLED = 8;
/** String constants for use with layoutTestController.overridePreference() */
private final String WEBKIT_OFFLINE_WEB_APPLICATION_CACHE_ENABLED =
"WebKitOfflineWebApplicationCacheEnabled";
private final String WEBKIT_USES_PAGE_CACHE_PREFERENCE_KEY = "WebKitUsesPageCachePreferenceKey";
Handler mLayoutTestControllerHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
assert mCurrentState.isRunningState() : "mCurrentState = " + mCurrentState.name();
switch (msg.what) {
case MSG_DUMP_AS_TEXT:
if (mCurrentResult == null) {
mCurrentResult = new TextResult(mCurrentTestRelativePath);
}
assert mCurrentResult instanceof TextResult
: "mCurrentResult instanceof" + mCurrentResult.getClass().getName();
break;
case MSG_DUMP_CHILD_FRAMES_AS_TEXT:
/** If dumpAsText was not called we assume that the result should be text */
if (mCurrentResult == null) {
mCurrentResult = new TextResult(mCurrentTestRelativePath);
}
assert mCurrentResult instanceof TextResult
: "mCurrentResult instanceof" + mCurrentResult.getClass().getName();
((TextResult)mCurrentResult).setDumpChildFramesAsText(true);
break;
case MSG_DUMP_DATABASE_CALLBACKS:
mDumpDatabaseCallbacks = true;
break;
case MSG_NOTIFY_DONE:
if (mCurrentState == CurrentState.WAITING_FOR_ASYNCHRONOUS_TEST) {
onTestFinished();
}
break;
case MSG_OVERRIDE_PREFERENCE:
/**
* TODO: We should look up the correct WebView for the frame which
* called the layoutTestController method. Currently, we just use the
* WebView for the main frame. EventSender suffers from the same
* problem.
*/
String key = msg.getData().getString("key");
boolean value = msg.getData().getBoolean("value");
if (WEBKIT_OFFLINE_WEB_APPLICATION_CACHE_ENABLED.equals(key)) {
mCurrentWebView.getSettings().setAppCacheEnabled(value);
} else if (WEBKIT_USES_PAGE_CACHE_PREFERENCE_KEY.equals(key)) {
// Cache the maximum possible number of pages.
mCurrentWebView.getSettings().setPageCacheCapacity(Integer.MAX_VALUE);
} else {
Log.w(LOG_TAG, "LayoutTestController.overridePreference(): " +
"Unsupported preference '" + key + "'");
}
break;
case MSG_SET_CAN_OPEN_WINDOWS:
mCanOpenWindows = true;
break;
case MSG_SET_GEOLOCATION_PERMISSION:
mIsGeolocationPermissionSet = true;
mGeolocationPermission = msg.arg1 == 1;
if (mPendingGeolocationPermissionCallbacks != null) {
Iterator<GeolocationPermissions.Callback> iter =
mPendingGeolocationPermissionCallbacks.keySet().iterator();
while (iter.hasNext()) {
GeolocationPermissions.Callback callback = iter.next();
String origin = mPendingGeolocationPermissionCallbacks.get(callback);
callback.invoke(origin, mGeolocationPermission, false);
}
mPendingGeolocationPermissionCallbacks = null;
}
break;
case MSG_SET_XSS_AUDITOR_ENABLED:
mCurrentWebView.getSettings().setXSSAuditorEnabled(msg.arg1 == 1);
break;
case MSG_WAIT_UNTIL_DONE:
mCurrentState = CurrentState.WAITING_FOR_ASYNCHRONOUS_TEST;
break;
default:
assert false : "msg.what=" + msg.what;
break;
}
}
};
private void resetLayoutTestController() {
mCanOpenWindows = false;
mDumpDatabaseCallbacks = false;
mIsGeolocationPermissionSet = false;
mPendingGeolocationPermissionCallbacks = null;
}
public void dumpAsText(boolean enablePixelTest) {
Log.i(LOG_TAG, mCurrentTestRelativePath + ": dumpAsText(" + enablePixelTest + ") called");
/** TODO: Implement */
if (enablePixelTest) {
Log.w(LOG_TAG, "enablePixelTest not implemented, switching to false");
}
mLayoutTestControllerHandler.sendEmptyMessage(MSG_DUMP_AS_TEXT);
}
public void dumpChildFramesAsText() {
Log.i(LOG_TAG, mCurrentTestRelativePath + ": dumpChildFramesAsText() called");
mLayoutTestControllerHandler.sendEmptyMessage(MSG_DUMP_CHILD_FRAMES_AS_TEXT);
}
public void dumpDatabaseCallbacks() {
Log.i(LOG_TAG, mCurrentTestRelativePath + ": dumpDatabaseCallbacks() called");
mLayoutTestControllerHandler.sendEmptyMessage(MSG_DUMP_DATABASE_CALLBACKS);
}
public void notifyDone() {
Log.i(LOG_TAG, mCurrentTestRelativePath + ": notifyDone() called");
mLayoutTestControllerHandler.sendEmptyMessage(MSG_NOTIFY_DONE);
}
public void overridePreference(String key, boolean value) {
Log.i(LOG_TAG, mCurrentTestRelativePath + ": overridePreference(" + key + ", " + value +
") called");
Message msg = mLayoutTestControllerHandler.obtainMessage(MSG_OVERRIDE_PREFERENCE);
msg.getData().putString("key", key);
msg.getData().putBoolean("value", value);
msg.sendToTarget();
}
public void setCanOpenWindows() {
Log.i(LOG_TAG, mCurrentTestRelativePath + ": setCanOpenWindows() called");
mLayoutTestControllerHandler.sendEmptyMessage(MSG_SET_CAN_OPEN_WINDOWS);
}
public void setGeolocationPermission(boolean allow) {
Log.i(LOG_TAG, mCurrentTestRelativePath + ": setGeolocationPermission(" + allow +
") called");
Message msg = mLayoutTestControllerHandler.obtainMessage(MSG_SET_GEOLOCATION_PERMISSION);
msg.arg1 = allow ? 1 : 0;
msg.sendToTarget();
}
public void setMockDeviceOrientation(boolean canProvideAlpha, double alpha,
boolean canProvideBeta, double beta, boolean canProvideGamma, double gamma) {
Log.i(LOG_TAG, mCurrentTestRelativePath + ": setMockDeviceOrientation(" + canProvideAlpha +
", " + alpha + ", " + canProvideBeta + ", " + beta + ", " + canProvideGamma +
", " + gamma + ")");
mCurrentWebView.setMockDeviceOrientation(canProvideAlpha, alpha, canProvideBeta, beta,
canProvideGamma, gamma);
}
public void setXSSAuditorEnabled(boolean flag) {
Log.i(LOG_TAG, mCurrentTestRelativePath + ": setXSSAuditorEnabled(" + flag + ") called");
Message msg = mLayoutTestControllerHandler.obtainMessage(MSG_SET_XSS_AUDITOR_ENABLED);
msg.arg1 = flag ? 1 : 0;
msg.sendToTarget();
}
public void waitUntilDone() {
Log.i(LOG_TAG, mCurrentTestRelativePath + ": waitUntilDone() called");
mLayoutTestControllerHandler.sendEmptyMessage(MSG_WAIT_UNTIL_DONE);
}
}