| Index: content/shell/renderer/test_runner/TestRunner.cpp
|
| diff --git a/content/shell/renderer/test_runner/TestRunner.cpp b/content/shell/renderer/test_runner/TestRunner.cpp
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..030abf50d6533b39f9e507eb0820d64af772eb03
|
| --- /dev/null
|
| +++ b/content/shell/renderer/test_runner/TestRunner.cpp
|
| @@ -0,0 +1,2132 @@
|
| +// Copyright 2013 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.
|
| +
|
| +/*
|
| + * Copyright (C) 2010 Google Inc. All rights reserved.
|
| + * Copyright (C) 2010 Pawel Hajdan (phajdan.jr@chromium.org)
|
| + * Copyright (C) 2012 Apple Inc. All Rights Reserved.
|
| + *
|
| + * Redistribution and use in source and binary forms, with or without
|
| + * modification, are permitted provided that the following conditions are
|
| + * met:
|
| + *
|
| + * * Redistributions of source code must retain the above copyright
|
| + * notice, this list of conditions and the following disclaimer.
|
| + * * Redistributions in binary form must reproduce the above
|
| + * copyright notice, this list of conditions and the following disclaimer
|
| + * in the documentation and/or other materials provided with the
|
| + * distribution.
|
| + * * Neither the name of Google Inc. nor the names of its
|
| + * contributors may be used to endorse or promote products derived from
|
| + * this software without specific prior written permission.
|
| + *
|
| + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
| + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
| + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
| + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
| + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
| + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
| + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
| + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
| + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
| + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
| + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
| + */
|
| +
|
| +#include "content/shell/renderer/test_runner/TestRunner.h"
|
| +
|
| +#include <limits>
|
| +
|
| +#include "content/shell/common/test_runner/WebPreferences.h"
|
| +#include "content/shell/renderer/test_runner/MockWebSpeechInputController.h"
|
| +#include "content/shell/renderer/test_runner/MockWebSpeechRecognizer.h"
|
| +#include "content/shell/renderer/test_runner/NotificationPresenter.h"
|
| +#include "content/shell/renderer/test_runner/TestInterfaces.h"
|
| +#include "content/shell/renderer/test_runner/WebPermissions.h"
|
| +#include "content/shell/renderer/test_runner/WebTestDelegate.h"
|
| +#include "content/shell/renderer/test_runner/WebTestProxy.h"
|
| +#include "third_party/WebKit/public/platform/WebData.h"
|
| +#include "third_party/WebKit/public/platform/WebDeviceMotionData.h"
|
| +#include "third_party/WebKit/public/platform/WebDeviceOrientationData.h"
|
| +#include "third_party/WebKit/public/platform/WebPoint.h"
|
| +#include "third_party/WebKit/public/platform/WebURLResponse.h"
|
| +#include "third_party/WebKit/public/web/WebBindings.h"
|
| +#include "third_party/WebKit/public/web/WebDataSource.h"
|
| +#include "third_party/WebKit/public/web/WebDocument.h"
|
| +#include "third_party/WebKit/public/web/WebElement.h"
|
| +#include "third_party/WebKit/public/web/WebFindOptions.h"
|
| +#include "third_party/WebKit/public/web/WebFrame.h"
|
| +#include "third_party/WebKit/public/web/WebGeolocationClientMock.h"
|
| +#include "third_party/WebKit/public/web/WebInputElement.h"
|
| +#include "third_party/WebKit/public/web/WebMIDIClientMock.h"
|
| +#include "third_party/WebKit/public/web/WebScriptSource.h"
|
| +#include "third_party/WebKit/public/web/WebSecurityPolicy.h"
|
| +#include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
|
| +#include "third_party/WebKit/public/web/WebSettings.h"
|
| +#include "third_party/WebKit/public/web/WebSurroundingText.h"
|
| +#include "third_party/WebKit/public/web/WebView.h"
|
| +#include "v8/include/v8.h"
|
| +
|
| +#if defined(__linux__) || defined(ANDROID)
|
| +#include "third_party/WebKit/public/web/linux/WebFontRendering.h"
|
| +#endif
|
| +
|
| +using namespace blink;
|
| +using namespace std;
|
| +
|
| +namespace WebTestRunner {
|
| +
|
| +namespace {
|
| +
|
| +class InvokeCallbackTask : public WebMethodTask<TestRunner> {
|
| +public:
|
| + InvokeCallbackTask(TestRunner* object, WebScopedPtr<CppVariant> callbackArguments)
|
| + : WebMethodTask<TestRunner>(object)
|
| + , m_callbackArguments(callbackArguments)
|
| + {
|
| + }
|
| +
|
| + virtual void runIfValid()
|
| + {
|
| + CppVariant invokeResult;
|
| + m_callbackArguments->invokeDefault(m_callbackArguments.get(), 1, invokeResult);
|
| + }
|
| +
|
| +private:
|
| + WebScopedPtr<CppVariant> m_callbackArguments;
|
| +};
|
| +
|
| +}
|
| +
|
| +TestRunner::WorkQueue::~WorkQueue()
|
| +{
|
| + reset();
|
| +}
|
| +
|
| +void TestRunner::WorkQueue::processWorkSoon()
|
| +{
|
| + if (m_controller->topLoadingFrame())
|
| + return;
|
| +
|
| + if (!m_queue.empty()) {
|
| + // We delay processing queued work to avoid recursion problems.
|
| + m_controller->m_delegate->postTask(new WorkQueueTask(this));
|
| + } else if (!m_controller->m_waitUntilDone)
|
| + m_controller->m_delegate->testFinished();
|
| +}
|
| +
|
| +void TestRunner::WorkQueue::processWork()
|
| +{
|
| + // Quit doing work once a load is in progress.
|
| + while (!m_queue.empty()) {
|
| + bool startedLoad = m_queue.front()->run(m_controller->m_delegate, m_controller->m_webView);
|
| + delete m_queue.front();
|
| + m_queue.pop_front();
|
| + if (startedLoad)
|
| + return;
|
| + }
|
| +
|
| + if (!m_controller->m_waitUntilDone && !m_controller->topLoadingFrame())
|
| + m_controller->m_delegate->testFinished();
|
| +}
|
| +
|
| +void TestRunner::WorkQueue::reset()
|
| +{
|
| + m_frozen = false;
|
| + while (!m_queue.empty()) {
|
| + delete m_queue.front();
|
| + m_queue.pop_front();
|
| + }
|
| +}
|
| +
|
| +void TestRunner::WorkQueue::addWork(WorkItem* work)
|
| +{
|
| + if (m_frozen) {
|
| + delete work;
|
| + return;
|
| + }
|
| + m_queue.push_back(work);
|
| +}
|
| +
|
| +
|
| +TestRunner::TestRunner(TestInterfaces* interfaces)
|
| + : m_testIsRunning(false)
|
| + , m_closeRemainingWindows(false)
|
| + , m_workQueue(this)
|
| + , m_testInterfaces(interfaces)
|
| + , m_delegate(0)
|
| + , m_webView(0)
|
| + , m_pageOverlay(0)
|
| + , m_webPermissions(new WebPermissions)
|
| + , m_notificationPresenter(new NotificationPresenter)
|
| +{
|
| + // Initialize the map that associates methods of this class with the names
|
| + // they will use when called by JavaScript. The actual binding of those
|
| + // names to their methods will be done by calling bindToJavaScript() (defined
|
| + // by CppBoundClass, the parent to TestRunner).
|
| +
|
| + // Methods controlling test execution.
|
| + bindMethod("notifyDone", &TestRunner::notifyDone);
|
| + bindMethod("queueBackNavigation", &TestRunner::queueBackNavigation);
|
| + bindMethod("queueForwardNavigation", &TestRunner::queueForwardNavigation);
|
| + bindMethod("queueLoadingScript", &TestRunner::queueLoadingScript);
|
| + bindMethod("queueLoad", &TestRunner::queueLoad);
|
| + bindMethod("queueLoadHTMLString", &TestRunner::queueLoadHTMLString);
|
| + bindMethod("queueNonLoadingScript", &TestRunner::queueNonLoadingScript);
|
| + bindMethod("queueReload", &TestRunner::queueReload);
|
| + bindMethod("setCloseRemainingWindowsWhenComplete", &TestRunner::setCloseRemainingWindowsWhenComplete);
|
| + bindMethod("resetTestHelperControllers", &TestRunner::resetTestHelperControllers);
|
| + bindMethod("setCustomPolicyDelegate", &TestRunner::setCustomPolicyDelegate);
|
| + bindMethod("waitForPolicyDelegate", &TestRunner::waitForPolicyDelegate);
|
| + bindMethod("waitUntilDone", &TestRunner::waitUntilDone);
|
| + bindMethod("windowCount", &TestRunner::windowCount);
|
| + // Methods implemented in terms of chromium's public WebKit API.
|
| + bindMethod("setTabKeyCyclesThroughElements", &TestRunner::setTabKeyCyclesThroughElements);
|
| + bindMethod("execCommand", &TestRunner::execCommand);
|
| + bindMethod("isCommandEnabled", &TestRunner::isCommandEnabled);
|
| + bindMethod("callShouldCloseOnWebView", &TestRunner::callShouldCloseOnWebView);
|
| + bindMethod("setDomainRelaxationForbiddenForURLScheme", &TestRunner::setDomainRelaxationForbiddenForURLScheme);
|
| + bindMethod("evaluateScriptInIsolatedWorldAndReturnValue", &TestRunner::evaluateScriptInIsolatedWorldAndReturnValue);
|
| + bindMethod("evaluateScriptInIsolatedWorld", &TestRunner::evaluateScriptInIsolatedWorld);
|
| + bindMethod("setIsolatedWorldSecurityOrigin", &TestRunner::setIsolatedWorldSecurityOrigin);
|
| + bindMethod("setIsolatedWorldContentSecurityPolicy", &TestRunner::setIsolatedWorldContentSecurityPolicy);
|
| + bindMethod("addOriginAccessWhitelistEntry", &TestRunner::addOriginAccessWhitelistEntry);
|
| + bindMethod("removeOriginAccessWhitelistEntry", &TestRunner::removeOriginAccessWhitelistEntry);
|
| + bindMethod("hasCustomPageSizeStyle", &TestRunner::hasCustomPageSizeStyle);
|
| + bindMethod("forceRedSelectionColors", &TestRunner::forceRedSelectionColors);
|
| + bindMethod("injectStyleSheet", &TestRunner::injectStyleSheet);
|
| + bindMethod("startSpeechInput", &TestRunner::startSpeechInput);
|
| + bindMethod("findString", &TestRunner::findString);
|
| + bindMethod("setValueForUser", &TestRunner::setValueForUser);
|
| + bindMethod("selectionAsMarkup", &TestRunner::selectionAsMarkup);
|
| + bindMethod("setTextSubpixelPositioning", &TestRunner::setTextSubpixelPositioning);
|
| + bindMethod("setPageVisibility", &TestRunner::setPageVisibility);
|
| + bindMethod("setTextDirection", &TestRunner::setTextDirection);
|
| + bindMethod("textSurroundingNode", &TestRunner::textSurroundingNode);
|
| + bindMethod("useUnfortunateSynchronousResizeMode", &TestRunner::useUnfortunateSynchronousResizeMode);
|
| + bindMethod("disableAutoResizeMode", &TestRunner::disableAutoResizeMode);
|
| + bindMethod("enableAutoResizeMode", &TestRunner::enableAutoResizeMode);
|
| + bindMethod("setMockDeviceMotion", &TestRunner::setMockDeviceMotion);
|
| + bindMethod("setMockDeviceOrientation", &TestRunner::setMockDeviceOrientation);
|
| + bindMethod("didAcquirePointerLock", &TestRunner::didAcquirePointerLock);
|
| + bindMethod("didLosePointerLock", &TestRunner::didLosePointerLock);
|
| + bindMethod("didNotAcquirePointerLock", &TestRunner::didNotAcquirePointerLock);
|
| + bindMethod("setPointerLockWillRespondAsynchronously", &TestRunner::setPointerLockWillRespondAsynchronously);
|
| + bindMethod("setPointerLockWillFailSynchronously", &TestRunner::setPointerLockWillFailSynchronously);
|
| +
|
| + // The following modify WebPreferences.
|
| + bindMethod("setPopupBlockingEnabled", &TestRunner::setPopupBlockingEnabled);
|
| + bindMethod("setJavaScriptCanAccessClipboard", &TestRunner::setJavaScriptCanAccessClipboard);
|
| + bindMethod("setXSSAuditorEnabled", &TestRunner::setXSSAuditorEnabled);
|
| + bindMethod("setAllowUniversalAccessFromFileURLs", &TestRunner::setAllowUniversalAccessFromFileURLs);
|
| + bindMethod("setAllowFileAccessFromFileURLs", &TestRunner::setAllowFileAccessFromFileURLs);
|
| + bindMethod("overridePreference", &TestRunner::overridePreference);
|
| + bindMethod("setPluginsEnabled", &TestRunner::setPluginsEnabled);
|
| +
|
| + // The following modify the state of the TestRunner.
|
| + bindMethod("dumpEditingCallbacks", &TestRunner::dumpEditingCallbacks);
|
| + bindMethod("dumpAsText", &TestRunner::dumpAsText);
|
| + bindMethod("dumpAsTextWithPixelResults", &TestRunner::dumpAsTextWithPixelResults);
|
| + bindMethod("dumpChildFramesAsText", &TestRunner::dumpChildFramesAsText);
|
| + bindMethod("dumpChildFrameScrollPositions", &TestRunner::dumpChildFrameScrollPositions);
|
| + bindMethod("dumpIconChanges", &TestRunner::dumpIconChanges);
|
| + bindMethod("setAudioData", &TestRunner::setAudioData);
|
| + bindMethod("dumpFrameLoadCallbacks", &TestRunner::dumpFrameLoadCallbacks);
|
| + bindMethod("dumpPingLoaderCallbacks", &TestRunner::dumpPingLoaderCallbacks);
|
| + bindMethod("dumpUserGestureInFrameLoadCallbacks", &TestRunner::dumpUserGestureInFrameLoadCallbacks);
|
| + bindMethod("dumpTitleChanges", &TestRunner::dumpTitleChanges);
|
| + bindMethod("dumpCreateView", &TestRunner::dumpCreateView);
|
| + bindMethod("setCanOpenWindows", &TestRunner::setCanOpenWindows);
|
| + bindMethod("dumpResourceLoadCallbacks", &TestRunner::dumpResourceLoadCallbacks);
|
| + bindMethod("dumpResourceRequestCallbacks", &TestRunner::dumpResourceRequestCallbacks);
|
| + bindMethod("dumpResourceResponseMIMETypes", &TestRunner::dumpResourceResponseMIMETypes);
|
| + bindMethod("dumpPermissionClientCallbacks", &TestRunner::dumpPermissionClientCallbacks);
|
| + bindMethod("setImagesAllowed", &TestRunner::setImagesAllowed);
|
| + bindMethod("setScriptsAllowed", &TestRunner::setScriptsAllowed);
|
| + bindMethod("setStorageAllowed", &TestRunner::setStorageAllowed);
|
| + bindMethod("setPluginsAllowed", &TestRunner::setPluginsAllowed);
|
| + bindMethod("setAllowDisplayOfInsecureContent", &TestRunner::setAllowDisplayOfInsecureContent);
|
| + bindMethod("setAllowRunningOfInsecureContent", &TestRunner::setAllowRunningOfInsecureContent);
|
| + bindMethod("dumpStatusCallbacks", &TestRunner::dumpWindowStatusChanges);
|
| + bindMethod("dumpProgressFinishedCallback", &TestRunner::dumpProgressFinishedCallback);
|
| + bindMethod("dumpSpellCheckCallbacks", &TestRunner::dumpSpellCheckCallbacks);
|
| + bindMethod("dumpBackForwardList", &TestRunner::dumpBackForwardList);
|
| + bindMethod("dumpSelectionRect", &TestRunner::dumpSelectionRect);
|
| + bindMethod("testRepaint", &TestRunner::testRepaint);
|
| + bindMethod("repaintSweepHorizontally", &TestRunner::repaintSweepHorizontally);
|
| + bindMethod("setPrinting", &TestRunner::setPrinting);
|
| + bindMethod("setShouldStayOnPageAfterHandlingBeforeUnload", &TestRunner::setShouldStayOnPageAfterHandlingBeforeUnload);
|
| + bindMethod("setWillSendRequestClearHeader", &TestRunner::setWillSendRequestClearHeader);
|
| + bindMethod("dumpResourceRequestPriorities", &TestRunner::dumpResourceRequestPriorities);
|
| +
|
| + // The following methods interact with the WebTestProxy.
|
| + // The following methods interact with the WebTestDelegate.
|
| + bindMethod("showWebInspector", &TestRunner::showWebInspector);
|
| + bindMethod("closeWebInspector", &TestRunner::closeWebInspector);
|
| + bindMethod("evaluateInWebInspector", &TestRunner::evaluateInWebInspector);
|
| + bindMethod("clearAllDatabases", &TestRunner::clearAllDatabases);
|
| + bindMethod("setDatabaseQuota", &TestRunner::setDatabaseQuota);
|
| + bindMethod("setAlwaysAcceptCookies", &TestRunner::setAlwaysAcceptCookies);
|
| + bindMethod("setWindowIsKey", &TestRunner::setWindowIsKey);
|
| + bindMethod("pathToLocalResource", &TestRunner::pathToLocalResource);
|
| + bindMethod("setBackingScaleFactor", &TestRunner::setBackingScaleFactor);
|
| + bindMethod("setPOSIXLocale", &TestRunner::setPOSIXLocale);
|
| + bindMethod("numberOfPendingGeolocationPermissionRequests", &TestRunner:: numberOfPendingGeolocationPermissionRequests);
|
| + bindMethod("setGeolocationPermission", &TestRunner::setGeolocationPermission);
|
| + bindMethod("setMockGeolocationPositionUnavailableError", &TestRunner::setMockGeolocationPositionUnavailableError);
|
| + bindMethod("setMockGeolocationPosition", &TestRunner::setMockGeolocationPosition);
|
| + bindMethod("setMIDIAccessorResult", &TestRunner::setMIDIAccessorResult);
|
| + bindMethod("setMIDISysExPermission", &TestRunner::setMIDISysExPermission);
|
| + bindMethod("grantWebNotificationPermission", &TestRunner::grantWebNotificationPermission);
|
| + bindMethod("simulateLegacyWebNotificationClick", &TestRunner::simulateLegacyWebNotificationClick);
|
| + bindMethod("cancelAllActiveNotifications", &TestRunner::cancelAllActiveNotifications);
|
| + bindMethod("addMockSpeechInputResult", &TestRunner::addMockSpeechInputResult);
|
| + bindMethod("setMockSpeechInputDumpRect", &TestRunner::setMockSpeechInputDumpRect);
|
| + bindMethod("addMockSpeechRecognitionResult", &TestRunner::addMockSpeechRecognitionResult);
|
| + bindMethod("setMockSpeechRecognitionError", &TestRunner::setMockSpeechRecognitionError);
|
| + bindMethod("wasMockSpeechRecognitionAborted", &TestRunner::wasMockSpeechRecognitionAborted);
|
| + bindMethod("display", &TestRunner::display);
|
| + bindMethod("displayInvalidatedRegion", &TestRunner::displayInvalidatedRegion);
|
| + bindMethod("isChooserShown", &TestRunner::isChooserShown);
|
| +
|
| + // The following modify WebPageOverlays.
|
| + bindMethod("addWebPageOverlay", &TestRunner::addWebPageOverlay);
|
| + bindMethod("removeWebPageOverlay", &TestRunner::removeWebPageOverlay);
|
| +
|
| + // Properties.
|
| + bindProperty("globalFlag", &m_globalFlag);
|
| + bindProperty("platformName", &m_platformName);
|
| + bindProperty("tooltipText", &m_tooltipText);
|
| + bindProperty("disableNotifyDone", &m_disableNotifyDone);
|
| +
|
| + // webHistoryItemCount is used by tests in LayoutTests\http\tests\history
|
| + bindProperty("webHistoryItemCount", &m_webHistoryItemCount);
|
| + bindProperty("interceptPostMessage", &m_interceptPostMessage);
|
| +
|
| + // The following are stubs.
|
| + bindMethod("dumpDatabaseCallbacks", &TestRunner::notImplemented);
|
| + bindMethod("denyWebNotificationPermission", &TestRunner::notImplemented);
|
| + bindMethod("removeAllWebNotificationPermissions", &TestRunner::notImplemented);
|
| + bindMethod("simulateWebNotificationClick", &TestRunner::notImplemented);
|
| + bindMethod("setIconDatabaseEnabled", &TestRunner::notImplemented);
|
| + bindMethod("setScrollbarPolicy", &TestRunner::notImplemented);
|
| + bindMethod("clearAllApplicationCaches", &TestRunner::notImplemented);
|
| + bindMethod("clearApplicationCacheForOrigin", &TestRunner::notImplemented);
|
| + bindMethod("clearBackForwardList", &TestRunner::notImplemented);
|
| + bindMethod("keepWebHistory", &TestRunner::notImplemented);
|
| + bindMethod("setApplicationCacheOriginQuota", &TestRunner::notImplemented);
|
| + bindMethod("setCallCloseOnWebViews", &TestRunner::notImplemented);
|
| + bindMethod("setMainFrameIsFirstResponder", &TestRunner::notImplemented);
|
| + bindMethod("setUseDashboardCompatibilityMode", &TestRunner::notImplemented);
|
| + bindMethod("deleteAllLocalStorage", &TestRunner::notImplemented);
|
| + bindMethod("localStorageDiskUsageForOrigin", &TestRunner::notImplemented);
|
| + bindMethod("originsWithLocalStorage", &TestRunner::notImplemented);
|
| + bindMethod("deleteLocalStorageForOrigin", &TestRunner::notImplemented);
|
| + bindMethod("observeStorageTrackerNotifications", &TestRunner::notImplemented);
|
| + bindMethod("syncLocalStorage", &TestRunner::notImplemented);
|
| + bindMethod("addDisallowedURL", &TestRunner::notImplemented);
|
| + bindMethod("applicationCacheDiskUsageForOrigin", &TestRunner::notImplemented);
|
| + bindMethod("abortModal", &TestRunner::notImplemented);
|
| +
|
| + // The fallback method is called when an unknown method is invoked.
|
| + bindFallbackMethod(&TestRunner::fallbackMethod);
|
| +}
|
| +
|
| +TestRunner::~TestRunner()
|
| +{
|
| +}
|
| +
|
| +void TestRunner::setDelegate(WebTestDelegate* delegate)
|
| +{
|
| + m_delegate = delegate;
|
| + m_webPermissions->setDelegate(delegate);
|
| + m_notificationPresenter->setDelegate(delegate);
|
| +}
|
| +
|
| +void TestRunner::setWebView(WebView* webView, WebTestProxyBase* proxy)
|
| +{
|
| + m_webView = webView;
|
| + m_proxy = proxy;
|
| +}
|
| +
|
| +void TestRunner::reset()
|
| +{
|
| + if (m_webView) {
|
| + m_webView->setZoomLevel(0);
|
| + m_webView->setTextZoomFactor(1);
|
| + m_webView->setTabKeyCyclesThroughElements(true);
|
| +#if !defined(__APPLE__) && !defined(WIN32) // Actually, TOOLKIT_GTK
|
| + // (Constants copied because we can't depend on the header that defined
|
| + // them from this file.)
|
| + m_webView->setSelectionColors(0xff1e90ff, 0xff000000, 0xffc8c8c8, 0xff323232);
|
| +#endif
|
| + m_webView->removeInjectedStyleSheets();
|
| + m_webView->setVisibilityState(WebPageVisibilityStateVisible, true);
|
| + m_webView->mainFrame()->enableViewSourceMode(false);
|
| +
|
| + if (m_pageOverlay) {
|
| + m_webView->removePageOverlay(m_pageOverlay);
|
| + delete m_pageOverlay;
|
| + m_pageOverlay = 0;
|
| + }
|
| + }
|
| +
|
| + m_topLoadingFrame = 0;
|
| + m_waitUntilDone = false;
|
| + m_policyDelegateEnabled = false;
|
| + m_policyDelegateIsPermissive = false;
|
| + m_policyDelegateShouldNotifyDone = false;
|
| +
|
| + WebSecurityPolicy::resetOriginAccessWhitelists();
|
| +#if defined(__linux__) || defined(ANDROID)
|
| + WebFontRendering::setSubpixelPositioning(false);
|
| +#endif
|
| +
|
| + if (m_delegate) {
|
| + // Reset the default quota for each origin to 5MB
|
| + m_delegate->setDatabaseQuota(5 * 1024 * 1024);
|
| + m_delegate->setDeviceScaleFactor(1);
|
| + m_delegate->setAcceptAllCookies(false);
|
| + m_delegate->setLocale("");
|
| + m_delegate->useUnfortunateSynchronousResizeMode(false);
|
| + m_delegate->disableAutoResizeMode(WebSize());
|
| + m_delegate->deleteAllCookies();
|
| + }
|
| +
|
| + m_dumpEditingCallbacks = false;
|
| + m_dumpAsText = false;
|
| + m_dumpAsMarkup = false;
|
| + m_generatePixelResults = true;
|
| + m_dumpChildFrameScrollPositions = false;
|
| + m_dumpChildFramesAsText = false;
|
| + m_dumpIconChanges = false;
|
| + m_dumpAsAudio = false;
|
| + m_dumpFrameLoadCallbacks = false;
|
| + m_dumpPingLoaderCallbacks = false;
|
| + m_dumpUserGestureInFrameLoadCallbacks = false;
|
| + m_dumpTitleChanges = false;
|
| + m_dumpCreateView = false;
|
| + m_canOpenWindows = false;
|
| + m_dumpResourceLoadCallbacks = false;
|
| + m_dumpResourceRequestCallbacks = false;
|
| + m_dumpResourceResponseMIMETypes = false;
|
| + m_dumpWindowStatusChanges = false;
|
| + m_dumpProgressFinishedCallback = false;
|
| + m_dumpSpellCheckCallbacks = false;
|
| + m_dumpBackForwardList = false;
|
| + m_dumpSelectionRect = false;
|
| + m_testRepaint = false;
|
| + m_sweepHorizontally = false;
|
| + m_isPrinting = false;
|
| + m_midiAccessorResult = true;
|
| + m_shouldStayOnPageAfterHandlingBeforeUnload = false;
|
| + m_shouldDumpResourcePriorities = false;
|
| +
|
| + m_httpHeadersToClear.clear();
|
| +
|
| + m_globalFlag.set(false);
|
| + m_webHistoryItemCount.set(0);
|
| + m_interceptPostMessage.set(false);
|
| + m_platformName.set("chromium");
|
| + m_tooltipText.set("");
|
| + m_disableNotifyDone.set(false);
|
| +
|
| + m_webPermissions->reset();
|
| +
|
| + m_notificationPresenter->reset();
|
| +
|
| + m_pointerLocked = false;
|
| + m_pointerLockPlannedResult = PointerLockWillSucceed;
|
| +
|
| + m_taskList.revokeAll();
|
| + m_workQueue.reset();
|
| +
|
| + if (m_closeRemainingWindows && m_delegate)
|
| + m_delegate->closeRemainingWindows();
|
| + else
|
| + m_closeRemainingWindows = true;
|
| +}
|
| +
|
| +
|
| +void TestRunner::setTestIsRunning(bool running)
|
| +{
|
| + m_testIsRunning = running;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpEditingCallbacks() const
|
| +{
|
| + return m_dumpEditingCallbacks;
|
| +}
|
| +
|
| +void TestRunner::checkResponseMimeType()
|
| +{
|
| + // Text output: the test page can request different types of output
|
| + // which we handle here.
|
| + if (!m_dumpAsText) {
|
| + string mimeType = m_webView->mainFrame()->dataSource()->response().mimeType().utf8();
|
| + if (mimeType == "text/plain") {
|
| + m_dumpAsText = true;
|
| + m_generatePixelResults = false;
|
| + }
|
| + }
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpAsText()
|
| +{
|
| + checkResponseMimeType();
|
| + return m_dumpAsText;
|
| +}
|
| +
|
| +void TestRunner::setShouldDumpAsText(bool value)
|
| +{
|
| + m_dumpAsText = value;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpAsMarkup()
|
| +{
|
| + return m_dumpAsMarkup;
|
| +}
|
| +
|
| +void TestRunner::setShouldDumpAsMarkup(bool value)
|
| +{
|
| + m_dumpAsMarkup = value;
|
| +}
|
| +
|
| +bool TestRunner::shouldGeneratePixelResults()
|
| +{
|
| + checkResponseMimeType();
|
| + return m_generatePixelResults;
|
| +}
|
| +
|
| +void TestRunner::setShouldGeneratePixelResults(bool value)
|
| +{
|
| + m_generatePixelResults = value;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpChildFrameScrollPositions() const
|
| +{
|
| + return m_dumpChildFrameScrollPositions;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpChildFramesAsText() const
|
| +{
|
| + return m_dumpChildFramesAsText;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpAsAudio() const
|
| +{
|
| + return m_dumpAsAudio;
|
| +}
|
| +
|
| +const WebArrayBufferView* TestRunner::audioData() const
|
| +{
|
| + return &m_audioData;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpFrameLoadCallbacks() const
|
| +{
|
| + return m_testIsRunning && m_dumpFrameLoadCallbacks;
|
| +}
|
| +
|
| +void TestRunner::setShouldDumpFrameLoadCallbacks(bool value)
|
| +{
|
| + m_dumpFrameLoadCallbacks = value;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpPingLoaderCallbacks() const
|
| +{
|
| + return m_testIsRunning && m_dumpPingLoaderCallbacks;
|
| +}
|
| +
|
| +void TestRunner::setShouldDumpPingLoaderCallbacks(bool value)
|
| +{
|
| + m_dumpPingLoaderCallbacks = value;
|
| +}
|
| +
|
| +void TestRunner::setShouldEnableViewSource(bool value)
|
| +{
|
| + m_webView->mainFrame()->enableViewSourceMode(value);
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpUserGestureInFrameLoadCallbacks() const
|
| +{
|
| + return m_testIsRunning && m_dumpUserGestureInFrameLoadCallbacks;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpTitleChanges() const
|
| +{
|
| + return m_dumpTitleChanges;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpIconChanges() const
|
| +{
|
| + return m_dumpIconChanges;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpCreateView() const
|
| +{
|
| + return m_dumpCreateView;
|
| +}
|
| +
|
| +bool TestRunner::canOpenWindows() const
|
| +{
|
| + return m_canOpenWindows;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpResourceLoadCallbacks() const
|
| +{
|
| + return m_testIsRunning && m_dumpResourceLoadCallbacks;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpResourceRequestCallbacks() const
|
| +{
|
| + return m_testIsRunning && m_dumpResourceRequestCallbacks;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpResourceResponseMIMETypes() const
|
| +{
|
| + return m_testIsRunning && m_dumpResourceResponseMIMETypes;
|
| +}
|
| +
|
| +WebPermissionClient* TestRunner::webPermissions() const
|
| +{
|
| + return m_webPermissions.get();
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpStatusCallbacks() const
|
| +{
|
| + return m_dumpWindowStatusChanges;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpProgressFinishedCallback() const
|
| +{
|
| + return m_dumpProgressFinishedCallback;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpSpellCheckCallbacks() const
|
| +{
|
| + return m_dumpSpellCheckCallbacks;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpBackForwardList() const
|
| +{
|
| + return m_dumpBackForwardList;
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpSelectionRect() const
|
| +{
|
| + return m_dumpSelectionRect;
|
| +}
|
| +
|
| +bool TestRunner::testRepaint() const
|
| +{
|
| + return m_testRepaint;
|
| +}
|
| +
|
| +bool TestRunner::sweepHorizontally() const
|
| +{
|
| + return m_sweepHorizontally;
|
| +}
|
| +
|
| +bool TestRunner::isPrinting() const
|
| +{
|
| + return m_isPrinting;
|
| +}
|
| +
|
| +bool TestRunner::shouldStayOnPageAfterHandlingBeforeUnload() const
|
| +{
|
| + return m_shouldStayOnPageAfterHandlingBeforeUnload;
|
| +}
|
| +
|
| +const std::set<std::string>* TestRunner::httpHeadersToClear() const
|
| +{
|
| + return &m_httpHeadersToClear;
|
| +}
|
| +
|
| +void TestRunner::setTopLoadingFrame(WebFrame* frame, bool clear)
|
| +{
|
| + if (frame->top()->view() != m_webView)
|
| + return;
|
| + if (!m_testIsRunning)
|
| + return;
|
| + if (clear) {
|
| + m_topLoadingFrame = 0;
|
| + locationChangeDone();
|
| + } else if (!m_topLoadingFrame)
|
| + m_topLoadingFrame = frame;
|
| +}
|
| +
|
| +WebFrame* TestRunner::topLoadingFrame() const
|
| +{
|
| + return m_topLoadingFrame;
|
| +}
|
| +
|
| +void TestRunner::policyDelegateDone()
|
| +{
|
| + BLINK_ASSERT(m_waitUntilDone);
|
| + m_delegate->testFinished();
|
| + m_waitUntilDone = false;
|
| +}
|
| +
|
| +bool TestRunner::policyDelegateEnabled() const
|
| +{
|
| + return m_policyDelegateEnabled;
|
| +}
|
| +
|
| +bool TestRunner::policyDelegateIsPermissive() const
|
| +{
|
| + return m_policyDelegateIsPermissive;
|
| +}
|
| +
|
| +bool TestRunner::policyDelegateShouldNotifyDone() const
|
| +{
|
| + return m_policyDelegateShouldNotifyDone;
|
| +}
|
| +
|
| +bool TestRunner::shouldInterceptPostMessage() const
|
| +{
|
| + return m_interceptPostMessage.isBool() && m_interceptPostMessage.toBoolean();
|
| +}
|
| +
|
| +bool TestRunner::shouldDumpResourcePriorities() const
|
| +{
|
| + return m_shouldDumpResourcePriorities;
|
| +}
|
| +
|
| +WebNotificationPresenter* TestRunner::notificationPresenter() const
|
| +{
|
| + return m_notificationPresenter.get();
|
| +}
|
| +
|
| +bool TestRunner::requestPointerLock()
|
| +{
|
| + switch (m_pointerLockPlannedResult) {
|
| + case PointerLockWillSucceed:
|
| + m_delegate->postDelayedTask(new HostMethodTask(this, &TestRunner::didAcquirePointerLockInternal), 0);
|
| + return true;
|
| + case PointerLockWillRespondAsync:
|
| + BLINK_ASSERT(!m_pointerLocked);
|
| + return true;
|
| + case PointerLockWillFailSync:
|
| + BLINK_ASSERT(!m_pointerLocked);
|
| + return false;
|
| + default:
|
| + BLINK_ASSERT_NOT_REACHED();
|
| + return false;
|
| + }
|
| +}
|
| +
|
| +void TestRunner::requestPointerUnlock()
|
| +{
|
| + m_delegate->postDelayedTask(new HostMethodTask(this, &TestRunner::didLosePointerLockInternal), 0);
|
| +}
|
| +
|
| +bool TestRunner::isPointerLocked()
|
| +{
|
| + return m_pointerLocked;
|
| +}
|
| +
|
| +void TestRunner::setToolTipText(const blink::WebString& text)
|
| +{
|
| + m_tooltipText.set(text.utf8());
|
| +}
|
| +
|
| +bool TestRunner::midiAccessorResult()
|
| +{
|
| + return m_midiAccessorResult;
|
| +}
|
| +
|
| +TestRunner::TestPageOverlay::TestPageOverlay(blink::WebView* webView) : m_webView(webView)
|
| +{
|
| +}
|
| +
|
| +TestRunner::TestPageOverlay::~TestPageOverlay()
|
| +{
|
| +}
|
| +
|
| +void TestRunner::TestPageOverlay::paintPageOverlay(blink::WebCanvas* canvas)
|
| +{
|
| + SkRect rect = SkRect::MakeWH(m_webView->size().width, m_webView->size().height);
|
| + SkPaint paint;
|
| + paint.setColor(SK_ColorCYAN);
|
| + paint.setStyle(SkPaint::kFill_Style);
|
| + canvas->drawRect(rect, paint);
|
| +}
|
| +
|
| +void TestRunner::didAcquirePointerLockInternal()
|
| +{
|
| + m_pointerLocked = true;
|
| + m_webView->didAcquirePointerLock();
|
| +
|
| + // Reset planned result to default.
|
| + m_pointerLockPlannedResult = PointerLockWillSucceed;
|
| +}
|
| +
|
| +void TestRunner::didNotAcquirePointerLockInternal()
|
| +{
|
| + BLINK_ASSERT(!m_pointerLocked);
|
| + m_pointerLocked = false;
|
| + m_webView->didNotAcquirePointerLock();
|
| +
|
| + // Reset planned result to default.
|
| + m_pointerLockPlannedResult = PointerLockWillSucceed;
|
| +}
|
| +
|
| +void TestRunner::didLosePointerLockInternal()
|
| +{
|
| + bool wasLocked = m_pointerLocked;
|
| + m_pointerLocked = false;
|
| + if (wasLocked)
|
| + m_webView->didLosePointerLock();
|
| +}
|
| +
|
| +void TestRunner::showDevTools()
|
| +{
|
| + m_delegate->showDevTools();
|
| +}
|
| +
|
| +void TestRunner::waitUntilDone(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_waitUntilDone = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::notifyDone(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + if (m_disableNotifyDone.toBoolean())
|
| + return;
|
| +
|
| + // Test didn't timeout. Kill the timeout timer.
|
| + taskList()->revokeAll();
|
| +
|
| + completeNotifyDone();
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::completeNotifyDone()
|
| +{
|
| + if (m_waitUntilDone && !topLoadingFrame() && m_workQueue.isEmpty())
|
| + m_delegate->testFinished();
|
| + m_waitUntilDone = false;
|
| +}
|
| +
|
| +class WorkItemBackForward : public TestRunner::WorkItem {
|
| +public:
|
| + WorkItemBackForward(int distance) : m_distance(distance) { }
|
| + bool run(WebTestDelegate* delegate, WebView*)
|
| + {
|
| + delegate->goToOffset(m_distance);
|
| + return true; // FIXME: Did it really start a navigation?
|
| + }
|
| +
|
| +private:
|
| + int m_distance;
|
| +};
|
| +
|
| +void TestRunner::queueBackNavigation(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isNumber())
|
| + m_workQueue.addWork(new WorkItemBackForward(-arguments[0].toInt32()));
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::queueForwardNavigation(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isNumber())
|
| + m_workQueue.addWork(new WorkItemBackForward(arguments[0].toInt32()));
|
| + result->setNull();
|
| +}
|
| +
|
| +class WorkItemReload : public TestRunner::WorkItem {
|
| +public:
|
| + bool run(WebTestDelegate* delegate, WebView*)
|
| + {
|
| + delegate->reload();
|
| + return true;
|
| + }
|
| +};
|
| +
|
| +void TestRunner::queueReload(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_workQueue.addWork(new WorkItemReload);
|
| + result->setNull();
|
| +}
|
| +
|
| +class WorkItemLoadingScript : public TestRunner::WorkItem {
|
| +public:
|
| + WorkItemLoadingScript(const string& script) : m_script(script) { }
|
| + bool run(WebTestDelegate*, WebView* webView)
|
| + {
|
| + webView->mainFrame()->executeScript(WebScriptSource(WebString::fromUTF8(m_script)));
|
| + return true; // FIXME: Did it really start a navigation?
|
| + }
|
| +
|
| +private:
|
| + string m_script;
|
| +};
|
| +
|
| +class WorkItemNonLoadingScript : public TestRunner::WorkItem {
|
| +public:
|
| + WorkItemNonLoadingScript(const string& script) : m_script(script) { }
|
| + bool run(WebTestDelegate*, WebView* webView)
|
| + {
|
| + webView->mainFrame()->executeScript(WebScriptSource(WebString::fromUTF8(m_script)));
|
| + return false;
|
| + }
|
| +
|
| +private:
|
| + string m_script;
|
| +};
|
| +
|
| +void TestRunner::queueLoadingScript(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isString())
|
| + m_workQueue.addWork(new WorkItemLoadingScript(arguments[0].toString()));
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::queueNonLoadingScript(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isString())
|
| + m_workQueue.addWork(new WorkItemNonLoadingScript(arguments[0].toString()));
|
| + result->setNull();
|
| +}
|
| +
|
| +class WorkItemLoad : public TestRunner::WorkItem {
|
| +public:
|
| + WorkItemLoad(const WebURL& url, const string& target)
|
| + : m_url(url)
|
| + , m_target(target) { }
|
| + bool run(WebTestDelegate* delegate, WebView*)
|
| + {
|
| + delegate->loadURLForFrame(m_url, m_target);
|
| + return true; // FIXME: Did it really start a navigation?
|
| + }
|
| +
|
| +private:
|
| + WebURL m_url;
|
| + string m_target;
|
| +};
|
| +
|
| +void TestRunner::queueLoad(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isString()) {
|
| + // FIXME: Implement WebURL::resolve() and avoid GURL.
|
| + GURL currentURL = m_webView->mainFrame()->document().url();
|
| + GURL fullURL = currentURL.Resolve(arguments[0].toString());
|
| +
|
| + string target = "";
|
| + if (arguments.size() > 1 && arguments[1].isString())
|
| + target = arguments[1].toString();
|
| +
|
| + m_workQueue.addWork(new WorkItemLoad(fullURL, target));
|
| + }
|
| + result->setNull();
|
| +}
|
| +
|
| +class WorkItemLoadHTMLString : public TestRunner::WorkItem {
|
| +public:
|
| + WorkItemLoadHTMLString(const std::string& html, const WebURL& baseURL)
|
| + : m_html(html)
|
| + , m_baseURL(baseURL) { }
|
| + WorkItemLoadHTMLString(const std::string& html, const WebURL& baseURL, const WebURL& unreachableURL)
|
| + : m_html(html)
|
| + , m_baseURL(baseURL)
|
| + , m_unreachableURL(unreachableURL) { }
|
| + bool run(WebTestDelegate*, WebView* webView)
|
| + {
|
| + webView->mainFrame()->loadHTMLString(
|
| + blink::WebData(m_html.data(), m_html.length()), m_baseURL, m_unreachableURL);
|
| + return true;
|
| + }
|
| +
|
| +private:
|
| + std::string m_html;
|
| + WebURL m_baseURL;
|
| + WebURL m_unreachableURL;
|
| +};
|
| +
|
| +void TestRunner::queueLoadHTMLString(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isString()) {
|
| + string html = arguments[0].toString();
|
| + WebURL baseURL(GURL(""));
|
| + if (arguments.size() > 1 && arguments[1].isString())
|
| + baseURL = WebURL(GURL(arguments[1].toString()));
|
| + if (arguments.size() > 2 && arguments[2].isString())
|
| + m_workQueue.addWork(new WorkItemLoadHTMLString(html, baseURL, WebURL(GURL(arguments[2].toString()))));
|
| + else
|
| + m_workQueue.addWork(new WorkItemLoadHTMLString(html, baseURL));
|
| + }
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::locationChangeDone()
|
| +{
|
| + m_webHistoryItemCount.set(m_delegate->navigationEntryCount());
|
| +
|
| + // No more new work after the first complete load.
|
| + m_workQueue.setFrozen(true);
|
| +
|
| + if (!m_waitUntilDone)
|
| + m_workQueue.processWorkSoon();
|
| +}
|
| +
|
| +void TestRunner::windowCount(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + result->set(static_cast<int>(m_testInterfaces->windowList().size()));
|
| +}
|
| +
|
| +void TestRunner::setCloseRemainingWindowsWhenComplete(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool())
|
| + m_closeRemainingWindows = arguments[0].value.boolValue;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::resetTestHelperControllers(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + m_testInterfaces->resetTestHelperControllers();
|
| +
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setCustomPolicyDelegate(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool()) {
|
| + m_policyDelegateEnabled = arguments[0].value.boolValue;
|
| + m_policyDelegateIsPermissive = false;
|
| + if (arguments.size() > 1 && arguments[1].isBool())
|
| + m_policyDelegateIsPermissive = arguments[1].value.boolValue;
|
| + }
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::waitForPolicyDelegate(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_policyDelegateEnabled = true;
|
| + m_policyDelegateShouldNotifyDone = true;
|
| + m_waitUntilDone = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpPermissionClientCallbacks(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_webPermissions->setDumpCallbacks(true);
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setImagesAllowed(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool())
|
| + m_webPermissions->setImagesAllowed(arguments[0].toBoolean());
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setScriptsAllowed(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool())
|
| + m_webPermissions->setScriptsAllowed(arguments[0].toBoolean());
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setStorageAllowed(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool())
|
| + m_webPermissions->setStorageAllowed(arguments[0].toBoolean());
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setPluginsAllowed(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool())
|
| + m_webPermissions->setPluginsAllowed(arguments[0].toBoolean());
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setAllowDisplayOfInsecureContent(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool())
|
| + m_webPermissions->setDisplayingInsecureContentAllowed(arguments[0].toBoolean());
|
| +
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setAllowRunningOfInsecureContent(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool())
|
| + m_webPermissions->setRunningInsecureContentAllowed(arguments[0].value.boolValue);
|
| +
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpWindowStatusChanges(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpWindowStatusChanges = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpProgressFinishedCallback(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpProgressFinishedCallback = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpSpellCheckCallbacks(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpSpellCheckCallbacks = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpBackForwardList(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpBackForwardList = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpSelectionRect(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + m_dumpSelectionRect = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::testRepaint(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_testRepaint = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::repaintSweepHorizontally(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_sweepHorizontally = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setPrinting(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + m_isPrinting = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setShouldStayOnPageAfterHandlingBeforeUnload(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() == 1 && arguments[0].isBool())
|
| + m_shouldStayOnPageAfterHandlingBeforeUnload = arguments[0].toBoolean();
|
| +
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setWillSendRequestClearHeader(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isString()) {
|
| + string header = arguments[0].toString();
|
| + if (!header.empty())
|
| + m_httpHeadersToClear.insert(header);
|
| + }
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setTabKeyCyclesThroughElements(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool())
|
| + m_webView->setTabKeyCyclesThroughElements(arguments[0].toBoolean());
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::execCommand(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() <= 0 || !arguments[0].isString())
|
| + return;
|
| +
|
| + std::string command = arguments[0].toString();
|
| + std::string value("");
|
| + // Ignore the second parameter (which is userInterface)
|
| + // since this command emulates a manual action.
|
| + if (arguments.size() >= 3 && arguments[2].isString())
|
| + value = arguments[2].toString();
|
| +
|
| + // Note: webkit's version does not return the boolean, so neither do we.
|
| + m_webView->focusedFrame()->executeCommand(WebString::fromUTF8(command), WebString::fromUTF8(value));
|
| +}
|
| +
|
| +void TestRunner::isCommandEnabled(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() <= 0 || !arguments[0].isString()) {
|
| + result->setNull();
|
| + return;
|
| + }
|
| +
|
| + std::string command = arguments[0].toString();
|
| + bool rv = m_webView->focusedFrame()->isCommandEnabled(WebString::fromUTF8(command));
|
| + result->set(rv);
|
| +}
|
| +
|
| +void TestRunner::callShouldCloseOnWebView(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + result->set(m_webView->dispatchBeforeUnloadEvent());
|
| +}
|
| +
|
| +void TestRunner::setDomainRelaxationForbiddenForURLScheme(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() != 2 || !arguments[0].isBool() || !arguments[1].isString())
|
| + return;
|
| + m_webView->setDomainRelaxationForbidden(cppVariantToBool(arguments[0]), cppVariantToWebString(arguments[1]));
|
| +}
|
| +
|
| +void TestRunner::evaluateScriptInIsolatedWorldAndReturnValue(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + v8::HandleScope scope(v8::Isolate::GetCurrent());
|
| + WebVector<v8::Local<v8::Value> > values;
|
| + if (arguments.size() >= 2 && arguments[0].isNumber() && arguments[1].isString()) {
|
| + WebScriptSource source(cppVariantToWebString(arguments[1]));
|
| + // This relies on the iframe focusing itself when it loads. This is a bit
|
| + // sketchy, but it seems to be what other tests do.
|
| + m_webView->focusedFrame()->executeScriptInIsolatedWorld(arguments[0].toInt32(), &source, 1, 1, &values);
|
| + }
|
| + result->setNull();
|
| + // Since only one script was added, only one result is expected
|
| + if (values.size() == 1 && !values[0].IsEmpty()) {
|
| + v8::Local<v8::Value> scriptValue = values[0];
|
| + // FIXME: There are many more types that can be handled.
|
| + if (scriptValue->IsString()) {
|
| + v8::String::Utf8Value utf8V8(scriptValue);
|
| + result->set(std::string(*utf8V8));
|
| + } else if (scriptValue->IsBoolean())
|
| + result->set(scriptValue->ToBoolean()->Value());
|
| + else if (scriptValue->IsNumber()) {
|
| + if (scriptValue->IsInt32())
|
| + result->set(scriptValue->ToInt32()->Value());
|
| + else
|
| + result->set(scriptValue->ToNumber()->Value());
|
| + } else if (scriptValue->IsNull())
|
| + result->setNull();
|
| + }
|
| +}
|
| +
|
| +void TestRunner::evaluateScriptInIsolatedWorld(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() >= 2 && arguments[0].isNumber() && arguments[1].isString()) {
|
| + WebScriptSource source(cppVariantToWebString(arguments[1]));
|
| + // This relies on the iframe focusing itself when it loads. This is a bit
|
| + // sketchy, but it seems to be what other tests do.
|
| + m_webView->focusedFrame()->executeScriptInIsolatedWorld(arguments[0].toInt32(), &source, 1, 1);
|
| + }
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setIsolatedWorldSecurityOrigin(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| +
|
| + if (arguments.size() != 2 || !arguments[0].isNumber() || !(arguments[1].isString() || arguments[1].isNull()))
|
| + return;
|
| +
|
| + WebSecurityOrigin origin;
|
| + if (arguments[1].isString())
|
| + origin = WebSecurityOrigin::createFromString(cppVariantToWebString(arguments[1]));
|
| + m_webView->focusedFrame()->setIsolatedWorldSecurityOrigin(arguments[0].toInt32(), origin);
|
| +}
|
| +
|
| +void TestRunner::setIsolatedWorldContentSecurityPolicy(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| +
|
| + if (arguments.size() != 2 || !arguments[0].isNumber() || !arguments[1].isString())
|
| + return;
|
| +
|
| + m_webView->focusedFrame()->setIsolatedWorldContentSecurityPolicy(arguments[0].toInt32(), cppVariantToWebString(arguments[1]));
|
| +}
|
| +
|
| +void TestRunner::addOriginAccessWhitelistEntry(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| +
|
| + if (arguments.size() != 4 || !arguments[0].isString() || !arguments[1].isString()
|
| + || !arguments[2].isString() || !arguments[3].isBool())
|
| + return;
|
| +
|
| + blink::WebURL url(GURL(arguments[0].toString()));
|
| + if (!url.isValid())
|
| + return;
|
| +
|
| + WebSecurityPolicy::addOriginAccessWhitelistEntry(
|
| + url,
|
| + cppVariantToWebString(arguments[1]),
|
| + cppVariantToWebString(arguments[2]),
|
| + arguments[3].toBoolean());
|
| +}
|
| +
|
| +void TestRunner::removeOriginAccessWhitelistEntry(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| +
|
| + if (arguments.size() != 4 || !arguments[0].isString() || !arguments[1].isString()
|
| + || !arguments[2].isString() || !arguments[3].isBool())
|
| + return;
|
| +
|
| + blink::WebURL url(GURL(arguments[0].toString()));
|
| + if (!url.isValid())
|
| + return;
|
| +
|
| + WebSecurityPolicy::removeOriginAccessWhitelistEntry(
|
| + url,
|
| + cppVariantToWebString(arguments[1]),
|
| + cppVariantToWebString(arguments[2]),
|
| + arguments[3].toBoolean());
|
| +}
|
| +
|
| +void TestRunner::hasCustomPageSizeStyle(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->set(false);
|
| + int pageIndex = 0;
|
| + if (arguments.size() > 1)
|
| + return;
|
| + if (arguments.size() == 1)
|
| + pageIndex = cppVariantToInt32(arguments[0]);
|
| + WebFrame* frame = m_webView->mainFrame();
|
| + if (!frame)
|
| + return;
|
| + result->set(frame->hasCustomPageSizeStyle(pageIndex));
|
| +}
|
| +
|
| +void TestRunner::forceRedSelectionColors(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + m_webView->setSelectionColors(0xffee0000, 0xff00ee00, 0xff000000, 0xffc0c0c0);
|
| +}
|
| +
|
| +void TestRunner::injectStyleSheet(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() < 2 || !arguments[0].isString() || !arguments[1].isBool())
|
| + return;
|
| + WebView::injectStyleSheet(
|
| + cppVariantToWebString(arguments[0]), WebVector<WebString>(),
|
| + arguments[1].toBoolean() ? WebView::InjectStyleInAllFrames : WebView::InjectStyleInTopFrameOnly);
|
| +}
|
| +
|
| +void TestRunner::startSpeechInput(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() != 1)
|
| + return;
|
| +
|
| + WebElement element;
|
| + if (!WebBindings::getElement(arguments[0].value.objectValue, &element))
|
| + return;
|
| +
|
| + WebInputElement* input = toWebInputElement(&element);
|
| + if (!input)
|
| + return;
|
| +
|
| + if (!input->isSpeechInputEnabled())
|
| + return;
|
| +
|
| + input->startSpeechInput();
|
| +}
|
| +
|
| +void TestRunner::findString(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() < 1 || !arguments[0].isString())
|
| + return;
|
| +
|
| + WebFindOptions findOptions;
|
| + bool wrapAround = false;
|
| + if (arguments.size() >= 2) {
|
| + vector<string> optionsArray = arguments[1].toStringVector();
|
| + findOptions.matchCase = true;
|
| + findOptions.findNext = true;
|
| +
|
| + for (size_t i = 0; i < optionsArray.size(); ++i) {
|
| + const std::string& option = optionsArray[i];
|
| + if (option == "CaseInsensitive")
|
| + findOptions.matchCase = false;
|
| + else if (option == "Backwards")
|
| + findOptions.forward = false;
|
| + else if (option == "StartInSelection")
|
| + findOptions.findNext = false;
|
| + else if (option == "AtWordStarts")
|
| + findOptions.wordStart = true;
|
| + else if (option == "TreatMedialCapitalAsWordStart")
|
| + findOptions.medialCapitalAsWordStart = true;
|
| + else if (option == "WrapAround")
|
| + wrapAround = true;
|
| + }
|
| + }
|
| +
|
| + WebFrame* frame = m_webView->mainFrame();
|
| + const bool findResult = frame->find(0, cppVariantToWebString(arguments[0]), findOptions, wrapAround, 0);
|
| + frame->stopFinding(false);
|
| + result->set(findResult);
|
| +}
|
| +
|
| +void TestRunner::setValueForUser(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() != 2)
|
| + return;
|
| +
|
| + WebElement element;
|
| + if (!WebBindings::getElement(arguments[0].value.objectValue, &element))
|
| + return;
|
| +
|
| + WebInputElement* input = toWebInputElement(&element);
|
| + if (!input)
|
| + return;
|
| +
|
| + input->setValue(cppVariantToWebString(arguments[1]), true);
|
| +}
|
| +
|
| +void TestRunner::selectionAsMarkup(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->set(m_webView->mainFrame()->selectionAsMarkup().utf8());
|
| +}
|
| +
|
| +void TestRunner::setTextSubpixelPositioning(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| +#if defined(__linux__) || defined(ANDROID)
|
| + // Since FontConfig doesn't provide a variable to control subpixel positioning, we'll fall back
|
| + // to setting it globally for all fonts.
|
| + if (arguments.size() > 0 && arguments[0].isBool())
|
| + WebFontRendering::setSubpixelPositioning(arguments[0].value.boolValue);
|
| +#endif
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setPageVisibility(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isString()) {
|
| + string newVisibility = arguments[0].toString();
|
| + if (newVisibility == "visible")
|
| + m_webView->setVisibilityState(WebPageVisibilityStateVisible, false);
|
| + else if (newVisibility == "hidden")
|
| + m_webView->setVisibilityState(WebPageVisibilityStateHidden, false);
|
| + else if (newVisibility == "prerender")
|
| + m_webView->setVisibilityState(WebPageVisibilityStatePrerender, false);
|
| + }
|
| +}
|
| +
|
| +void TestRunner::setTextDirection(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() != 1 || !arguments[0].isString())
|
| + return;
|
| +
|
| + // Map a direction name to a WebTextDirection value.
|
| + std::string directionName = arguments[0].toString();
|
| + blink::WebTextDirection direction;
|
| + if (directionName == "auto")
|
| + direction = blink::WebTextDirectionDefault;
|
| + else if (directionName == "rtl")
|
| + direction = blink::WebTextDirectionRightToLeft;
|
| + else if (directionName == "ltr")
|
| + direction = blink::WebTextDirectionLeftToRight;
|
| + else
|
| + return;
|
| +
|
| + m_webView->setTextDirection(direction);
|
| +}
|
| +
|
| +void TestRunner::textSurroundingNode(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() < 4 || !arguments[0].isObject() || !arguments[1].isNumber() || !arguments[2].isNumber() || !arguments[3].isNumber())
|
| + return;
|
| +
|
| + WebNode node;
|
| + if (!WebBindings::getNode(arguments[0].value.objectValue, &node))
|
| + return;
|
| +
|
| + if (node.isNull() || !node.isTextNode())
|
| + return;
|
| +
|
| + WebPoint point(arguments[1].toInt32(), arguments[2].toInt32());
|
| + unsigned maxLength = arguments[3].toInt32();
|
| +
|
| + WebSurroundingText surroundingText;
|
| + surroundingText.initialize(node, point, maxLength);
|
| + if (surroundingText.isNull())
|
| + return;
|
| +
|
| + result->set(surroundingText.textContent().utf8());
|
| +}
|
| +
|
| +void TestRunner::dumpResourceRequestPriorities(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + m_shouldDumpResourcePriorities = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::useUnfortunateSynchronousResizeMode(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + m_delegate->useUnfortunateSynchronousResizeMode(true);
|
| +}
|
| +
|
| +void TestRunner::enableAutoResizeMode(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() != 4) {
|
| + result->set(false);
|
| + return;
|
| + }
|
| + int minWidth = cppVariantToInt32(arguments[0]);
|
| + int minHeight = cppVariantToInt32(arguments[1]);
|
| + blink::WebSize minSize(minWidth, minHeight);
|
| +
|
| + int maxWidth = cppVariantToInt32(arguments[2]);
|
| + int maxHeight = cppVariantToInt32(arguments[3]);
|
| + blink::WebSize maxSize(maxWidth, maxHeight);
|
| +
|
| + m_delegate->enableAutoResizeMode(minSize, maxSize);
|
| + result->set(true);
|
| +}
|
| +
|
| +void TestRunner::disableAutoResizeMode(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() !=2) {
|
| + result->set(false);
|
| + return;
|
| + }
|
| + int newWidth = cppVariantToInt32(arguments[0]);
|
| + int newHeight = cppVariantToInt32(arguments[1]);
|
| + blink::WebSize newSize(newWidth, newHeight);
|
| +
|
| + m_delegate->disableAutoResizeMode(newSize);
|
| + result->set(true);
|
| +}
|
| +
|
| +void TestRunner::setMockDeviceMotion(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() < 19
|
| + || !arguments[0].isBool() || !arguments[1].isNumber() // acceleration.x
|
| + || !arguments[2].isBool() || !arguments[3].isNumber() // acceleration.y
|
| + || !arguments[4].isBool() || !arguments[5].isNumber() // acceleration.z
|
| + || !arguments[6].isBool() || !arguments[7].isNumber() // accelerationIncludingGravity.x
|
| + || !arguments[8].isBool() || !arguments[9].isNumber() // accelerationIncludingGravity.y
|
| + || !arguments[10].isBool() || !arguments[11].isNumber() // accelerationIncludingGravity.z
|
| + || !arguments[12].isBool() || !arguments[13].isNumber() // rotationRate.alpha
|
| + || !arguments[14].isBool() || !arguments[15].isNumber() // rotationRate.beta
|
| + || !arguments[16].isBool() || !arguments[17].isNumber() // rotationRate.gamma
|
| + || !arguments[18].isNumber()) // interval
|
| + return;
|
| +
|
| + WebDeviceMotionData motion;
|
| +
|
| + // acceleration
|
| + motion.hasAccelerationX = arguments[0].toBoolean();
|
| + motion.accelerationX = arguments[1].toDouble();
|
| + motion.hasAccelerationY = arguments[2].toBoolean();
|
| + motion.accelerationY = arguments[3].toDouble();
|
| + motion.hasAccelerationZ = arguments[4].toBoolean();
|
| + motion.accelerationZ = arguments[5].toDouble();
|
| +
|
| + // accelerationIncludingGravity
|
| + motion.hasAccelerationIncludingGravityX = arguments[6].toBoolean();
|
| + motion.accelerationIncludingGravityX = arguments[7].toDouble();
|
| + motion.hasAccelerationIncludingGravityY = arguments[8].toBoolean();
|
| + motion.accelerationIncludingGravityY = arguments[9].toDouble();
|
| + motion.hasAccelerationIncludingGravityZ = arguments[10].toBoolean();
|
| + motion.accelerationIncludingGravityZ = arguments[11].toDouble();
|
| +
|
| + // rotationRate
|
| + motion.hasRotationRateAlpha = arguments[12].toBoolean();
|
| + motion.rotationRateAlpha = arguments[13].toDouble();
|
| + motion.hasRotationRateBeta = arguments[14].toBoolean();
|
| + motion.rotationRateBeta = arguments[15].toDouble();
|
| + motion.hasRotationRateGamma = arguments[16].toBoolean();
|
| + motion.rotationRateGamma = arguments[17].toDouble();
|
| +
|
| + // interval
|
| + motion.interval = arguments[18].toDouble();
|
| +
|
| + m_delegate->setDeviceMotionData(motion);
|
| +}
|
| +
|
| +void TestRunner::setMockDeviceOrientation(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() < 8
|
| + || !arguments[0].isBool() || !arguments[1].isNumber() // alpha
|
| + || !arguments[2].isBool() || !arguments[3].isNumber() // beta
|
| + || !arguments[4].isBool() || !arguments[5].isNumber() // gamma
|
| + || !arguments[6].isBool() || !arguments[7].isBool()) // absolute
|
| + return;
|
| +
|
| + WebDeviceOrientationData orientation;
|
| +
|
| + // alpha
|
| + orientation.hasAlpha = arguments[0].toBoolean();
|
| + orientation.alpha = arguments[1].toDouble();
|
| +
|
| + // beta
|
| + orientation.hasBeta = arguments[2].toBoolean();
|
| + orientation.beta = arguments[3].toDouble();
|
| +
|
| + // gamma
|
| + orientation.hasGamma = arguments[4].toBoolean();
|
| + orientation.gamma = arguments[5].toDouble();
|
| +
|
| + // absolute
|
| + orientation.hasAbsolute = arguments[6].toBoolean();
|
| + orientation.absolute = arguments[7].toBoolean();
|
| +
|
| + m_delegate->setDeviceOrientationData(orientation);
|
| +}
|
| +
|
| +void TestRunner::setPopupBlockingEnabled(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool()) {
|
| + bool blockPopups = arguments[0].toBoolean();
|
| + m_delegate->preferences()->javaScriptCanOpenWindowsAutomatically = !blockPopups;
|
| + m_delegate->applyPreferences();
|
| + }
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setJavaScriptCanAccessClipboard(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool()) {
|
| + m_delegate->preferences()->javaScriptCanAccessClipboard = arguments[0].value.boolValue;
|
| + m_delegate->applyPreferences();
|
| + }
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setXSSAuditorEnabled(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool()) {
|
| + m_delegate->preferences()->XSSAuditorEnabled = arguments[0].value.boolValue;
|
| + m_delegate->applyPreferences();
|
| + }
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setAllowUniversalAccessFromFileURLs(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool()) {
|
| + m_delegate->preferences()->allowUniversalAccessFromFileURLs = arguments[0].value.boolValue;
|
| + m_delegate->applyPreferences();
|
| + }
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setAllowFileAccessFromFileURLs(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool()) {
|
| + m_delegate->preferences()->allowFileAccessFromFileURLs = arguments[0].value.boolValue;
|
| + m_delegate->applyPreferences();
|
| + }
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::overridePreference(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() != 2 || !arguments[0].isString())
|
| + return;
|
| +
|
| + string key = arguments[0].toString();
|
| + CppVariant value = arguments[1];
|
| + WebPreferences* prefs = m_delegate->preferences();
|
| + if (key == "WebKitDefaultFontSize")
|
| + prefs->defaultFontSize = cppVariantToInt32(value);
|
| + else if (key == "WebKitMinimumFontSize")
|
| + prefs->minimumFontSize = cppVariantToInt32(value);
|
| + else if (key == "WebKitDefaultTextEncodingName")
|
| + prefs->defaultTextEncodingName = cppVariantToWebString(value);
|
| + else if (key == "WebKitJavaScriptEnabled")
|
| + prefs->javaScriptEnabled = cppVariantToBool(value);
|
| + else if (key == "WebKitSupportsMultipleWindows")
|
| + prefs->supportsMultipleWindows = cppVariantToBool(value);
|
| + else if (key == "WebKitDisplayImagesKey")
|
| + prefs->loadsImagesAutomatically = cppVariantToBool(value);
|
| + else if (key == "WebKitPluginsEnabled")
|
| + prefs->pluginsEnabled = cppVariantToBool(value);
|
| + else if (key == "WebKitJavaEnabled")
|
| + prefs->javaEnabled = cppVariantToBool(value);
|
| + else if (key == "WebKitOfflineWebApplicationCacheEnabled")
|
| + prefs->offlineWebApplicationCacheEnabled = cppVariantToBool(value);
|
| + else if (key == "WebKitTabToLinksPreferenceKey")
|
| + prefs->tabsToLinks = cppVariantToBool(value);
|
| + else if (key == "WebKitWebGLEnabled")
|
| + prefs->experimentalWebGLEnabled = cppVariantToBool(value);
|
| + else if (key == "WebKitCSSRegionsEnabled")
|
| + prefs->experimentalCSSRegionsEnabled = cppVariantToBool(value);
|
| + else if (key == "WebKitCSSGridLayoutEnabled")
|
| + prefs->experimentalCSSGridLayoutEnabled = cppVariantToBool(value);
|
| + else if (key == "WebKitHyperlinkAuditingEnabled")
|
| + prefs->hyperlinkAuditingEnabled = cppVariantToBool(value);
|
| + else if (key == "WebKitEnableCaretBrowsing")
|
| + prefs->caretBrowsingEnabled = cppVariantToBool(value);
|
| + else if (key == "WebKitAllowDisplayingInsecureContent")
|
| + prefs->allowDisplayOfInsecureContent = cppVariantToBool(value);
|
| + else if (key == "WebKitAllowRunningInsecureContent")
|
| + prefs->allowRunningOfInsecureContent = cppVariantToBool(value);
|
| + else if (key == "WebKitCSSCustomFilterEnabled")
|
| + prefs->cssCustomFilterEnabled = cppVariantToBool(value);
|
| + else if (key == "WebKitShouldRespectImageOrientation")
|
| + prefs->shouldRespectImageOrientation = cppVariantToBool(value);
|
| + else if (key == "WebKitWebAudioEnabled")
|
| + BLINK_ASSERT(cppVariantToBool(value));
|
| + else {
|
| + string message("Invalid name for preference: ");
|
| + message.append(key);
|
| + printErrorMessage(message);
|
| + }
|
| + m_delegate->applyPreferences();
|
| +}
|
| +
|
| +void TestRunner::setPluginsEnabled(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool()) {
|
| + m_delegate->preferences()->pluginsEnabled = arguments[0].toBoolean();
|
| + m_delegate->applyPreferences();
|
| + }
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::showWebInspector(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + showDevTools();
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::closeWebInspector(const CppArgumentList& args, CppVariant* result)
|
| +{
|
| + m_delegate->closeDevTools();
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::isChooserShown(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + result->set(m_proxy->isChooserShown());
|
| +}
|
| +
|
| +void TestRunner::evaluateInWebInspector(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() < 2 || !arguments[0].isNumber() || !arguments[1].isString())
|
| + return;
|
| + m_delegate->evaluateInWebInspector(arguments[0].toInt32(), arguments[1].toString());
|
| +}
|
| +
|
| +void TestRunner::clearAllDatabases(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + m_delegate->clearAllDatabases();
|
| +}
|
| +
|
| +void TestRunner::setDatabaseQuota(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if ((arguments.size() >= 1) && arguments[0].isNumber())
|
| + m_delegate->setDatabaseQuota(arguments[0].toInt32());
|
| +}
|
| +
|
| +void TestRunner::setAlwaysAcceptCookies(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0)
|
| + m_delegate->setAcceptAllCookies(cppVariantToBool(arguments[0]));
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setWindowIsKey(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() > 0 && arguments[0].isBool())
|
| + m_delegate->setFocus(m_proxy, arguments[0].value.boolValue);
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::pathToLocalResource(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() <= 0 || !arguments[0].isString())
|
| + return;
|
| +
|
| + result->set(m_delegate->pathToLocalResource(arguments[0].toString()));
|
| +}
|
| +
|
| +void TestRunner::setBackingScaleFactor(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() < 2 || !arguments[0].isNumber() || !arguments[1].isObject())
|
| + return;
|
| +
|
| + float value = arguments[0].value.doubleValue;
|
| + m_delegate->setDeviceScaleFactor(value);
|
| + m_proxy->discardBackingStore();
|
| +
|
| + WebScopedPtr<CppVariant> callbackArguments(new CppVariant());
|
| + callbackArguments->set(arguments[1]);
|
| + result->setNull();
|
| + m_delegate->postTask(new InvokeCallbackTask(this, callbackArguments));
|
| +}
|
| +
|
| +void TestRunner::setPOSIXLocale(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() == 1 && arguments[0].isString())
|
| + m_delegate->setLocale(arguments[0].toString());
|
| +}
|
| +
|
| +void TestRunner::numberOfPendingGeolocationPermissionRequests(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->set(m_proxy->geolocationClientMock()->numberOfPendingPermissionRequests());
|
| +}
|
| +
|
| +// FIXME: For greater test flexibility, we should be able to set each page's geolocation mock individually.
|
| +// https://bugs.webkit.org/show_bug.cgi?id=52368
|
| +void TestRunner::setGeolocationPermission(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() < 1 || !arguments[0].isBool())
|
| + return;
|
| + const vector<WebTestProxyBase*>& windowList = m_testInterfaces->windowList();
|
| + for (unsigned i = 0; i < windowList.size(); ++i)
|
| + windowList.at(i)->geolocationClientMock()->setPermission(arguments[0].toBoolean());
|
| +}
|
| +
|
| +void TestRunner::setMockGeolocationPosition(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() < 3 || !arguments[0].isNumber() || !arguments[1].isNumber() || !arguments[2].isNumber())
|
| + return;
|
| + const vector<WebTestProxyBase*>& windowList = m_testInterfaces->windowList();
|
| + for (unsigned i = 0; i < windowList.size(); ++i)
|
| + windowList.at(i)->geolocationClientMock()->setPosition(arguments[0].toDouble(), arguments[1].toDouble(), arguments[2].toDouble());
|
| +}
|
| +
|
| +void TestRunner::setMockGeolocationPositionUnavailableError(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() != 1 || !arguments[0].isString())
|
| + return;
|
| + const vector<WebTestProxyBase*>& windowList = m_testInterfaces->windowList();
|
| + for (unsigned i = 0; i < windowList.size(); ++i)
|
| + windowList.at(i)->geolocationClientMock()->setPositionUnavailableError(WebString::fromUTF8(arguments[0].toString()));
|
| +}
|
| +
|
| +void TestRunner::setMIDIAccessorResult(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() < 1 || !arguments[0].isBool())
|
| + return;
|
| + m_midiAccessorResult = arguments[0].toBoolean();
|
| +}
|
| +
|
| +void TestRunner::setMIDISysExPermission(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() < 1 || !arguments[0].isBool())
|
| + return;
|
| + const vector<WebTestProxyBase*>& windowList = m_testInterfaces->windowList();
|
| + for (unsigned i = 0; i < windowList.size(); ++i)
|
| + windowList.at(i)->midiClientMock()->setSysExPermission(arguments[0].toBoolean());
|
| +}
|
| +
|
| +void TestRunner::grantWebNotificationPermission(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() != 1 || !arguments[0].isString()) {
|
| + result->set(false);
|
| + return;
|
| + }
|
| + m_notificationPresenter->grantPermission(WebString::fromUTF8(arguments[0].toString()));
|
| + result->set(true);
|
| +}
|
| +
|
| +void TestRunner::simulateLegacyWebNotificationClick(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + if (arguments.size() != 1 || !arguments[0].isString()) {
|
| + result->set(false);
|
| + return;
|
| + }
|
| + result->set(m_notificationPresenter->simulateClick(WebString::fromUTF8(arguments[0].toString())));
|
| +}
|
| +
|
| +void TestRunner::cancelAllActiveNotifications(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + m_notificationPresenter->cancelAllActiveNotifications();
|
| + result->set(true);
|
| +}
|
| +
|
| +void TestRunner::addMockSpeechInputResult(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() < 3 || !arguments[0].isString() || !arguments[1].isNumber() || !arguments[2].isString())
|
| + return;
|
| +
|
| +#if ENABLE_INPUT_SPEECH
|
| + m_proxy->speechInputControllerMock()->addMockRecognitionResult(WebString::fromUTF8(arguments[0].toString()), arguments[1].toDouble(), WebString::fromUTF8(arguments[2].toString()));
|
| +#endif
|
| +}
|
| +
|
| +void TestRunner::setMockSpeechInputDumpRect(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() < 1 || !arguments[0].isBool())
|
| + return;
|
| +
|
| +#if ENABLE_INPUT_SPEECH
|
| + m_proxy->speechInputControllerMock()->setDumpRect(arguments[0].toBoolean());
|
| +#endif
|
| +}
|
| +
|
| +void TestRunner::addMockSpeechRecognitionResult(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() < 2 || !arguments[0].isString() || !arguments[1].isNumber())
|
| + return;
|
| +
|
| + m_proxy->speechRecognizerMock()->addMockResult(WebString::fromUTF8(arguments[0].toString()), arguments[1].toDouble());
|
| +}
|
| +
|
| +void TestRunner::setMockSpeechRecognitionError(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| + if (arguments.size() != 2 || !arguments[0].isString() || !arguments[1].isString())
|
| + return;
|
| +
|
| + m_proxy->speechRecognizerMock()->setError(WebString::fromUTF8(arguments[0].toString()), WebString::fromUTF8(arguments[1].toString()));
|
| +}
|
| +
|
| +void TestRunner::wasMockSpeechRecognitionAborted(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + result->set(m_proxy->speechRecognizerMock()->wasAborted());
|
| +}
|
| +
|
| +void TestRunner::addWebPageOverlay(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + if (m_webView && !m_pageOverlay) {
|
| + m_pageOverlay = new TestPageOverlay(m_webView);
|
| + m_webView->addPageOverlay(m_pageOverlay, 0);
|
| + }
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::removeWebPageOverlay(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + if (m_webView && m_pageOverlay) {
|
| + m_webView->removePageOverlay(m_pageOverlay);
|
| + delete m_pageOverlay;
|
| + m_pageOverlay = 0;
|
| + }
|
| +
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::display(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + m_proxy->display();
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::displayInvalidatedRegion(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + m_proxy->displayInvalidatedRegion();
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpEditingCallbacks(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpEditingCallbacks = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpAsText(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpAsText = true;
|
| + m_generatePixelResults = false;
|
| +
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpAsTextWithPixelResults(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpAsText = true;
|
| + m_generatePixelResults = true;
|
| +
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpChildFrameScrollPositions(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpChildFrameScrollPositions = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpChildFramesAsText(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpChildFramesAsText = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpIconChanges(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpIconChanges = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setAudioData(const CppArgumentList& arguments, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| +
|
| + if (arguments.size() < 1 || !arguments[0].isObject())
|
| + return;
|
| +
|
| + // Check that passed-in object is, in fact, an ArrayBufferView.
|
| + NPObject* npobject = NPVARIANT_TO_OBJECT(arguments[0]);
|
| + if (!npobject)
|
| + return;
|
| + if (!WebBindings::getArrayBufferView(npobject, &m_audioData))
|
| + return;
|
| +
|
| + m_dumpAsAudio = true;
|
| +}
|
| +
|
| +void TestRunner::dumpFrameLoadCallbacks(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpFrameLoadCallbacks = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpPingLoaderCallbacks(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpPingLoaderCallbacks = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpUserGestureInFrameLoadCallbacks(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpUserGestureInFrameLoadCallbacks = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpTitleChanges(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpTitleChanges = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpCreateView(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpCreateView = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setCanOpenWindows(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_canOpenWindows = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpResourceLoadCallbacks(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpResourceLoadCallbacks = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpResourceRequestCallbacks(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpResourceRequestCallbacks = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::dumpResourceResponseMIMETypes(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_dumpResourceResponseMIMETypes = true;
|
| + result->setNull();
|
| +}
|
| +
|
| +// Need these conversions because the format of the value for booleans
|
| +// may vary - for example, on mac "1" and "0" are used for boolean.
|
| +bool TestRunner::cppVariantToBool(const CppVariant& value)
|
| +{
|
| + if (value.isBool())
|
| + return value.toBoolean();
|
| + if (value.isNumber())
|
| + return value.toInt32() != 0;
|
| + if (value.isString()) {
|
| + string valueString = value.toString();
|
| + if (valueString == "true" || valueString == "1")
|
| + return true;
|
| + if (valueString == "false" || valueString == "0")
|
| + return false;
|
| + }
|
| + printErrorMessage("Invalid value. Expected boolean value.");
|
| + return false;
|
| +}
|
| +
|
| +int32_t TestRunner::cppVariantToInt32(const CppVariant& value)
|
| +{
|
| + if (value.isNumber())
|
| + return value.toInt32();
|
| + if (value.isString()) {
|
| + string stringSource = value.toString();
|
| + const char* source = stringSource.data();
|
| + char* end;
|
| + long number = strtol(source, &end, 10);
|
| + if (end == source + stringSource.length() && number >= numeric_limits<int32_t>::min() && number <= numeric_limits<int32_t>::max())
|
| + return static_cast<int32_t>(number);
|
| + }
|
| + printErrorMessage("Invalid value for preference. Expected integer value.");
|
| + return 0;
|
| +}
|
| +
|
| +WebString TestRunner::cppVariantToWebString(const CppVariant& value)
|
| +{
|
| + if (!value.isString()) {
|
| + printErrorMessage("Invalid value for preference. Expected string value.");
|
| + return WebString();
|
| + }
|
| + return WebString::fromUTF8(value.toString());
|
| +}
|
| +
|
| +void TestRunner::printErrorMessage(const string& text)
|
| +{
|
| + m_delegate->printMessage(string("CONSOLE MESSAGE: ") + text + "\n");
|
| +}
|
| +
|
| +void TestRunner::fallbackMethod(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + printErrorMessage("JavaScript ERROR: unknown method called on TestRunner");
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::notImplemented(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::didAcquirePointerLock(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + didAcquirePointerLockInternal();
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::didNotAcquirePointerLock(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + didNotAcquirePointerLockInternal();
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::didLosePointerLock(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + didLosePointerLockInternal();
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setPointerLockWillRespondAsynchronously(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_pointerLockPlannedResult = PointerLockWillRespondAsync;
|
| + result->setNull();
|
| +}
|
| +
|
| +void TestRunner::setPointerLockWillFailSynchronously(const CppArgumentList&, CppVariant* result)
|
| +{
|
| + m_pointerLockPlannedResult = PointerLockWillFailSync;
|
| + result->setNull();
|
| +}
|
| +
|
| +}
|
|
|
Chromium Code Reviews
Issue 110533009:
Import TestRunner library into chromium. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src