components/test_runner/test_runner.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/test_runner/test_runner.h"
   6
   7 #include <limits>
   8
   9 #include "base/logging.h"
  10 #include "components/test_runner/mock_credential_manager_client.h"
  11 #include "components/test_runner/mock_web_speech_recognizer.h"
  12 #include "components/test_runner/test_interfaces.h"
  13 #include "components/test_runner/test_preferences.h"
  14 #include "components/test_runner/web_content_settings.h"
  15 #include "components/test_runner/web_test_delegate.h"
  16 #include "components/test_runner/web_test_proxy.h"
  17 #include "gin/arguments.h"
  18 #include "gin/array_buffer.h"
  19 #include "gin/handle.h"
  20 #include "gin/object_template_builder.h"
  21 #include "gin/wrappable.h"
  22 #include "third_party/WebKit/public/platform/WebBatteryStatus.h"
  23 #include "third_party/WebKit/public/platform/WebCanvas.h"
  24 #include "third_party/WebKit/public/platform/WebData.h"
  25 #include "third_party/WebKit/public/platform/WebPasswordCredential.h"
  26 #include "third_party/WebKit/public/platform/WebPoint.h"
  27 #include "third_party/WebKit/public/platform/WebServiceWorkerRegistration.h"
  28 #include "third_party/WebKit/public/platform/WebURLResponse.h"
  29 #include "third_party/WebKit/public/platform/modules/device_orientation/WebDeviceMotionData.h"
  30 #include "third_party/WebKit/public/platform/modules/device_orientation/WebDeviceOrientationData.h"
  31 #include "third_party/WebKit/public/web/WebArrayBuffer.h"
  32 #include "third_party/WebKit/public/web/WebArrayBufferConverter.h"
  33 #include "third_party/WebKit/public/web/WebBindings.h"
  34 #include "third_party/WebKit/public/web/WebDataSource.h"
  35 #include "third_party/WebKit/public/web/WebDocument.h"
  36 #include "third_party/WebKit/public/web/WebFindOptions.h"
  37 #include "third_party/WebKit/public/web/WebFrame.h"
  38 #include "third_party/WebKit/public/web/WebGraphicsContext.h"
  39 #include "third_party/WebKit/public/web/WebInputElement.h"
  40 #include "third_party/WebKit/public/web/WebKit.h"
  41 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  42 #include "third_party/WebKit/public/web/WebPageOverlay.h"
  43 #include "third_party/WebKit/public/web/WebScriptSource.h"
  44 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
  45 #include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
  46 #include "third_party/WebKit/public/web/WebSettings.h"
  47 #include "third_party/WebKit/public/web/WebSurroundingText.h"
  48 #include "third_party/WebKit/public/web/WebView.h"
  49 #include "third_party/skia/include/core/SkBitmap.h"
  50 #include "third_party/skia/include/core/SkCanvas.h"
  51 #include "ui/gfx/geometry/rect.h"
  52 #include "ui/gfx/geometry/rect_f.h"
  53 #include "ui/gfx/geometry/size.h"
  54 #include "ui/gfx/skia_util.h"
  55
  56 #if defined(__linux__) || defined(ANDROID)
  57 #include "third_party/WebKit/public/web/linux/WebFontRendering.h"
  58 #endif
  59
  60 using namespace blink;
  61
  62 namespace test_runner {
  63
  64 namespace {
  65
  66 WebString V8StringToWebString(v8::Local<v8::String> v8_str) {
  67   int length = v8_str->Utf8Length() + 1;
  68   scoped_ptr<char[]> chars(new char[length]);
  69   v8_str->WriteUtf8(chars.get(), length);
  70   return WebString::fromUTF8(chars.get());
  71 }
  72
  73 class HostMethodTask : public WebMethodTask<TestRunner> {
  74  public:
  75   typedef void (TestRunner::*CallbackMethodType)();
  76   HostMethodTask(TestRunner* object, CallbackMethodType callback)
  77       : WebMethodTask<TestRunner>(object), callback_(callback) {}
  78
  79   void RunIfValid() override { (object_->*callback_)(); }
  80
  81  private:
  82   CallbackMethodType callback_;
  83 };
  84
  85 }  // namespace
  86
  87 class InvokeCallbackTask : public WebMethodTask<TestRunner> {
  88  public:
  89   InvokeCallbackTask(TestRunner* object, v8::Local<v8::Function> callback)
  90       : WebMethodTask<TestRunner>(object),
  91         callback_(blink::mainThreadIsolate(), callback),
  92         argc_(0) {}
  93
  94   void RunIfValid() override {
  95     v8::Isolate* isolate = blink::mainThreadIsolate();
  96     v8::HandleScope handle_scope(isolate);
  97     WebFrame* frame = object_->web_view_->mainFrame();
  98
  99     v8::Local<v8::Context> context = frame->mainWorldScriptContext();
 100     if (context.IsEmpty())
 101       return;
 102
 103     v8::Context::Scope context_scope(context);
 104
 105     scoped_ptr<v8::Local<v8::Value>[]> local_argv;
 106     if (argc_) {
 107         local_argv.reset(new v8::Local<v8::Value>[argc_]);
 108         for (int i = 0; i < argc_; ++i)
 109           local_argv[i] = v8::Local<v8::Value>::New(isolate, argv_[i]);
 110     }
 111
 112     frame->callFunctionEvenIfScriptDisabled(
 113         v8::Local<v8::Function>::New(isolate, callback_),
 114         context->Global(),
 115         argc_,
 116         local_argv.get());
 117   }
 118
 119   void SetArguments(int argc, v8::Local<v8::Value> argv[]) {
 120     v8::Isolate* isolate = blink::mainThreadIsolate();
 121     argc_ = argc;
 122     argv_.reset(new v8::UniquePersistent<v8::Value>[argc]);
 123     for (int i = 0; i < argc; ++i)
 124       argv_[i] = v8::UniquePersistent<v8::Value>(isolate, argv[i]);
 125   }
 126
 127  private:
 128   v8::UniquePersistent<v8::Function> callback_;
 129   int argc_;
 130   scoped_ptr<v8::UniquePersistent<v8::Value>[]> argv_;
 131 };
 132
 133 class TestRunnerBindings : public gin::Wrappable<TestRunnerBindings> {
 134  public:
 135   static gin::WrapperInfo kWrapperInfo;
 136
 137   static void Install(base::WeakPtr<TestRunner> controller,
 138                       WebFrame* frame);
 139
 140  private:
 141   explicit TestRunnerBindings(
 142       base::WeakPtr<TestRunner> controller);
 143   ~TestRunnerBindings() override;
 144
 145   // gin::Wrappable:
 146   gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
 147       v8::Isolate* isolate) override;
 148
 149   void LogToStderr(const std::string& output);
 150   void NotifyDone();
 151   void WaitUntilDone();
 152   void QueueBackNavigation(int how_far_back);
 153   void QueueForwardNavigation(int how_far_forward);
 154   void QueueReload();
 155   void QueueLoadingScript(const std::string& script);
 156   void QueueNonLoadingScript(const std::string& script);
 157   void QueueLoad(gin::Arguments* args);
 158   void QueueLoadHTMLString(gin::Arguments* args);
 159   void SetCustomPolicyDelegate(gin::Arguments* args);
 160   void WaitForPolicyDelegate();
 161   int WindowCount();
 162   void SetCloseRemainingWindowsWhenComplete(gin::Arguments* args);
 163   void ResetTestHelperControllers();
 164   void SetTabKeyCyclesThroughElements(bool tab_key_cycles_through_elements);
 165   void ExecCommand(gin::Arguments* args);
 166   bool IsCommandEnabled(const std::string& command);
 167   bool CallShouldCloseOnWebView();
 168   void SetDomainRelaxationForbiddenForURLScheme(bool forbidden,
 169                                                 const std::string& scheme);
 170   v8::Local<v8::Value> EvaluateScriptInIsolatedWorldAndReturnValue(
 171       int world_id, const std::string& script);
 172   void EvaluateScriptInIsolatedWorld(int world_id, const std::string& script);
 173   void SetIsolatedWorldSecurityOrigin(int world_id,
 174                                       v8::Local<v8::Value> origin);
 175   void SetIsolatedWorldContentSecurityPolicy(int world_id,
 176                                              const std::string& policy);
 177   void AddOriginAccessWhitelistEntry(const std::string& source_origin,
 178                                      const std::string& destination_protocol,
 179                                      const std::string& destination_host,
 180                                      bool allow_destination_subdomains);
 181   void RemoveOriginAccessWhitelistEntry(const std::string& source_origin,
 182                                         const std::string& destination_protocol,
 183                                         const std::string& destination_host,
 184                                         bool allow_destination_subdomains);
 185   bool HasCustomPageSizeStyle(int page_index);
 186   void ForceRedSelectionColors();
 187   void InsertStyleSheet(const std::string& source_code);
 188   bool FindString(const std::string& search_text,
 189                   const std::vector<std::string>& options_array);
 190   std::string SelectionAsMarkup();
 191   void SetTextSubpixelPositioning(bool value);
 192   void SetPageVisibility(const std::string& new_visibility);
 193   void SetTextDirection(const std::string& direction_name);
 194   void UseUnfortunateSynchronousResizeMode();
 195   bool EnableAutoResizeMode(int min_width,
 196                             int min_height,
 197                             int max_width,
 198                             int max_height);
 199   bool DisableAutoResizeMode(int new_width, int new_height);
 200   void SetMockDeviceLight(double value);
 201   void ResetDeviceLight();
 202   void SetMockDeviceMotion(gin::Arguments* args);
 203   void SetMockDeviceOrientation(gin::Arguments* args);
 204   void SetMockScreenOrientation(const std::string& orientation);
 205   void DidChangeBatteryStatus(bool charging,
 206                               double chargingTime,
 207                               double dischargingTime,
 208                               double level);
 209   void ResetBatteryStatus();
 210   void DidAcquirePointerLock();
 211   void DidNotAcquirePointerLock();
 212   void DidLosePointerLock();
 213   void SetPointerLockWillFailSynchronously();
 214   void SetPointerLockWillRespondAsynchronously();
 215   void SetPopupBlockingEnabled(bool block_popups);
 216   void SetJavaScriptCanAccessClipboard(bool can_access);
 217   void SetXSSAuditorEnabled(bool enabled);
 218   void SetAllowUniversalAccessFromFileURLs(bool allow);
 219   void SetAllowFileAccessFromFileURLs(bool allow);
 220   void OverridePreference(const std::string key, v8::Local<v8::Value> value);
 221   void SetAcceptLanguages(const std::string& accept_languages);
 222   void SetPluginsEnabled(bool enabled);
 223   void DumpEditingCallbacks();
 224   void DumpAsMarkup();
 225   void DumpAsText();
 226   void DumpAsTextWithPixelResults();
 227   void DumpChildFrameScrollPositions();
 228   void DumpChildFramesAsMarkup();
 229   void DumpChildFramesAsText();
 230   void DumpIconChanges();
 231   void SetAudioData(const gin::ArrayBufferView& view);
 232   void DumpFrameLoadCallbacks();
 233   void DumpPingLoaderCallbacks();
 234   void DumpUserGestureInFrameLoadCallbacks();
 235   void DumpTitleChanges();
 236   void DumpCreateView();
 237   void SetCanOpenWindows();
 238   void DumpResourceLoadCallbacks();
 239   void DumpResourceRequestCallbacks();
 240   void DumpResourceResponseMIMETypes();
 241   void SetImagesAllowed(bool allowed);
 242   void SetMediaAllowed(bool allowed);
 243   void SetScriptsAllowed(bool allowed);
 244   void SetStorageAllowed(bool allowed);
 245   void SetPluginsAllowed(bool allowed);
 246   void SetAllowDisplayOfInsecureContent(bool allowed);
 247   void SetAllowRunningOfInsecureContent(bool allowed);
 248   void DumpPermissionClientCallbacks();
 249   void DumpWindowStatusChanges();
 250   void DumpProgressFinishedCallback();
 251   void DumpSpellCheckCallbacks();
 252   void DumpBackForwardList();
 253   void DumpSelectionRect();
 254   void SetPrinting();
 255   void ClearPrinting();
 256   void SetShouldStayOnPageAfterHandlingBeforeUnload(bool value);
 257   void SetWillSendRequestClearHeader(const std::string& header);
 258   void DumpResourceRequestPriorities();
 259   void SetUseMockTheme(bool use);
 260   void WaitUntilExternalURLLoad();
 261   void DumpDragImage();
 262   void DumpNavigationPolicy();
 263   void ShowWebInspector(gin::Arguments* args);
 264   void CloseWebInspector();
 265   bool IsChooserShown();
 266   void EvaluateInWebInspector(int call_id, const std::string& script);
 267   void ClearAllDatabases();
 268   void SetDatabaseQuota(int quota);
 269   void SetAlwaysAcceptCookies(bool accept);
 270   void SetWindowIsKey(bool value);
 271   std::string PathToLocalResource(const std::string& path);
 272   void SetBackingScaleFactor(double value, v8::Local<v8::Function> callback);
 273   void SetColorProfile(const std::string& name,
 274                        v8::Local<v8::Function> callback);
 275   void SetPOSIXLocale(const std::string& locale);
 276   void SetMIDIAccessorResult(bool result);
 277   void SimulateWebNotificationClick(const std::string& title);
 278   void AddMockSpeechRecognitionResult(const std::string& transcript,
 279                                       double confidence);
 280   void SetMockSpeechRecognitionError(const std::string& error,
 281                                      const std::string& message);
 282   bool WasMockSpeechRecognitionAborted();
 283   void AddMockCredentialManagerResponse(const std::string& id,
 284                                         const std::string& name,
 285                                         const std::string& avatar,
 286                                         const std::string& password);
 287   void AddWebPageOverlay();
 288   void RemoveWebPageOverlay();
 289   void LayoutAndPaintAsync();
 290   void LayoutAndPaintAsyncThen(v8::Local<v8::Function> callback);
 291   void GetManifestThen(v8::Local<v8::Function> callback);
 292   void CapturePixelsAsyncThen(v8::Local<v8::Function> callback);
 293   void CopyImageAtAndCapturePixelsAsyncThen(int x,
 294                                             int y,
 295                                             v8::Local<v8::Function> callback);
 296   void SetCustomTextOutput(std::string output);
 297   void SetViewSourceForFrame(const std::string& name, bool enabled);
 298   void SetBluetoothMockDataSet(const std::string& dataset_name);
 299   void SetGeofencingMockProvider(bool service_available);
 300   void ClearGeofencingMockProvider();
 301   void SetGeofencingMockPosition(double latitude, double longitude);
 302   void SetPermission(const std::string& name,
 303                      const std::string& value,
 304                      const std::string& origin,
 305                      const std::string& embedding_origin);
 306   void DispatchBeforeInstallPromptEvent(
 307       int request_id,
 308       const std::vector<std::string>& event_platforms,
 309       v8::Local<v8::Function> callback);
 310   void ResolveBeforeInstallPromptPromise(int request_id,
 311                                          const std::string& platform);
 312
 313   std::string PlatformName();
 314   std::string TooltipText();
 315   bool DisableNotifyDone();
 316   int WebHistoryItemCount();
 317   bool InterceptPostMessage();
 318   void SetInterceptPostMessage(bool value);
 319
 320   void NotImplemented(const gin::Arguments& args);
 321
 322   void ForceNextWebGLContextCreationToFail();
 323   void ForceNextDrawingBufferCreationToFail();
 324
 325   base::WeakPtr<TestRunner> runner_;
 326
 327   DISALLOW_COPY_AND_ASSIGN(TestRunnerBindings);
 328 };
 329
 330 gin::WrapperInfo TestRunnerBindings::kWrapperInfo = {
 331     gin::kEmbedderNativeGin};
 332
 333 // static
 334 void TestRunnerBindings::Install(base::WeakPtr<TestRunner> runner,
 335                                  WebFrame* frame) {
 336   v8::Isolate* isolate = blink::mainThreadIsolate();
 337   v8::HandleScope handle_scope(isolate);
 338   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
 339   if (context.IsEmpty())
 340     return;
 341
 342   v8::Context::Scope context_scope(context);
 343
 344   TestRunnerBindings* wrapped = new TestRunnerBindings(runner);
 345   gin::Handle<TestRunnerBindings> bindings =
 346       gin::CreateHandle(isolate, wrapped);
 347   if (bindings.IsEmpty())
 348     return;
 349   v8::Local<v8::Object> global = context->Global();
 350   v8::Local<v8::Value> v8_bindings = bindings.ToV8();
 351
 352   std::vector<std::string> names;
 353   names.push_back("testRunner");
 354   names.push_back("layoutTestController");
 355   for (size_t i = 0; i < names.size(); ++i)
 356     global->Set(gin::StringToV8(isolate, names[i].c_str()), v8_bindings);
 357 }
 358
 359 TestRunnerBindings::TestRunnerBindings(base::WeakPtr<TestRunner> runner)
 360     : runner_(runner) {}
 361
 362 TestRunnerBindings::~TestRunnerBindings() {}
 363
 364 gin::ObjectTemplateBuilder TestRunnerBindings::GetObjectTemplateBuilder(
 365     v8::Isolate* isolate) {
 366   return gin::Wrappable<TestRunnerBindings>::GetObjectTemplateBuilder(isolate)
 367       // Methods controlling test execution.
 368       .SetMethod("logToStderr", &TestRunnerBindings::LogToStderr)
 369       .SetMethod("notifyDone", &TestRunnerBindings::NotifyDone)
 370       .SetMethod("waitUntilDone", &TestRunnerBindings::WaitUntilDone)
 371       .SetMethod("queueBackNavigation",
 372                  &TestRunnerBindings::QueueBackNavigation)
 373       .SetMethod("queueForwardNavigation",
 374                  &TestRunnerBindings::QueueForwardNavigation)
 375       .SetMethod("queueReload", &TestRunnerBindings::QueueReload)
 376       .SetMethod("queueLoadingScript", &TestRunnerBindings::QueueLoadingScript)
 377       .SetMethod("queueNonLoadingScript",
 378                  &TestRunnerBindings::QueueNonLoadingScript)
 379       .SetMethod("queueLoad", &TestRunnerBindings::QueueLoad)
 380       .SetMethod("queueLoadHTMLString",
 381                  &TestRunnerBindings::QueueLoadHTMLString)
 382       .SetMethod("setCustomPolicyDelegate",
 383                  &TestRunnerBindings::SetCustomPolicyDelegate)
 384       .SetMethod("waitForPolicyDelegate",
 385                  &TestRunnerBindings::WaitForPolicyDelegate)
 386       .SetMethod("windowCount", &TestRunnerBindings::WindowCount)
 387       .SetMethod("setCloseRemainingWindowsWhenComplete",
 388                  &TestRunnerBindings::SetCloseRemainingWindowsWhenComplete)
 389       .SetMethod("resetTestHelperControllers",
 390                  &TestRunnerBindings::ResetTestHelperControllers)
 391       .SetMethod("setTabKeyCyclesThroughElements",
 392                  &TestRunnerBindings::SetTabKeyCyclesThroughElements)
 393       .SetMethod("execCommand", &TestRunnerBindings::ExecCommand)
 394       .SetMethod("isCommandEnabled", &TestRunnerBindings::IsCommandEnabled)
 395       .SetMethod("callShouldCloseOnWebView",
 396                  &TestRunnerBindings::CallShouldCloseOnWebView)
 397       .SetMethod("setDomainRelaxationForbiddenForURLScheme",
 398                  &TestRunnerBindings::SetDomainRelaxationForbiddenForURLScheme)
 399       .SetMethod(
 400           "evaluateScriptInIsolatedWorldAndReturnValue",
 401           &TestRunnerBindings::EvaluateScriptInIsolatedWorldAndReturnValue)
 402       .SetMethod("evaluateScriptInIsolatedWorld",
 403                  &TestRunnerBindings::EvaluateScriptInIsolatedWorld)
 404       .SetMethod("setIsolatedWorldSecurityOrigin",
 405                  &TestRunnerBindings::SetIsolatedWorldSecurityOrigin)
 406       .SetMethod("setIsolatedWorldContentSecurityPolicy",
 407                  &TestRunnerBindings::SetIsolatedWorldContentSecurityPolicy)
 408       .SetMethod("addOriginAccessWhitelistEntry",
 409                  &TestRunnerBindings::AddOriginAccessWhitelistEntry)
 410       .SetMethod("removeOriginAccessWhitelistEntry",
 411                  &TestRunnerBindings::RemoveOriginAccessWhitelistEntry)
 412       .SetMethod("hasCustomPageSizeStyle",
 413                  &TestRunnerBindings::HasCustomPageSizeStyle)
 414       .SetMethod("forceRedSelectionColors",
 415                  &TestRunnerBindings::ForceRedSelectionColors)
 416       .SetMethod("insertStyleSheet", &TestRunnerBindings::InsertStyleSheet)
 417       .SetMethod("findString", &TestRunnerBindings::FindString)
 418       .SetMethod("selectionAsMarkup", &TestRunnerBindings::SelectionAsMarkup)
 419       .SetMethod("setTextSubpixelPositioning",
 420                  &TestRunnerBindings::SetTextSubpixelPositioning)
 421       .SetMethod("setPageVisibility", &TestRunnerBindings::SetPageVisibility)
 422       .SetMethod("setTextDirection", &TestRunnerBindings::SetTextDirection)
 423       .SetMethod("useUnfortunateSynchronousResizeMode",
 424                  &TestRunnerBindings::UseUnfortunateSynchronousResizeMode)
 425       .SetMethod("enableAutoResizeMode",
 426                  &TestRunnerBindings::EnableAutoResizeMode)
 427       .SetMethod("disableAutoResizeMode",
 428                  &TestRunnerBindings::DisableAutoResizeMode)
 429       .SetMethod("setMockDeviceLight", &TestRunnerBindings::SetMockDeviceLight)
 430       .SetMethod("resetDeviceLight", &TestRunnerBindings::ResetDeviceLight)
 431       .SetMethod("setMockDeviceMotion",
 432                  &TestRunnerBindings::SetMockDeviceMotion)
 433       .SetMethod("setMockDeviceOrientation",
 434                  &TestRunnerBindings::SetMockDeviceOrientation)
 435       .SetMethod("setMockScreenOrientation",
 436                  &TestRunnerBindings::SetMockScreenOrientation)
 437       .SetMethod("didChangeBatteryStatus",
 438                  &TestRunnerBindings::DidChangeBatteryStatus)
 439       .SetMethod("resetBatteryStatus", &TestRunnerBindings::ResetBatteryStatus)
 440       .SetMethod("didAcquirePointerLock",
 441                  &TestRunnerBindings::DidAcquirePointerLock)
 442       .SetMethod("didNotAcquirePointerLock",
 443                  &TestRunnerBindings::DidNotAcquirePointerLock)
 444       .SetMethod("didLosePointerLock", &TestRunnerBindings::DidLosePointerLock)
 445       .SetMethod("setPointerLockWillFailSynchronously",
 446                  &TestRunnerBindings::SetPointerLockWillFailSynchronously)
 447       .SetMethod("setPointerLockWillRespondAsynchronously",
 448                  &TestRunnerBindings::SetPointerLockWillRespondAsynchronously)
 449       .SetMethod("setPopupBlockingEnabled",
 450                  &TestRunnerBindings::SetPopupBlockingEnabled)
 451       .SetMethod("setJavaScriptCanAccessClipboard",
 452                  &TestRunnerBindings::SetJavaScriptCanAccessClipboard)
 453       .SetMethod("setXSSAuditorEnabled",
 454                  &TestRunnerBindings::SetXSSAuditorEnabled)
 455       .SetMethod("setAllowUniversalAccessFromFileURLs",
 456                  &TestRunnerBindings::SetAllowUniversalAccessFromFileURLs)
 457       .SetMethod("setAllowFileAccessFromFileURLs",
 458                  &TestRunnerBindings::SetAllowFileAccessFromFileURLs)
 459       .SetMethod("overridePreference", &TestRunnerBindings::OverridePreference)
 460       .SetMethod("setAcceptLanguages", &TestRunnerBindings::SetAcceptLanguages)
 461       .SetMethod("setPluginsEnabled", &TestRunnerBindings::SetPluginsEnabled)
 462       .SetMethod("dumpEditingCallbacks",
 463                  &TestRunnerBindings::DumpEditingCallbacks)
 464       .SetMethod("dumpAsMarkup", &TestRunnerBindings::DumpAsMarkup)
 465       .SetMethod("dumpAsText", &TestRunnerBindings::DumpAsText)
 466       .SetMethod("dumpAsTextWithPixelResults",
 467                  &TestRunnerBindings::DumpAsTextWithPixelResults)
 468       .SetMethod("dumpChildFrameScrollPositions",
 469                  &TestRunnerBindings::DumpChildFrameScrollPositions)
 470       .SetMethod("dumpChildFramesAsText",
 471                  &TestRunnerBindings::DumpChildFramesAsText)
 472       .SetMethod("dumpChildFramesAsMarkup",
 473                  &TestRunnerBindings::DumpChildFramesAsMarkup)
 474       .SetMethod("dumpIconChanges", &TestRunnerBindings::DumpIconChanges)
 475       .SetMethod("setAudioData", &TestRunnerBindings::SetAudioData)
 476       .SetMethod("dumpFrameLoadCallbacks",
 477                  &TestRunnerBindings::DumpFrameLoadCallbacks)
 478       .SetMethod("dumpPingLoaderCallbacks",
 479                  &TestRunnerBindings::DumpPingLoaderCallbacks)
 480       .SetMethod("dumpUserGestureInFrameLoadCallbacks",
 481                  &TestRunnerBindings::DumpUserGestureInFrameLoadCallbacks)
 482       .SetMethod("dumpTitleChanges", &TestRunnerBindings::DumpTitleChanges)
 483       .SetMethod("dumpCreateView", &TestRunnerBindings::DumpCreateView)
 484       .SetMethod("setCanOpenWindows", &TestRunnerBindings::SetCanOpenWindows)
 485       .SetMethod("dumpResourceLoadCallbacks",
 486                  &TestRunnerBindings::DumpResourceLoadCallbacks)
 487       .SetMethod("dumpResourceRequestCallbacks",
 488                  &TestRunnerBindings::DumpResourceRequestCallbacks)
 489       .SetMethod("dumpResourceResponseMIMETypes",
 490                  &TestRunnerBindings::DumpResourceResponseMIMETypes)
 491       .SetMethod("setImagesAllowed", &TestRunnerBindings::SetImagesAllowed)
 492       .SetMethod("setMediaAllowed", &TestRunnerBindings::SetMediaAllowed)
 493       .SetMethod("setScriptsAllowed", &TestRunnerBindings::SetScriptsAllowed)
 494       .SetMethod("setStorageAllowed", &TestRunnerBindings::SetStorageAllowed)
 495       .SetMethod("setPluginsAllowed", &TestRunnerBindings::SetPluginsAllowed)
 496       .SetMethod("setAllowDisplayOfInsecureContent",
 497                  &TestRunnerBindings::SetAllowDisplayOfInsecureContent)
 498       .SetMethod("setAllowRunningOfInsecureContent",
 499                  &TestRunnerBindings::SetAllowRunningOfInsecureContent)
 500       .SetMethod("dumpPermissionClientCallbacks",
 501                  &TestRunnerBindings::DumpPermissionClientCallbacks)
 502       .SetMethod("dumpWindowStatusChanges",
 503                  &TestRunnerBindings::DumpWindowStatusChanges)
 504       .SetMethod("dumpProgressFinishedCallback",
 505                  &TestRunnerBindings::DumpProgressFinishedCallback)
 506       .SetMethod("dumpSpellCheckCallbacks",
 507                  &TestRunnerBindings::DumpSpellCheckCallbacks)
 508       .SetMethod("dumpBackForwardList",
 509                  &TestRunnerBindings::DumpBackForwardList)
 510       .SetMethod("dumpSelectionRect", &TestRunnerBindings::DumpSelectionRect)
 511       .SetMethod("setPrinting", &TestRunnerBindings::SetPrinting)
 512       .SetMethod("clearPrinting", &TestRunnerBindings::ClearPrinting)
 513       .SetMethod(
 514           "setShouldStayOnPageAfterHandlingBeforeUnload",
 515           &TestRunnerBindings::SetShouldStayOnPageAfterHandlingBeforeUnload)
 516       .SetMethod("setWillSendRequestClearHeader",
 517                  &TestRunnerBindings::SetWillSendRequestClearHeader)
 518       .SetMethod("dumpResourceRequestPriorities",
 519                  &TestRunnerBindings::DumpResourceRequestPriorities)
 520       .SetMethod("setUseMockTheme", &TestRunnerBindings::SetUseMockTheme)
 521       .SetMethod("waitUntilExternalURLLoad",
 522                  &TestRunnerBindings::WaitUntilExternalURLLoad)
 523       .SetMethod("dumpDragImage", &TestRunnerBindings::DumpDragImage)
 524       .SetMethod("dumpNavigationPolicy",
 525                  &TestRunnerBindings::DumpNavigationPolicy)
 526       .SetMethod("showWebInspector", &TestRunnerBindings::ShowWebInspector)
 527       .SetMethod("closeWebInspector", &TestRunnerBindings::CloseWebInspector)
 528       .SetMethod("isChooserShown", &TestRunnerBindings::IsChooserShown)
 529       .SetMethod("evaluateInWebInspector",
 530                  &TestRunnerBindings::EvaluateInWebInspector)
 531       .SetMethod("clearAllDatabases", &TestRunnerBindings::ClearAllDatabases)
 532       .SetMethod("setDatabaseQuota", &TestRunnerBindings::SetDatabaseQuota)
 533       .SetMethod("setAlwaysAcceptCookies",
 534                  &TestRunnerBindings::SetAlwaysAcceptCookies)
 535       .SetMethod("setWindowIsKey", &TestRunnerBindings::SetWindowIsKey)
 536       .SetMethod("pathToLocalResource",
 537                  &TestRunnerBindings::PathToLocalResource)
 538       .SetMethod("setBackingScaleFactor",
 539                  &TestRunnerBindings::SetBackingScaleFactor)
 540       .SetMethod("setColorProfile", &TestRunnerBindings::SetColorProfile)
 541       .SetMethod("setPOSIXLocale", &TestRunnerBindings::SetPOSIXLocale)
 542       .SetMethod("setMIDIAccessorResult",
 543                  &TestRunnerBindings::SetMIDIAccessorResult)
 544       .SetMethod("simulateWebNotificationClick",
 545                  &TestRunnerBindings::SimulateWebNotificationClick)
 546       .SetMethod("addMockSpeechRecognitionResult",
 547                  &TestRunnerBindings::AddMockSpeechRecognitionResult)
 548       .SetMethod("setMockSpeechRecognitionError",
 549                  &TestRunnerBindings::SetMockSpeechRecognitionError)
 550       .SetMethod("wasMockSpeechRecognitionAborted",
 551                  &TestRunnerBindings::WasMockSpeechRecognitionAborted)
 552       .SetMethod("addMockCredentialManagerResponse",
 553                  &TestRunnerBindings::AddMockCredentialManagerResponse)
 554       .SetMethod("addWebPageOverlay", &TestRunnerBindings::AddWebPageOverlay)
 555       .SetMethod("removeWebPageOverlay",
 556                  &TestRunnerBindings::RemoveWebPageOverlay)
 557       .SetMethod("layoutAndPaintAsync",
 558                  &TestRunnerBindings::LayoutAndPaintAsync)
 559       .SetMethod("layoutAndPaintAsyncThen",
 560                  &TestRunnerBindings::LayoutAndPaintAsyncThen)
 561       .SetMethod("getManifestThen", &TestRunnerBindings::GetManifestThen)
 562       .SetMethod("capturePixelsAsyncThen",
 563                  &TestRunnerBindings::CapturePixelsAsyncThen)
 564       .SetMethod("copyImageAtAndCapturePixelsAsyncThen",
 565                  &TestRunnerBindings::CopyImageAtAndCapturePixelsAsyncThen)
 566       .SetMethod("setCustomTextOutput",
 567                  &TestRunnerBindings::SetCustomTextOutput)
 568       .SetMethod("setViewSourceForFrame",
 569                  &TestRunnerBindings::SetViewSourceForFrame)
 570       .SetMethod("setBluetoothMockDataSet",
 571                  &TestRunnerBindings::SetBluetoothMockDataSet)
 572       .SetMethod("forceNextWebGLContextCreationToFail",
 573                  &TestRunnerBindings::ForceNextWebGLContextCreationToFail)
 574       .SetMethod("forceNextDrawingBufferCreationToFail",
 575                  &TestRunnerBindings::ForceNextDrawingBufferCreationToFail)
 576       .SetMethod("setGeofencingMockProvider",
 577                  &TestRunnerBindings::SetGeofencingMockProvider)
 578       .SetMethod("clearGeofencingMockProvider",
 579                  &TestRunnerBindings::ClearGeofencingMockProvider)
 580       .SetMethod("setGeofencingMockPosition",
 581                  &TestRunnerBindings::SetGeofencingMockPosition)
 582       .SetMethod("setPermission", &TestRunnerBindings::SetPermission)
 583       .SetMethod("dispatchBeforeInstallPromptEvent",
 584                  &TestRunnerBindings::DispatchBeforeInstallPromptEvent)
 585       .SetMethod("resolveBeforeInstallPromptPromise",
 586                  &TestRunnerBindings::ResolveBeforeInstallPromptPromise)
 587
 588       // Properties.
 589       .SetProperty("platformName", &TestRunnerBindings::PlatformName)
 590       .SetProperty("tooltipText", &TestRunnerBindings::TooltipText)
 591       .SetProperty("disableNotifyDone", &TestRunnerBindings::DisableNotifyDone)
 592       // webHistoryItemCount is used by tests in LayoutTests\http\tests\history
 593       .SetProperty("webHistoryItemCount",
 594                    &TestRunnerBindings::WebHistoryItemCount)
 595       .SetProperty("interceptPostMessage",
 596                    &TestRunnerBindings::InterceptPostMessage,
 597                    &TestRunnerBindings::SetInterceptPostMessage)
 598
 599       // The following are stubs.
 600       .SetMethod("dumpDatabaseCallbacks", &TestRunnerBindings::NotImplemented)
 601       .SetMethod("setIconDatabaseEnabled", &TestRunnerBindings::NotImplemented)
 602       .SetMethod("setScrollbarPolicy", &TestRunnerBindings::NotImplemented)
 603       .SetMethod("clearAllApplicationCaches",
 604                  &TestRunnerBindings::NotImplemented)
 605       .SetMethod("clearApplicationCacheForOrigin",
 606                  &TestRunnerBindings::NotImplemented)
 607       .SetMethod("clearBackForwardList", &TestRunnerBindings::NotImplemented)
 608       .SetMethod("keepWebHistory", &TestRunnerBindings::NotImplemented)
 609       .SetMethod("setApplicationCacheOriginQuota",
 610                  &TestRunnerBindings::NotImplemented)
 611       .SetMethod("setCallCloseOnWebViews", &TestRunnerBindings::NotImplemented)
 612       .SetMethod("setMainFrameIsFirstResponder",
 613                  &TestRunnerBindings::NotImplemented)
 614       .SetMethod("setUseDashboardCompatibilityMode",
 615                  &TestRunnerBindings::NotImplemented)
 616       .SetMethod("deleteAllLocalStorage", &TestRunnerBindings::NotImplemented)
 617       .SetMethod("localStorageDiskUsageForOrigin",
 618                  &TestRunnerBindings::NotImplemented)
 619       .SetMethod("originsWithLocalStorage", &TestRunnerBindings::NotImplemented)
 620       .SetMethod("deleteLocalStorageForOrigin",
 621                  &TestRunnerBindings::NotImplemented)
 622       .SetMethod("observeStorageTrackerNotifications",
 623                  &TestRunnerBindings::NotImplemented)
 624       .SetMethod("syncLocalStorage", &TestRunnerBindings::NotImplemented)
 625       .SetMethod("addDisallowedURL", &TestRunnerBindings::NotImplemented)
 626       .SetMethod("applicationCacheDiskUsageForOrigin",
 627                  &TestRunnerBindings::NotImplemented)
 628       .SetMethod("abortModal", &TestRunnerBindings::NotImplemented)
 629
 630       // Aliases.
 631       // Used at fast/dom/assign-to-window-status.html
 632       .SetMethod("dumpStatusCallbacks",
 633                  &TestRunnerBindings::DumpWindowStatusChanges);
 634 }
 635
 636 void TestRunnerBindings::LogToStderr(const std::string& output) {
 637   LOG(ERROR) << output;
 638 }
 639
 640 void TestRunnerBindings::NotifyDone() {
 641   if (runner_)
 642     runner_->NotifyDone();
 643 }
 644
 645 void TestRunnerBindings::WaitUntilDone() {
 646   if (runner_)
 647     runner_->WaitUntilDone();
 648 }
 649
 650 void TestRunnerBindings::QueueBackNavigation(int how_far_back) {
 651   if (runner_)
 652     runner_->QueueBackNavigation(how_far_back);
 653 }
 654
 655 void TestRunnerBindings::QueueForwardNavigation(int how_far_forward) {
 656   if (runner_)
 657     runner_->QueueForwardNavigation(how_far_forward);
 658 }
 659
 660 void TestRunnerBindings::QueueReload() {
 661   if (runner_)
 662     runner_->QueueReload();
 663 }
 664
 665 void TestRunnerBindings::QueueLoadingScript(const std::string& script) {
 666   if (runner_)
 667     runner_->QueueLoadingScript(script);
 668 }
 669
 670 void TestRunnerBindings::QueueNonLoadingScript(const std::string& script) {
 671   if (runner_)
 672     runner_->QueueNonLoadingScript(script);
 673 }
 674
 675 void TestRunnerBindings::QueueLoad(gin::Arguments* args) {
 676   if (runner_) {
 677     std::string url;
 678     std::string target;
 679     args->GetNext(&url);
 680     args->GetNext(&target);
 681     runner_->QueueLoad(url, target);
 682   }
 683 }
 684
 685 void TestRunnerBindings::QueueLoadHTMLString(gin::Arguments* args) {
 686   if (runner_)
 687     runner_->QueueLoadHTMLString(args);
 688 }
 689
 690 void TestRunnerBindings::SetCustomPolicyDelegate(gin::Arguments* args) {
 691   if (runner_)
 692     runner_->SetCustomPolicyDelegate(args);
 693 }
 694
 695 void TestRunnerBindings::WaitForPolicyDelegate() {
 696   if (runner_)
 697     runner_->WaitForPolicyDelegate();
 698 }
 699
 700 int TestRunnerBindings::WindowCount() {
 701   if (runner_)
 702     return runner_->WindowCount();
 703   return 0;
 704 }
 705
 706 void TestRunnerBindings::SetCloseRemainingWindowsWhenComplete(
 707     gin::Arguments* args) {
 708   if (!runner_)
 709     return;
 710
 711   // In the original implementation, nothing happens if the argument is
 712   // ommitted.
 713   bool close_remaining_windows = false;
 714   if (args->GetNext(&close_remaining_windows))
 715     runner_->SetCloseRemainingWindowsWhenComplete(close_remaining_windows);
 716 }
 717
 718 void TestRunnerBindings::ResetTestHelperControllers() {
 719   if (runner_)
 720     runner_->ResetTestHelperControllers();
 721 }
 722
 723 void TestRunnerBindings::SetTabKeyCyclesThroughElements(
 724     bool tab_key_cycles_through_elements) {
 725   if (runner_)
 726     runner_->SetTabKeyCyclesThroughElements(tab_key_cycles_through_elements);
 727 }
 728
 729 void TestRunnerBindings::ExecCommand(gin::Arguments* args) {
 730   if (runner_)
 731     runner_->ExecCommand(args);
 732 }
 733
 734 bool TestRunnerBindings::IsCommandEnabled(const std::string& command) {
 735   if (runner_)
 736     return runner_->IsCommandEnabled(command);
 737   return false;
 738 }
 739
 740 bool TestRunnerBindings::CallShouldCloseOnWebView() {
 741   if (runner_)
 742     return runner_->CallShouldCloseOnWebView();
 743   return false;
 744 }
 745
 746 void TestRunnerBindings::SetDomainRelaxationForbiddenForURLScheme(
 747     bool forbidden, const std::string& scheme) {
 748   if (runner_)
 749     runner_->SetDomainRelaxationForbiddenForURLScheme(forbidden, scheme);
 750 }
 751
 752 v8::Local<v8::Value>
 753 TestRunnerBindings::EvaluateScriptInIsolatedWorldAndReturnValue(
 754     int world_id, const std::string& script) {
 755   if (!runner_ || world_id <= 0 || world_id >= (1 << 29))
 756     return v8::Local<v8::Value>();
 757   return runner_->EvaluateScriptInIsolatedWorldAndReturnValue(world_id,
 758                                                               script);
 759 }
 760
 761 void TestRunnerBindings::EvaluateScriptInIsolatedWorld(
 762     int world_id, const std::string& script) {
 763   if (runner_ && world_id > 0 && world_id < (1 << 29))
 764     runner_->EvaluateScriptInIsolatedWorld(world_id, script);
 765 }
 766
 767 void TestRunnerBindings::SetIsolatedWorldSecurityOrigin(
 768     int world_id, v8::Local<v8::Value> origin) {
 769   if (runner_)
 770     runner_->SetIsolatedWorldSecurityOrigin(world_id, origin);
 771 }
 772
 773 void TestRunnerBindings::SetIsolatedWorldContentSecurityPolicy(
 774     int world_id, const std::string& policy) {
 775   if (runner_)
 776     runner_->SetIsolatedWorldContentSecurityPolicy(world_id, policy);
 777 }
 778
 779 void TestRunnerBindings::AddOriginAccessWhitelistEntry(
 780     const std::string& source_origin,
 781     const std::string& destination_protocol,
 782     const std::string& destination_host,
 783     bool allow_destination_subdomains) {
 784   if (runner_) {
 785     runner_->AddOriginAccessWhitelistEntry(source_origin,
 786                                            destination_protocol,
 787                                            destination_host,
 788                                            allow_destination_subdomains);
 789   }
 790 }
 791
 792 void TestRunnerBindings::RemoveOriginAccessWhitelistEntry(
 793     const std::string& source_origin,
 794     const std::string& destination_protocol,
 795     const std::string& destination_host,
 796     bool allow_destination_subdomains) {
 797   if (runner_) {
 798     runner_->RemoveOriginAccessWhitelistEntry(source_origin,
 799                                               destination_protocol,
 800                                               destination_host,
 801                                               allow_destination_subdomains);
 802   }
 803 }
 804
 805 bool TestRunnerBindings::HasCustomPageSizeStyle(int page_index) {
 806   if (runner_)
 807     return runner_->HasCustomPageSizeStyle(page_index);
 808   return false;
 809 }
 810
 811 void TestRunnerBindings::ForceRedSelectionColors() {
 812   if (runner_)
 813     runner_->ForceRedSelectionColors();
 814 }
 815
 816 void TestRunnerBindings::InsertStyleSheet(const std::string& source_code) {
 817   if (runner_)
 818     runner_->InsertStyleSheet(source_code);
 819 }
 820
 821 bool TestRunnerBindings::FindString(
 822     const std::string& search_text,
 823     const std::vector<std::string>& options_array) {
 824   if (runner_)
 825     return runner_->FindString(search_text, options_array);
 826   return false;
 827 }
 828
 829 std::string TestRunnerBindings::SelectionAsMarkup() {
 830   if (runner_)
 831     return runner_->SelectionAsMarkup();
 832   return std::string();
 833 }
 834
 835 void TestRunnerBindings::SetTextSubpixelPositioning(bool value) {
 836   if (runner_)
 837     runner_->SetTextSubpixelPositioning(value);
 838 }
 839
 840 void TestRunnerBindings::SetPageVisibility(const std::string& new_visibility) {
 841   if (runner_)
 842     runner_->SetPageVisibility(new_visibility);
 843 }
 844
 845 void TestRunnerBindings::SetTextDirection(const std::string& direction_name) {
 846   if (runner_)
 847     runner_->SetTextDirection(direction_name);
 848 }
 849
 850 void TestRunnerBindings::UseUnfortunateSynchronousResizeMode() {
 851   if (runner_)
 852     runner_->UseUnfortunateSynchronousResizeMode();
 853 }
 854
 855 bool TestRunnerBindings::EnableAutoResizeMode(int min_width,
 856                                               int min_height,
 857                                               int max_width,
 858                                               int max_height) {
 859   if (runner_) {
 860     return runner_->EnableAutoResizeMode(min_width, min_height,
 861                                          max_width, max_height);
 862   }
 863   return false;
 864 }
 865
 866 bool TestRunnerBindings::DisableAutoResizeMode(int new_width, int new_height) {
 867   if (runner_)
 868     return runner_->DisableAutoResizeMode(new_width, new_height);
 869   return false;
 870 }
 871
 872 void TestRunnerBindings::SetMockDeviceLight(double value) {
 873   if (!runner_)
 874     return;
 875   runner_->SetMockDeviceLight(value);
 876 }
 877
 878 void TestRunnerBindings::ResetDeviceLight() {
 879   if (runner_)
 880     runner_->ResetDeviceLight();
 881 }
 882
 883 void TestRunnerBindings::SetMockDeviceMotion(gin::Arguments* args) {
 884   if (!runner_)
 885     return;
 886
 887   bool has_acceleration_x;
 888   double acceleration_x;
 889   bool has_acceleration_y;
 890   double acceleration_y;
 891   bool has_acceleration_z;
 892   double acceleration_z;
 893   bool has_acceleration_including_gravity_x;
 894   double acceleration_including_gravity_x;
 895   bool has_acceleration_including_gravity_y;
 896   double acceleration_including_gravity_y;
 897   bool has_acceleration_including_gravity_z;
 898   double acceleration_including_gravity_z;
 899   bool has_rotation_rate_alpha;
 900   double rotation_rate_alpha;
 901   bool has_rotation_rate_beta;
 902   double rotation_rate_beta;
 903   bool has_rotation_rate_gamma;
 904   double rotation_rate_gamma;
 905   double interval;
 906
 907   args->GetNext(&has_acceleration_x);
 908   args->GetNext(& acceleration_x);
 909   args->GetNext(&has_acceleration_y);
 910   args->GetNext(& acceleration_y);
 911   args->GetNext(&has_acceleration_z);
 912   args->GetNext(& acceleration_z);
 913   args->GetNext(&has_acceleration_including_gravity_x);
 914   args->GetNext(& acceleration_including_gravity_x);
 915   args->GetNext(&has_acceleration_including_gravity_y);
 916   args->GetNext(& acceleration_including_gravity_y);
 917   args->GetNext(&has_acceleration_including_gravity_z);
 918   args->GetNext(& acceleration_including_gravity_z);
 919   args->GetNext(&has_rotation_rate_alpha);
 920   args->GetNext(& rotation_rate_alpha);
 921   args->GetNext(&has_rotation_rate_beta);
 922   args->GetNext(& rotation_rate_beta);
 923   args->GetNext(&has_rotation_rate_gamma);
 924   args->GetNext(& rotation_rate_gamma);
 925   args->GetNext(& interval);
 926
 927   runner_->SetMockDeviceMotion(has_acceleration_x, acceleration_x,
 928                                has_acceleration_y, acceleration_y,
 929                                has_acceleration_z, acceleration_z,
 930                                has_acceleration_including_gravity_x,
 931                                acceleration_including_gravity_x,
 932                                has_acceleration_including_gravity_y,
 933                                acceleration_including_gravity_y,
 934                                has_acceleration_including_gravity_z,
 935                                acceleration_including_gravity_z,
 936                                has_rotation_rate_alpha,
 937                                rotation_rate_alpha,
 938                                has_rotation_rate_beta,
 939                                rotation_rate_beta,
 940                                has_rotation_rate_gamma,
 941                                rotation_rate_gamma,
 942                                interval);
 943 }
 944
 945 void TestRunnerBindings::SetMockDeviceOrientation(gin::Arguments* args) {
 946   if (!runner_)
 947     return;
 948
 949   bool has_alpha = false;
 950   double alpha = 0.0;
 951   bool has_beta = false;
 952   double beta = 0.0;
 953   bool has_gamma = false;
 954   double gamma = 0.0;
 955   bool has_absolute = false;
 956   bool absolute = false;
 957
 958   args->GetNext(&has_alpha);
 959   args->GetNext(&alpha);
 960   args->GetNext(&has_beta);
 961   args->GetNext(&beta);
 962   args->GetNext(&has_gamma);
 963   args->GetNext(&gamma);
 964   args->GetNext(&has_absolute);
 965   args->GetNext(&absolute);
 966
 967   runner_->SetMockDeviceOrientation(has_alpha, alpha,
 968                                     has_beta, beta,
 969                                     has_gamma, gamma,
 970                                     has_absolute, absolute);
 971 }
 972
 973 void TestRunnerBindings::SetMockScreenOrientation(
 974     const std::string& orientation) {
 975   if (!runner_)
 976     return;
 977
 978   runner_->SetMockScreenOrientation(orientation);
 979 }
 980
 981 void TestRunnerBindings::DidChangeBatteryStatus(bool charging,
 982                                                 double chargingTime,
 983                                                 double dischargingTime,
 984                                                 double level) {
 985   if (runner_) {
 986     runner_->DidChangeBatteryStatus(charging, chargingTime,
 987                                     dischargingTime, level);
 988   }
 989 }
 990
 991 void TestRunnerBindings::ResetBatteryStatus() {
 992   if (runner_)
 993     runner_->ResetBatteryStatus();
 994 }
 995
 996 void TestRunnerBindings::DidAcquirePointerLock() {
 997   if (runner_)
 998     runner_->DidAcquirePointerLock();
 999 }
1000
1001 void TestRunnerBindings::DidNotAcquirePointerLock() {
1002   if (runner_)
1003     runner_->DidNotAcquirePointerLock();
1004 }
1005
1006 void TestRunnerBindings::DidLosePointerLock() {
1007   if (runner_)
1008     runner_->DidLosePointerLock();
1009 }
1010
1011 void TestRunnerBindings::SetPointerLockWillFailSynchronously() {
1012   if (runner_)
1013     runner_->SetPointerLockWillFailSynchronously();
1014 }
1015
1016 void TestRunnerBindings::SetPointerLockWillRespondAsynchronously() {
1017   if (runner_)
1018     runner_->SetPointerLockWillRespondAsynchronously();
1019 }
1020
1021 void TestRunnerBindings::SetPopupBlockingEnabled(bool block_popups) {
1022   if (runner_)
1023     runner_->SetPopupBlockingEnabled(block_popups);
1024 }
1025
1026 void TestRunnerBindings::SetJavaScriptCanAccessClipboard(bool can_access) {
1027   if (runner_)
1028     runner_->SetJavaScriptCanAccessClipboard(can_access);
1029 }
1030
1031 void TestRunnerBindings::SetXSSAuditorEnabled(bool enabled) {
1032   if (runner_)
1033     runner_->SetXSSAuditorEnabled(enabled);
1034 }
1035
1036 void TestRunnerBindings::SetAllowUniversalAccessFromFileURLs(bool allow) {
1037   if (runner_)
1038     runner_->SetAllowUniversalAccessFromFileURLs(allow);
1039 }
1040
1041 void TestRunnerBindings::SetAllowFileAccessFromFileURLs(bool allow) {
1042   if (runner_)
1043     runner_->SetAllowFileAccessFromFileURLs(allow);
1044 }
1045
1046 void TestRunnerBindings::OverridePreference(const std::string key,
1047                                             v8::Local<v8::Value> value) {
1048   if (runner_)
1049     runner_->OverridePreference(key, value);
1050 }
1051
1052 void TestRunnerBindings::SetAcceptLanguages(
1053     const std::string& accept_languages) {
1054   if (!runner_)
1055     return;
1056
1057   runner_->SetAcceptLanguages(accept_languages);
1058 }
1059
1060 void TestRunnerBindings::SetPluginsEnabled(bool enabled) {
1061   if (runner_)
1062     runner_->SetPluginsEnabled(enabled);
1063 }
1064
1065 void TestRunnerBindings::DumpEditingCallbacks() {
1066   if (runner_)
1067     runner_->DumpEditingCallbacks();
1068 }
1069
1070 void TestRunnerBindings::DumpAsMarkup() {
1071   if (runner_)
1072     runner_->DumpAsMarkup();
1073 }
1074
1075 void TestRunnerBindings::DumpAsText() {
1076   if (runner_)
1077     runner_->DumpAsText();
1078 }
1079
1080 void TestRunnerBindings::DumpAsTextWithPixelResults() {
1081   if (runner_)
1082     runner_->DumpAsTextWithPixelResults();
1083 }
1084
1085 void TestRunnerBindings::DumpChildFrameScrollPositions() {
1086   if (runner_)
1087     runner_->DumpChildFrameScrollPositions();
1088 }
1089
1090 void TestRunnerBindings::DumpChildFramesAsText() {
1091   if (runner_)
1092     runner_->DumpChildFramesAsText();
1093 }
1094
1095 void TestRunnerBindings::DumpChildFramesAsMarkup() {
1096   if (runner_)
1097     runner_->DumpChildFramesAsMarkup();
1098 }
1099
1100 void TestRunnerBindings::DumpIconChanges() {
1101   if (runner_)
1102     runner_->DumpIconChanges();
1103 }
1104
1105 void TestRunnerBindings::SetAudioData(const gin::ArrayBufferView& view) {
1106   if (runner_)
1107     runner_->SetAudioData(view);
1108 }
1109
1110 void TestRunnerBindings::DumpFrameLoadCallbacks() {
1111   if (runner_)
1112     runner_->DumpFrameLoadCallbacks();
1113 }
1114
1115 void TestRunnerBindings::DumpPingLoaderCallbacks() {
1116   if (runner_)
1117     runner_->DumpPingLoaderCallbacks();
1118 }
1119
1120 void TestRunnerBindings::DumpUserGestureInFrameLoadCallbacks() {
1121   if (runner_)
1122     runner_->DumpUserGestureInFrameLoadCallbacks();
1123 }
1124
1125 void TestRunnerBindings::DumpTitleChanges() {
1126   if (runner_)
1127     runner_->DumpTitleChanges();
1128 }
1129
1130 void TestRunnerBindings::DumpCreateView() {
1131   if (runner_)
1132     runner_->DumpCreateView();
1133 }
1134
1135 void TestRunnerBindings::SetCanOpenWindows() {
1136   if (runner_)
1137     runner_->SetCanOpenWindows();
1138 }
1139
1140 void TestRunnerBindings::DumpResourceLoadCallbacks() {
1141   if (runner_)
1142     runner_->DumpResourceLoadCallbacks();
1143 }
1144
1145 void TestRunnerBindings::DumpResourceRequestCallbacks() {
1146   if (runner_)
1147     runner_->DumpResourceRequestCallbacks();
1148 }
1149
1150 void TestRunnerBindings::DumpResourceResponseMIMETypes() {
1151   if (runner_)
1152     runner_->DumpResourceResponseMIMETypes();
1153 }
1154
1155 void TestRunnerBindings::SetImagesAllowed(bool allowed) {
1156   if (runner_)
1157     runner_->SetImagesAllowed(allowed);
1158 }
1159
1160 void TestRunnerBindings::SetMediaAllowed(bool allowed) {
1161   if (runner_)
1162     runner_->SetMediaAllowed(allowed);
1163 }
1164
1165 void TestRunnerBindings::SetScriptsAllowed(bool allowed) {
1166   if (runner_)
1167     runner_->SetScriptsAllowed(allowed);
1168 }
1169
1170 void TestRunnerBindings::SetStorageAllowed(bool allowed) {
1171   if (runner_)
1172     runner_->SetStorageAllowed(allowed);
1173 }
1174
1175 void TestRunnerBindings::SetPluginsAllowed(bool allowed) {
1176   if (runner_)
1177     runner_->SetPluginsAllowed(allowed);
1178 }
1179
1180 void TestRunnerBindings::SetAllowDisplayOfInsecureContent(bool allowed) {
1181   if (runner_)
1182     runner_->SetAllowDisplayOfInsecureContent(allowed);
1183 }
1184
1185 void TestRunnerBindings::SetAllowRunningOfInsecureContent(bool allowed) {
1186   if (runner_)
1187     runner_->SetAllowRunningOfInsecureContent(allowed);
1188 }
1189
1190 void TestRunnerBindings::DumpPermissionClientCallbacks() {
1191   if (runner_)
1192     runner_->DumpPermissionClientCallbacks();
1193 }
1194
1195 void TestRunnerBindings::DumpWindowStatusChanges() {
1196   if (runner_)
1197     runner_->DumpWindowStatusChanges();
1198 }
1199
1200 void TestRunnerBindings::DumpProgressFinishedCallback() {
1201   if (runner_)
1202     runner_->DumpProgressFinishedCallback();
1203 }
1204
1205 void TestRunnerBindings::DumpSpellCheckCallbacks() {
1206   if (runner_)
1207     runner_->DumpSpellCheckCallbacks();
1208 }
1209
1210 void TestRunnerBindings::DumpBackForwardList() {
1211   if (runner_)
1212     runner_->DumpBackForwardList();
1213 }
1214
1215 void TestRunnerBindings::DumpSelectionRect() {
1216   if (runner_)
1217     runner_->DumpSelectionRect();
1218 }
1219
1220 void TestRunnerBindings::SetPrinting() {
1221   if (runner_)
1222     runner_->SetPrinting();
1223 }
1224
1225 void TestRunnerBindings::ClearPrinting() {
1226   if (runner_)
1227     runner_->ClearPrinting();
1228 }
1229
1230 void TestRunnerBindings::SetShouldStayOnPageAfterHandlingBeforeUnload(
1231     bool value) {
1232   if (runner_)
1233     runner_->SetShouldStayOnPageAfterHandlingBeforeUnload(value);
1234 }
1235
1236 void TestRunnerBindings::SetWillSendRequestClearHeader(
1237     const std::string& header) {
1238   if (runner_)
1239     runner_->SetWillSendRequestClearHeader(header);
1240 }
1241
1242 void TestRunnerBindings::DumpResourceRequestPriorities() {
1243   if (runner_)
1244     runner_->DumpResourceRequestPriorities();
1245 }
1246
1247 void TestRunnerBindings::SetUseMockTheme(bool use) {
1248   if (runner_)
1249     runner_->SetUseMockTheme(use);
1250 }
1251
1252 void TestRunnerBindings::WaitUntilExternalURLLoad() {
1253   if (runner_)
1254     runner_->WaitUntilExternalURLLoad();
1255 }
1256
1257 void TestRunnerBindings::DumpDragImage() {
1258   if (runner_)
1259     runner_->DumpDragImage();
1260 }
1261
1262 void TestRunnerBindings::DumpNavigationPolicy() {
1263   if (runner_)
1264     runner_->DumpNavigationPolicy();
1265 }
1266
1267 void TestRunnerBindings::ShowWebInspector(gin::Arguments* args) {
1268   if (runner_) {
1269     std::string settings;
1270     args->GetNext(&settings);
1271     std::string frontend_url;
1272     args->GetNext(&frontend_url);
1273     runner_->ShowWebInspector(settings, frontend_url);
1274   }
1275 }
1276
1277 void TestRunnerBindings::CloseWebInspector() {
1278   if (runner_)
1279     runner_->CloseWebInspector();
1280 }
1281
1282 bool TestRunnerBindings::IsChooserShown() {
1283   if (runner_)
1284     return runner_->IsChooserShown();
1285   return false;
1286 }
1287
1288 void TestRunnerBindings::EvaluateInWebInspector(int call_id,
1289                                                 const std::string& script) {
1290   if (runner_)
1291     runner_->EvaluateInWebInspector(call_id, script);
1292 }
1293
1294 void TestRunnerBindings::ClearAllDatabases() {
1295   if (runner_)
1296     runner_->ClearAllDatabases();
1297 }
1298
1299 void TestRunnerBindings::SetDatabaseQuota(int quota) {
1300   if (runner_)
1301     runner_->SetDatabaseQuota(quota);
1302 }
1303
1304 void TestRunnerBindings::SetAlwaysAcceptCookies(bool accept) {
1305   if (runner_)
1306     runner_->SetAlwaysAcceptCookies(accept);
1307 }
1308
1309 void TestRunnerBindings::SetWindowIsKey(bool value) {
1310   if (runner_)
1311     runner_->SetWindowIsKey(value);
1312 }
1313
1314 std::string TestRunnerBindings::PathToLocalResource(const std::string& path) {
1315   if (runner_)
1316     return runner_->PathToLocalResource(path);
1317   return std::string();
1318 }
1319
1320 void TestRunnerBindings::SetBackingScaleFactor(
1321     double value, v8::Local<v8::Function> callback) {
1322   if (runner_)
1323     runner_->SetBackingScaleFactor(value, callback);
1324 }
1325
1326 void TestRunnerBindings::SetColorProfile(
1327     const std::string& name, v8::Local<v8::Function> callback) {
1328   if (runner_)
1329     runner_->SetColorProfile(name, callback);
1330 }
1331
1332 void TestRunnerBindings::SetBluetoothMockDataSet(const std::string& name) {
1333   if (runner_)
1334     runner_->SetBluetoothMockDataSet(name);
1335 }
1336
1337 void TestRunnerBindings::SetPOSIXLocale(const std::string& locale) {
1338   if (runner_)
1339     runner_->SetPOSIXLocale(locale);
1340 }
1341
1342 void TestRunnerBindings::SetMIDIAccessorResult(bool result) {
1343   if (runner_)
1344     runner_->SetMIDIAccessorResult(result);
1345 }
1346
1347 void TestRunnerBindings::SimulateWebNotificationClick(
1348     const std::string& title) {
1349   if (runner_)
1350     runner_->SimulateWebNotificationClick(title);
1351 }
1352
1353 void TestRunnerBindings::AddMockSpeechRecognitionResult(
1354     const std::string& transcript, double confidence) {
1355   if (runner_)
1356     runner_->AddMockSpeechRecognitionResult(transcript, confidence);
1357 }
1358
1359 void TestRunnerBindings::SetMockSpeechRecognitionError(
1360     const std::string& error, const std::string& message) {
1361   if (runner_)
1362     runner_->SetMockSpeechRecognitionError(error, message);
1363 }
1364
1365 bool TestRunnerBindings::WasMockSpeechRecognitionAborted() {
1366   if (runner_)
1367     return runner_->WasMockSpeechRecognitionAborted();
1368   return false;
1369 }
1370
1371 void TestRunnerBindings::AddMockCredentialManagerResponse(
1372     const std::string& id,
1373     const std::string& name,
1374     const std::string& avatar,
1375     const std::string& password) {
1376   if (runner_)
1377     runner_->AddMockCredentialManagerResponse(id, name, avatar, password);
1378 }
1379
1380 void TestRunnerBindings::AddWebPageOverlay() {
1381   if (runner_)
1382     runner_->AddWebPageOverlay();
1383 }
1384
1385 void TestRunnerBindings::RemoveWebPageOverlay() {
1386   if (runner_)
1387     runner_->RemoveWebPageOverlay();
1388 }
1389
1390 void TestRunnerBindings::LayoutAndPaintAsync() {
1391   if (runner_)
1392     runner_->LayoutAndPaintAsync();
1393 }
1394
1395 void TestRunnerBindings::LayoutAndPaintAsyncThen(
1396     v8::Local<v8::Function> callback) {
1397   if (runner_)
1398     runner_->LayoutAndPaintAsyncThen(callback);
1399 }
1400
1401 void TestRunnerBindings::GetManifestThen(v8::Local<v8::Function> callback) {
1402   if (runner_)
1403     runner_->GetManifestThen(callback);
1404 }
1405
1406 void TestRunnerBindings::CapturePixelsAsyncThen(
1407     v8::Local<v8::Function> callback) {
1408   if (runner_)
1409     runner_->CapturePixelsAsyncThen(callback);
1410 }
1411
1412 void TestRunnerBindings::CopyImageAtAndCapturePixelsAsyncThen(
1413     int x, int y, v8::Local<v8::Function> callback) {
1414   if (runner_)
1415     runner_->CopyImageAtAndCapturePixelsAsyncThen(x, y, callback);
1416 }
1417
1418 void TestRunnerBindings::SetCustomTextOutput(std::string output) {
1419   runner_->setCustomTextOutput(output);
1420 }
1421
1422 void TestRunnerBindings::SetViewSourceForFrame(const std::string& name,
1423                                                bool enabled) {
1424   if (runner_ && runner_->web_view_) {
1425     WebFrame* target_frame =
1426         runner_->web_view_->findFrameByName(WebString::fromUTF8(name));
1427     if (target_frame)
1428       target_frame->enableViewSourceMode(enabled);
1429   }
1430 }
1431
1432 void TestRunnerBindings::SetGeofencingMockProvider(bool service_available) {
1433   if (runner_)
1434     runner_->SetGeofencingMockProvider(service_available);
1435 }
1436
1437 void TestRunnerBindings::ClearGeofencingMockProvider() {
1438   if (runner_)
1439     runner_->ClearGeofencingMockProvider();
1440 }
1441
1442 void TestRunnerBindings::SetGeofencingMockPosition(double latitude,
1443                                                    double longitude) {
1444   if (runner_)
1445     runner_->SetGeofencingMockPosition(latitude, longitude);
1446 }
1447
1448 void TestRunnerBindings::SetPermission(const std::string& name,
1449                                        const std::string& value,
1450                                        const std::string& origin,
1451                                        const std::string& embedding_origin) {
1452   if (!runner_)
1453     return;
1454
1455   return runner_->SetPermission(
1456       name, value, GURL(origin), GURL(embedding_origin));
1457 }
1458
1459 void TestRunnerBindings::DispatchBeforeInstallPromptEvent(
1460     int request_id,
1461     const std::vector<std::string>& event_platforms,
1462     v8::Local<v8::Function> callback) {
1463   if (!runner_)
1464     return;
1465
1466   return runner_->DispatchBeforeInstallPromptEvent(request_id, event_platforms,
1467                                                    callback);
1468 }
1469
1470 void TestRunnerBindings::ResolveBeforeInstallPromptPromise(
1471     int request_id,
1472     const std::string& platform) {
1473   if (!runner_)
1474     return;
1475
1476   return runner_->ResolveBeforeInstallPromptPromise(request_id, platform);
1477 }
1478
1479 std::string TestRunnerBindings::PlatformName() {
1480   if (runner_)
1481     return runner_->platform_name_;
1482   return std::string();
1483 }
1484
1485 std::string TestRunnerBindings::TooltipText() {
1486   if (runner_)
1487     return runner_->tooltip_text_;
1488   return std::string();
1489 }
1490
1491 bool TestRunnerBindings::DisableNotifyDone() {
1492   if (runner_)
1493     return runner_->disable_notify_done_;
1494   return false;
1495 }
1496
1497 int TestRunnerBindings::WebHistoryItemCount() {
1498   if (runner_)
1499     return runner_->web_history_item_count_;
1500   return false;
1501 }
1502
1503 bool TestRunnerBindings::InterceptPostMessage() {
1504   if (runner_)
1505     return runner_->intercept_post_message_;
1506   return false;
1507 }
1508
1509 void TestRunnerBindings::SetInterceptPostMessage(bool value) {
1510   if (runner_)
1511     runner_->intercept_post_message_ = value;
1512 }
1513
1514 void TestRunnerBindings::ForceNextWebGLContextCreationToFail() {
1515   if (runner_)
1516     runner_->ForceNextWebGLContextCreationToFail();
1517 }
1518
1519 void TestRunnerBindings::ForceNextDrawingBufferCreationToFail() {
1520   if (runner_)
1521     runner_->ForceNextDrawingBufferCreationToFail();
1522 }
1523
1524 void TestRunnerBindings::NotImplemented(const gin::Arguments& args) {
1525 }
1526
1527 class TestPageOverlay : public WebPageOverlay {
1528  public:
1529   TestPageOverlay() {}
1530   virtual ~TestPageOverlay() {}
1531
1532   virtual void paintPageOverlay(WebGraphicsContext* context,
1533                                 const WebSize& webViewSize) {
1534     gfx::Rect rect(webViewSize);
1535     SkCanvas* canvas = context->beginDrawing(gfx::RectF(rect));
1536     SkPaint paint;
1537     paint.setColor(SK_ColorCYAN);
1538     paint.setStyle(SkPaint::kFill_Style);
1539     canvas->drawRect(gfx::RectToSkRect(rect), paint);
1540     context->endDrawing();
1541   }
1542 };
1543
1544 TestRunner::WorkQueue::WorkQueue(TestRunner* controller)
1545     : frozen_(false)
1546     , controller_(controller) {}
1547
1548 TestRunner::WorkQueue::~WorkQueue() {
1549   Reset();
1550 }
1551
1552 void TestRunner::WorkQueue::ProcessWorkSoon() {
1553   if (controller_->topLoadingFrame())
1554     return;
1555
1556   if (!queue_.empty()) {
1557     // We delay processing queued work to avoid recursion problems.
1558     controller_->delegate_->PostTask(new WorkQueueTask(this));
1559   } else if (!controller_->wait_until_done_) {
1560     controller_->delegate_->TestFinished();
1561   }
1562 }
1563
1564 void TestRunner::WorkQueue::Reset() {
1565   frozen_ = false;
1566   while (!queue_.empty()) {
1567     delete queue_.front();
1568     queue_.pop_front();
1569   }
1570 }
1571
1572 void TestRunner::WorkQueue::AddWork(WorkItem* work) {
1573   if (frozen_) {
1574     delete work;
1575     return;
1576   }
1577   queue_.push_back(work);
1578 }
1579
1580 void TestRunner::WorkQueue::ProcessWork() {
1581   // Quit doing work once a load is in progress.
1582   while (!queue_.empty()) {
1583     bool startedLoad = queue_.front()->Run(controller_->delegate_,
1584                                            controller_->web_view_);
1585     delete queue_.front();
1586     queue_.pop_front();
1587     if (startedLoad)
1588       return;
1589   }
1590
1591   if (!controller_->wait_until_done_ && !controller_->topLoadingFrame())
1592     controller_->delegate_->TestFinished();
1593 }
1594
1595 void TestRunner::WorkQueue::WorkQueueTask::RunIfValid() {
1596   object_->ProcessWork();
1597 }
1598
1599 TestRunner::TestRunner(TestInterfaces* interfaces)
1600     : test_is_running_(false),
1601       close_remaining_windows_(false),
1602       work_queue_(this),
1603       disable_notify_done_(false),
1604       web_history_item_count_(0),
1605       intercept_post_message_(false),
1606       test_interfaces_(interfaces),
1607       delegate_(nullptr),
1608       web_view_(nullptr),
1609       page_overlay_(nullptr),
1610       web_content_settings_(new WebContentSettings()),
1611       weak_factory_(this) {}
1612
1613 TestRunner::~TestRunner() {}
1614
1615 void TestRunner::Install(WebFrame* frame) {
1616   TestRunnerBindings::Install(weak_factory_.GetWeakPtr(), frame);
1617 }
1618
1619 void TestRunner::SetDelegate(WebTestDelegate* delegate) {
1620   delegate_ = delegate;
1621   web_content_settings_->SetDelegate(delegate);
1622 }
1623
1624 void TestRunner::SetWebView(WebView* webView, WebTestProxyBase* proxy) {
1625   web_view_ = webView;
1626   proxy_ = proxy;
1627 }
1628
1629 void TestRunner::Reset() {
1630   if (web_view_) {
1631     web_view_->setZoomLevel(0);
1632     web_view_->setTextZoomFactor(1);
1633     web_view_->setTabKeyCyclesThroughElements(true);
1634 #if !defined(__APPLE__) && !defined(WIN32) // Actually, TOOLKIT_GTK
1635     // (Constants copied because we can't depend on the header that defined
1636     // them from this file.)
1637     web_view_->setSelectionColors(
1638         0xff1e90ff, 0xff000000, 0xffc8c8c8, 0xff323232);
1639 #endif
1640     web_view_->setVisibilityState(WebPageVisibilityStateVisible, true);
1641     web_view_->mainFrame()->enableViewSourceMode(false);
1642
1643     if (page_overlay_) {
1644       web_view_->removePageOverlay(page_overlay_);
1645       delete page_overlay_;
1646       page_overlay_ = nullptr;
1647     }
1648   }
1649
1650   top_loading_frame_ = nullptr;
1651   wait_until_done_ = false;
1652   wait_until_external_url_load_ = false;
1653   policy_delegate_enabled_ = false;
1654   policy_delegate_is_permissive_ = false;
1655   policy_delegate_should_notify_done_ = false;
1656
1657   WebSecurityPolicy::resetOriginAccessWhitelists();
1658 #if defined(__linux__) || defined(ANDROID)
1659   WebFontRendering::setSubpixelPositioning(false);
1660 #endif
1661
1662   if (delegate_) {
1663     // Reset the default quota for each origin to 5MB
1664     delegate_->SetDatabaseQuota(5 * 1024 * 1024);
1665     delegate_->SetDeviceColorProfile("reset");
1666     delegate_->SetDeviceScaleFactor(1);
1667     delegate_->SetAcceptAllCookies(false);
1668     delegate_->SetLocale("");
1669     delegate_->UseUnfortunateSynchronousResizeMode(false);
1670     delegate_->DisableAutoResizeMode(WebSize());
1671     delegate_->DeleteAllCookies();
1672     delegate_->ResetScreenOrientation();
1673     delegate_->SetBluetoothMockDataSet("");
1674     delegate_->ClearGeofencingMockProvider();
1675     delegate_->ResetPermissions();
1676     ResetBatteryStatus();
1677     ResetDeviceLight();
1678   }
1679
1680   dump_editting_callbacks_ = false;
1681   dump_as_text_ = false;
1682   dump_as_markup_ = false;
1683   generate_pixel_results_ = true;
1684   dump_child_frame_scroll_positions_ = false;
1685   dump_child_frames_as_markup_ = false;
1686   dump_child_frames_as_text_ = false;
1687   dump_icon_changes_ = false;
1688   dump_as_audio_ = false;
1689   dump_frame_load_callbacks_ = false;
1690   dump_ping_loader_callbacks_ = false;
1691   dump_user_gesture_in_frame_load_callbacks_ = false;
1692   dump_title_changes_ = false;
1693   dump_create_view_ = false;
1694   can_open_windows_ = false;
1695   dump_resource_load_callbacks_ = false;
1696   dump_resource_request_callbacks_ = false;
1697   dump_resource_response_mime_types_ = false;
1698   dump_window_status_changes_ = false;
1699   dump_progress_finished_callback_ = false;
1700   dump_spell_check_callbacks_ = false;
1701   dump_back_forward_list_ = false;
1702   dump_selection_rect_ = false;
1703   dump_drag_image_ = false;
1704   dump_navigation_policy_ = false;
1705   test_repaint_ = false;
1706   sweep_horizontally_ = false;
1707   is_printing_ = false;
1708   midi_accessor_result_ = true;
1709   should_stay_on_page_after_handling_before_unload_ = false;
1710   should_dump_resource_priorities_ = false;
1711   has_custom_text_output_ = false;
1712   custom_text_output_.clear();
1713
1714   http_headers_to_clear_.clear();
1715
1716   platform_name_ = "chromium";
1717   tooltip_text_ = std::string();
1718   disable_notify_done_ = false;
1719   web_history_item_count_ = 0;
1720   intercept_post_message_ = false;
1721
1722   web_content_settings_->Reset();
1723
1724   use_mock_theme_ = true;
1725   pointer_locked_ = false;
1726   pointer_lock_planned_result_ = PointerLockWillSucceed;
1727
1728   task_list_.RevokeAll();
1729   work_queue_.Reset();
1730
1731   if (close_remaining_windows_ && delegate_)
1732     delegate_->CloseRemainingWindows();
1733   else
1734     close_remaining_windows_ = true;
1735 }
1736
1737 void TestRunner::SetTestIsRunning(bool running) {
1738   test_is_running_ = running;
1739 }
1740
1741 void TestRunner::InvokeCallback(scoped_ptr<InvokeCallbackTask> task) {
1742   delegate_->PostTask(task.release());
1743 }
1744
1745 bool TestRunner::shouldDumpEditingCallbacks() const {
1746   return dump_editting_callbacks_;
1747 }
1748
1749 bool TestRunner::shouldDumpAsText() {
1750   CheckResponseMimeType();
1751   return dump_as_text_;
1752 }
1753
1754 void TestRunner::setShouldDumpAsText(bool value) {
1755   dump_as_text_ = value;
1756 }
1757
1758 bool TestRunner::shouldDumpAsMarkup() {
1759   return dump_as_markup_;
1760 }
1761
1762 void TestRunner::setShouldDumpAsMarkup(bool value) {
1763   dump_as_markup_ = value;
1764 }
1765
1766 bool TestRunner::shouldDumpAsCustomText() const {
1767   return has_custom_text_output_;
1768 }
1769
1770 std::string TestRunner::customDumpText() const {
1771   return custom_text_output_;
1772 }
1773
1774 void TestRunner::setCustomTextOutput(std::string text) {
1775   custom_text_output_ = text;
1776   has_custom_text_output_ = true;
1777 }
1778
1779 bool TestRunner::ShouldGeneratePixelResults() {
1780   CheckResponseMimeType();
1781   return generate_pixel_results_;
1782 }
1783
1784 bool TestRunner::ShouldStayOnPageAfterHandlingBeforeUnload() const {
1785   return should_stay_on_page_after_handling_before_unload_;
1786 }
1787
1788
1789 void TestRunner::setShouldGeneratePixelResults(bool value) {
1790   generate_pixel_results_ = value;
1791 }
1792
1793 bool TestRunner::shouldDumpChildFrameScrollPositions() const {
1794   return dump_child_frame_scroll_positions_;
1795 }
1796
1797 bool TestRunner::shouldDumpChildFramesAsMarkup() const {
1798   return dump_child_frames_as_markup_;
1799 }
1800
1801 bool TestRunner::shouldDumpChildFramesAsText() const {
1802   return dump_child_frames_as_text_;
1803 }
1804
1805 bool TestRunner::ShouldDumpAsAudio() const {
1806   return dump_as_audio_;
1807 }
1808
1809 void TestRunner::GetAudioData(std::vector<unsigned char>* buffer_view) const {
1810   *buffer_view = audio_data_;
1811 }
1812
1813 bool TestRunner::shouldDumpFrameLoadCallbacks() const {
1814   return test_is_running_ && dump_frame_load_callbacks_;
1815 }
1816
1817 void TestRunner::setShouldDumpFrameLoadCallbacks(bool value) {
1818   dump_frame_load_callbacks_ = value;
1819 }
1820
1821 bool TestRunner::shouldDumpPingLoaderCallbacks() const {
1822   return test_is_running_ && dump_ping_loader_callbacks_;
1823 }
1824
1825 void TestRunner::setShouldDumpPingLoaderCallbacks(bool value) {
1826   dump_ping_loader_callbacks_ = value;
1827 }
1828
1829 void TestRunner::setShouldEnableViewSource(bool value) {
1830   web_view_->mainFrame()->enableViewSourceMode(value);
1831 }
1832
1833 bool TestRunner::shouldDumpUserGestureInFrameLoadCallbacks() const {
1834   return test_is_running_ && dump_user_gesture_in_frame_load_callbacks_;
1835 }
1836
1837 bool TestRunner::shouldDumpTitleChanges() const {
1838   return dump_title_changes_;
1839 }
1840
1841 bool TestRunner::shouldDumpIconChanges() const {
1842   return dump_icon_changes_;
1843 }
1844
1845 bool TestRunner::shouldDumpCreateView() const {
1846   return dump_create_view_;
1847 }
1848
1849 bool TestRunner::canOpenWindows() const {
1850   return can_open_windows_;
1851 }
1852
1853 bool TestRunner::shouldDumpResourceLoadCallbacks() const {
1854   return test_is_running_ && dump_resource_load_callbacks_;
1855 }
1856
1857 bool TestRunner::shouldDumpResourceRequestCallbacks() const {
1858   return test_is_running_ && dump_resource_request_callbacks_;
1859 }
1860
1861 bool TestRunner::shouldDumpResourceResponseMIMETypes() const {
1862   return test_is_running_ && dump_resource_response_mime_types_;
1863 }
1864
1865 WebContentSettingsClient* TestRunner::GetWebContentSettings() const {
1866   return web_content_settings_.get();
1867 }
1868
1869 bool TestRunner::shouldDumpStatusCallbacks() const {
1870   return dump_window_status_changes_;
1871 }
1872
1873 bool TestRunner::shouldDumpProgressFinishedCallback() const {
1874   return dump_progress_finished_callback_;
1875 }
1876
1877 bool TestRunner::shouldDumpSpellCheckCallbacks() const {
1878   return dump_spell_check_callbacks_;
1879 }
1880
1881 bool TestRunner::ShouldDumpBackForwardList() const {
1882   return dump_back_forward_list_;
1883 }
1884
1885 bool TestRunner::shouldDumpSelectionRect() const {
1886   return dump_selection_rect_;
1887 }
1888
1889 bool TestRunner::isPrinting() const {
1890   return is_printing_;
1891 }
1892
1893 bool TestRunner::shouldWaitUntilExternalURLLoad() const {
1894   return wait_until_external_url_load_;
1895 }
1896
1897 const std::set<std::string>* TestRunner::httpHeadersToClear() const {
1898   return &http_headers_to_clear_;
1899 }
1900
1901 void TestRunner::setTopLoadingFrame(WebFrame* frame, bool clear) {
1902   if (frame->top()->view() != web_view_)
1903     return;
1904   if (!test_is_running_)
1905     return;
1906   if (clear) {
1907     top_loading_frame_ = nullptr;
1908     LocationChangeDone();
1909   } else if (!top_loading_frame_) {
1910     top_loading_frame_ = frame;
1911   }
1912 }
1913
1914 WebFrame* TestRunner::topLoadingFrame() const {
1915   return top_loading_frame_;
1916 }
1917
1918 void TestRunner::policyDelegateDone() {
1919   DCHECK(wait_until_done_);
1920   delegate_->TestFinished();
1921   wait_until_done_ = false;
1922 }
1923
1924 bool TestRunner::policyDelegateEnabled() const {
1925   return policy_delegate_enabled_;
1926 }
1927
1928 bool TestRunner::policyDelegateIsPermissive() const {
1929   return policy_delegate_is_permissive_;
1930 }
1931
1932 bool TestRunner::policyDelegateShouldNotifyDone() const {
1933   return policy_delegate_should_notify_done_;
1934 }
1935
1936 bool TestRunner::shouldInterceptPostMessage() const {
1937   return intercept_post_message_;
1938 }
1939
1940 bool TestRunner::shouldDumpResourcePriorities() const {
1941   return should_dump_resource_priorities_;
1942 }
1943
1944 bool TestRunner::RequestPointerLock() {
1945   switch (pointer_lock_planned_result_) {
1946     case PointerLockWillSucceed:
1947       delegate_->PostDelayedTask(
1948           new HostMethodTask(this, &TestRunner::DidAcquirePointerLockInternal),
1949           0);
1950       return true;
1951     case PointerLockWillRespondAsync:
1952       DCHECK(!pointer_locked_);
1953       return true;
1954     case PointerLockWillFailSync:
1955       DCHECK(!pointer_locked_);
1956       return false;
1957     default:
1958       NOTREACHED();
1959       return false;
1960   }
1961 }
1962
1963 void TestRunner::RequestPointerUnlock() {
1964   delegate_->PostDelayedTask(
1965       new HostMethodTask(this, &TestRunner::DidLosePointerLockInternal), 0);
1966 }
1967
1968 bool TestRunner::isPointerLocked() {
1969   return pointer_locked_;
1970 }
1971
1972 void TestRunner::setToolTipText(const WebString& text) {
1973   tooltip_text_ = text.utf8();
1974 }
1975
1976 bool TestRunner::shouldDumpDragImage() {
1977   return dump_drag_image_;
1978 }
1979
1980 bool TestRunner::shouldDumpNavigationPolicy() const {
1981   return dump_navigation_policy_;
1982 }
1983
1984 bool TestRunner::midiAccessorResult() {
1985   return midi_accessor_result_;
1986 }
1987
1988 void TestRunner::ClearDevToolsLocalStorage() {
1989   delegate_->ClearDevToolsLocalStorage();
1990 }
1991
1992 void TestRunner::ShowDevTools(const std::string& settings,
1993                               const std::string& frontend_url) {
1994   delegate_->ShowDevTools(settings, frontend_url);
1995 }
1996
1997 class WorkItemBackForward : public TestRunner::WorkItem {
1998  public:
1999   WorkItemBackForward(int distance) : distance_(distance) {}
2000
2001   bool Run(WebTestDelegate* delegate, WebView*) override {
2002     delegate->GoToOffset(distance_);
2003     return true; // FIXME: Did it really start a navigation?
2004   }
2005
2006  private:
2007   int distance_;
2008 };
2009
2010 void TestRunner::NotifyDone() {
2011   if (disable_notify_done_)
2012     return;
2013
2014   // Test didn't timeout. Kill the timeout timer.
2015   task_list_.RevokeAll();
2016
2017   CompleteNotifyDone();
2018 }
2019
2020 void TestRunner::WaitUntilDone() {
2021   wait_until_done_ = true;
2022 }
2023
2024 void TestRunner::QueueBackNavigation(int how_far_back) {
2025   work_queue_.AddWork(new WorkItemBackForward(-how_far_back));
2026 }
2027
2028 void TestRunner::QueueForwardNavigation(int how_far_forward) {
2029   work_queue_.AddWork(new WorkItemBackForward(how_far_forward));
2030 }
2031
2032 class WorkItemReload : public TestRunner::WorkItem {
2033  public:
2034   bool Run(WebTestDelegate* delegate, WebView*) override {
2035     delegate->Reload();
2036     return true;
2037   }
2038 };
2039
2040 void TestRunner::QueueReload() {
2041   work_queue_.AddWork(new WorkItemReload());
2042 }
2043
2044 class WorkItemLoadingScript : public TestRunner::WorkItem {
2045  public:
2046   WorkItemLoadingScript(const std::string& script)
2047       : script_(script) {}
2048
2049   bool Run(WebTestDelegate*, WebView* web_view) override {
2050     web_view->mainFrame()->executeScript(
2051         WebScriptSource(WebString::fromUTF8(script_)));
2052     return true; // FIXME: Did it really start a navigation?
2053   }
2054
2055  private:
2056   std::string script_;
2057 };
2058
2059 void TestRunner::QueueLoadingScript(const std::string& script) {
2060   work_queue_.AddWork(new WorkItemLoadingScript(script));
2061 }
2062
2063 class WorkItemNonLoadingScript : public TestRunner::WorkItem {
2064  public:
2065   WorkItemNonLoadingScript(const std::string& script)
2066       : script_(script) {}
2067
2068   bool Run(WebTestDelegate*, WebView* web_view) override {
2069     web_view->mainFrame()->executeScript(
2070         WebScriptSource(WebString::fromUTF8(script_)));
2071     return false;
2072   }
2073
2074  private:
2075   std::string script_;
2076 };
2077
2078 void TestRunner::QueueNonLoadingScript(const std::string& script) {
2079   work_queue_.AddWork(new WorkItemNonLoadingScript(script));
2080 }
2081
2082 class WorkItemLoad : public TestRunner::WorkItem {
2083  public:
2084   WorkItemLoad(const WebURL& url, const std::string& target)
2085       : url_(url), target_(target) {}
2086
2087   bool Run(WebTestDelegate* delegate, WebView*) override {
2088     delegate->LoadURLForFrame(url_, target_);
2089     return true; // FIXME: Did it really start a navigation?
2090   }
2091
2092  private:
2093   WebURL url_;
2094   std::string target_;
2095 };
2096
2097 void TestRunner::QueueLoad(const std::string& url, const std::string& target) {
2098   // FIXME: Implement WebURL::resolve() and avoid GURL.
2099   GURL current_url = web_view_->mainFrame()->document().url();
2100   GURL full_url = current_url.Resolve(url);
2101   work_queue_.AddWork(new WorkItemLoad(full_url, target));
2102 }
2103
2104 class WorkItemLoadHTMLString : public TestRunner::WorkItem  {
2105  public:
2106   WorkItemLoadHTMLString(const std::string& html, const WebURL& base_url)
2107       : html_(html), base_url_(base_url) {}
2108
2109   WorkItemLoadHTMLString(const std::string& html, const WebURL& base_url,
2110                          const WebURL& unreachable_url)
2111       : html_(html), base_url_(base_url), unreachable_url_(unreachable_url) {}
2112
2113   bool Run(WebTestDelegate*, WebView* web_view) override {
2114     web_view->mainFrame()->loadHTMLString(
2115         WebData(html_.data(), html_.length()),
2116         base_url_, unreachable_url_);
2117     return true;
2118   }
2119
2120  private:
2121   std::string html_;
2122   WebURL base_url_;
2123   WebURL unreachable_url_;
2124 };
2125
2126 void TestRunner::QueueLoadHTMLString(gin::Arguments* args) {
2127   std::string html;
2128   args->GetNext(&html);
2129
2130   std::string base_url_str;
2131   args->GetNext(&base_url_str);
2132   WebURL base_url = WebURL(GURL(base_url_str));
2133
2134   if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsString()) {
2135     std::string unreachable_url_str;
2136     args->GetNext(&unreachable_url_str);
2137     WebURL unreachable_url = WebURL(GURL(unreachable_url_str));
2138     work_queue_.AddWork(new WorkItemLoadHTMLString(html, base_url,
2139                                                    unreachable_url));
2140   } else {
2141     work_queue_.AddWork(new WorkItemLoadHTMLString(html, base_url));
2142   }
2143 }
2144
2145 void TestRunner::SetCustomPolicyDelegate(gin::Arguments* args) {
2146   args->GetNext(&policy_delegate_enabled_);
2147   if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsBoolean())
2148     args->GetNext(&policy_delegate_is_permissive_);
2149 }
2150
2151 void TestRunner::WaitForPolicyDelegate() {
2152   policy_delegate_enabled_ = true;
2153   policy_delegate_should_notify_done_ = true;
2154   wait_until_done_ = true;
2155 }
2156
2157 int TestRunner::WindowCount() {
2158   return test_interfaces_->GetWindowList().size();
2159 }
2160
2161 void TestRunner::SetCloseRemainingWindowsWhenComplete(
2162     bool close_remaining_windows) {
2163   close_remaining_windows_ = close_remaining_windows;
2164 }
2165
2166 void TestRunner::ResetTestHelperControllers() {
2167   test_interfaces_->ResetTestHelperControllers();
2168 }
2169
2170 void TestRunner::SetTabKeyCyclesThroughElements(
2171     bool tab_key_cycles_through_elements) {
2172   web_view_->setTabKeyCyclesThroughElements(tab_key_cycles_through_elements);
2173 }
2174
2175 void TestRunner::ExecCommand(gin::Arguments* args) {
2176   std::string command;
2177   args->GetNext(&command);
2178
2179   std::string value;
2180   if (args->Length() >= 3) {
2181     // Ignore the second parameter (which is userInterface)
2182     // since this command emulates a manual action.
2183     args->Skip();
2184     args->GetNext(&value);
2185   }
2186
2187   // Note: webkit's version does not return the boolean, so neither do we.
2188   web_view_->focusedFrame()->executeCommand(WebString::fromUTF8(command),
2189                                             WebString::fromUTF8(value));
2190 }
2191
2192 bool TestRunner::IsCommandEnabled(const std::string& command) {
2193   return web_view_->focusedFrame()->isCommandEnabled(
2194       WebString::fromUTF8(command));
2195 }
2196
2197 bool TestRunner::CallShouldCloseOnWebView() {
2198   return web_view_->mainFrame()->dispatchBeforeUnloadEvent();
2199 }
2200
2201 void TestRunner::SetDomainRelaxationForbiddenForURLScheme(
2202     bool forbidden, const std::string& scheme) {
2203   web_view_->setDomainRelaxationForbidden(forbidden,
2204                                           WebString::fromUTF8(scheme));
2205 }
2206
2207 v8::Local<v8::Value> TestRunner::EvaluateScriptInIsolatedWorldAndReturnValue(
2208     int world_id,
2209     const std::string& script) {
2210   WebVector<v8::Local<v8::Value>> values;
2211   WebScriptSource source(WebString::fromUTF8(script));
2212   // This relies on the iframe focusing itself when it loads. This is a bit
2213   // sketchy, but it seems to be what other tests do.
2214   web_view_->focusedFrame()->executeScriptInIsolatedWorld(
2215       world_id, &source, 1, 1, &values);
2216   // Since only one script was added, only one result is expected
2217   if (values.size() == 1 && !values[0].IsEmpty())
2218     return values[0];
2219   return v8::Local<v8::Value>();
2220 }
2221
2222 void TestRunner::EvaluateScriptInIsolatedWorld(int world_id,
2223                                                const std::string& script) {
2224   WebScriptSource source(WebString::fromUTF8(script));
2225   web_view_->focusedFrame()->executeScriptInIsolatedWorld(
2226       world_id, &source, 1, 1);
2227 }
2228
2229 void TestRunner::SetIsolatedWorldSecurityOrigin(int world_id,
2230                                                 v8::Local<v8::Value> origin) {
2231   if (!(origin->IsString() || !origin->IsNull()))
2232     return;
2233
2234   WebSecurityOrigin web_origin;
2235   if (origin->IsString()) {
2236     web_origin = WebSecurityOrigin::createFromString(
2237         V8StringToWebString(origin.As<v8::String>()));
2238   }
2239   web_view_->focusedFrame()->setIsolatedWorldSecurityOrigin(world_id,
2240                                                             web_origin);
2241 }
2242
2243 void TestRunner::SetIsolatedWorldContentSecurityPolicy(
2244     int world_id,
2245     const std::string& policy) {
2246   web_view_->focusedFrame()->setIsolatedWorldContentSecurityPolicy(
2247       world_id, WebString::fromUTF8(policy));
2248 }
2249
2250 void TestRunner::AddOriginAccessWhitelistEntry(
2251     const std::string& source_origin,
2252     const std::string& destination_protocol,
2253     const std::string& destination_host,
2254     bool allow_destination_subdomains) {
2255   WebURL url((GURL(source_origin)));
2256   if (!url.isValid())
2257     return;
2258
2259   WebSecurityPolicy::addOriginAccessWhitelistEntry(
2260       url,
2261       WebString::fromUTF8(destination_protocol),
2262       WebString::fromUTF8(destination_host),
2263       allow_destination_subdomains);
2264 }
2265
2266 void TestRunner::RemoveOriginAccessWhitelistEntry(
2267     const std::string& source_origin,
2268     const std::string& destination_protocol,
2269     const std::string& destination_host,
2270     bool allow_destination_subdomains) {
2271   WebURL url((GURL(source_origin)));
2272   if (!url.isValid())
2273     return;
2274
2275   WebSecurityPolicy::removeOriginAccessWhitelistEntry(
2276       url,
2277       WebString::fromUTF8(destination_protocol),
2278       WebString::fromUTF8(destination_host),
2279       allow_destination_subdomains);
2280 }
2281
2282 bool TestRunner::HasCustomPageSizeStyle(int page_index) {
2283   WebFrame* frame = web_view_->mainFrame();
2284   if (!frame)
2285     return false;
2286   return frame->hasCustomPageSizeStyle(page_index);
2287 }
2288
2289 void TestRunner::ForceRedSelectionColors() {
2290   web_view_->setSelectionColors(0xffee0000, 0xff00ee00, 0xff000000, 0xffc0c0c0);
2291 }
2292
2293 void TestRunner::InsertStyleSheet(const std::string& source_code) {
2294   WebLocalFrame::frameForCurrentContext()->document().insertStyleSheet(
2295       WebString::fromUTF8(source_code));
2296 }
2297
2298 bool TestRunner::FindString(const std::string& search_text,
2299                             const std::vector<std::string>& options_array) {
2300   WebFindOptions find_options;
2301   bool wrap_around = false;
2302   find_options.matchCase = true;
2303   find_options.findNext = true;
2304
2305   for (const std::string& option : options_array) {
2306     if (option == "CaseInsensitive")
2307       find_options.matchCase = false;
2308     else if (option == "Backwards")
2309       find_options.forward = false;
2310     else if (option == "StartInSelection")
2311       find_options.findNext = false;
2312     else if (option == "AtWordStarts")
2313       find_options.wordStart = true;
2314     else if (option == "TreatMedialCapitalAsWordStart")
2315       find_options.medialCapitalAsWordStart = true;
2316     else if (option == "WrapAround")
2317       wrap_around = true;
2318   }
2319
2320   WebFrame* frame = web_view_->mainFrame();
2321   const bool find_result = frame->find(0, WebString::fromUTF8(search_text),
2322                                        find_options, wrap_around, 0);
2323   frame->stopFinding(false);
2324   return find_result;
2325 }
2326
2327 std::string TestRunner::SelectionAsMarkup() {
2328   return web_view_->mainFrame()->selectionAsMarkup().utf8();
2329 }
2330
2331 void TestRunner::SetTextSubpixelPositioning(bool value) {
2332 #if defined(__linux__) || defined(ANDROID)
2333   // Since FontConfig doesn't provide a variable to control subpixel
2334   // positioning, we'll fall back to setting it globally for all fonts.
2335   WebFontRendering::setSubpixelPositioning(value);
2336 #endif
2337 }
2338
2339 void TestRunner::SetPageVisibility(const std::string& new_visibility) {
2340   if (new_visibility == "visible")
2341     web_view_->setVisibilityState(WebPageVisibilityStateVisible, false);
2342   else if (new_visibility == "hidden")
2343     web_view_->setVisibilityState(WebPageVisibilityStateHidden, false);
2344   else if (new_visibility == "prerender")
2345     web_view_->setVisibilityState(WebPageVisibilityStatePrerender, false);
2346 }
2347
2348 void TestRunner::SetTextDirection(const std::string& direction_name) {
2349   // Map a direction name to a WebTextDirection value.
2350   WebTextDirection direction;
2351   if (direction_name == "auto")
2352     direction = WebTextDirectionDefault;
2353   else if (direction_name == "rtl")
2354     direction = WebTextDirectionRightToLeft;
2355   else if (direction_name == "ltr")
2356     direction = WebTextDirectionLeftToRight;
2357   else
2358     return;
2359
2360   web_view_->setTextDirection(direction);
2361 }
2362
2363 void TestRunner::UseUnfortunateSynchronousResizeMode() {
2364   delegate_->UseUnfortunateSynchronousResizeMode(true);
2365 }
2366
2367 bool TestRunner::EnableAutoResizeMode(int min_width,
2368                                       int min_height,
2369                                       int max_width,
2370                                       int max_height) {
2371   WebSize min_size(min_width, min_height);
2372   WebSize max_size(max_width, max_height);
2373   delegate_->EnableAutoResizeMode(min_size, max_size);
2374   return true;
2375 }
2376
2377 bool TestRunner::DisableAutoResizeMode(int new_width, int new_height) {
2378   WebSize new_size(new_width, new_height);
2379   delegate_->DisableAutoResizeMode(new_size);
2380   return true;
2381 }
2382
2383 void TestRunner::SetMockDeviceLight(double value) {
2384   delegate_->SetDeviceLightData(value);
2385 }
2386
2387 void TestRunner::ResetDeviceLight() {
2388   delegate_->SetDeviceLightData(-1);
2389 }
2390
2391 void TestRunner::SetMockDeviceMotion(
2392     bool has_acceleration_x, double acceleration_x,
2393     bool has_acceleration_y, double acceleration_y,
2394     bool has_acceleration_z, double acceleration_z,
2395     bool has_acceleration_including_gravity_x,
2396     double acceleration_including_gravity_x,
2397     bool has_acceleration_including_gravity_y,
2398     double acceleration_including_gravity_y,
2399     bool has_acceleration_including_gravity_z,
2400     double acceleration_including_gravity_z,
2401     bool has_rotation_rate_alpha, double rotation_rate_alpha,
2402     bool has_rotation_rate_beta, double rotation_rate_beta,
2403     bool has_rotation_rate_gamma, double rotation_rate_gamma,
2404     double interval) {
2405   WebDeviceMotionData motion;
2406
2407   // acceleration
2408   motion.hasAccelerationX = has_acceleration_x;
2409   motion.accelerationX = acceleration_x;
2410   motion.hasAccelerationY = has_acceleration_y;
2411   motion.accelerationY = acceleration_y;
2412   motion.hasAccelerationZ = has_acceleration_z;
2413   motion.accelerationZ = acceleration_z;
2414
2415   // accelerationIncludingGravity
2416   motion.hasAccelerationIncludingGravityX =
2417       has_acceleration_including_gravity_x;
2418   motion.accelerationIncludingGravityX = acceleration_including_gravity_x;
2419   motion.hasAccelerationIncludingGravityY =
2420       has_acceleration_including_gravity_y;
2421   motion.accelerationIncludingGravityY = acceleration_including_gravity_y;
2422   motion.hasAccelerationIncludingGravityZ =
2423       has_acceleration_including_gravity_z;
2424   motion.accelerationIncludingGravityZ = acceleration_including_gravity_z;
2425
2426   // rotationRate
2427   motion.hasRotationRateAlpha = has_rotation_rate_alpha;
2428   motion.rotationRateAlpha = rotation_rate_alpha;
2429   motion.hasRotationRateBeta = has_rotation_rate_beta;
2430   motion.rotationRateBeta = rotation_rate_beta;
2431   motion.hasRotationRateGamma = has_rotation_rate_gamma;
2432   motion.rotationRateGamma = rotation_rate_gamma;
2433
2434   // interval
2435   motion.interval = interval;
2436
2437   delegate_->SetDeviceMotionData(motion);
2438 }
2439
2440 void TestRunner::SetMockDeviceOrientation(bool has_alpha, double alpha,
2441                                           bool has_beta, double beta,
2442                                           bool has_gamma, double gamma,
2443                                           bool has_absolute, bool absolute) {
2444   WebDeviceOrientationData orientation;
2445
2446   // alpha
2447   orientation.hasAlpha = has_alpha;
2448   orientation.alpha = alpha;
2449
2450   // beta
2451   orientation.hasBeta = has_beta;
2452   orientation.beta = beta;
2453
2454   // gamma
2455   orientation.hasGamma = has_gamma;
2456   orientation.gamma = gamma;
2457
2458   // absolute
2459   orientation.hasAbsolute = has_absolute;
2460   orientation.absolute = absolute;
2461
2462   delegate_->SetDeviceOrientationData(orientation);
2463 }
2464
2465 void TestRunner::SetMockScreenOrientation(const std::string& orientation_str) {
2466   blink::WebScreenOrientationType orientation;
2467
2468   if (orientation_str == "portrait-primary") {
2469     orientation = WebScreenOrientationPortraitPrimary;
2470   } else if (orientation_str == "portrait-secondary") {
2471     orientation = WebScreenOrientationPortraitSecondary;
2472   } else if (orientation_str == "landscape-primary") {
2473     orientation = WebScreenOrientationLandscapePrimary;
2474   } else if (orientation_str == "landscape-secondary") {
2475     orientation = WebScreenOrientationLandscapeSecondary;
2476   }
2477
2478   delegate_->SetScreenOrientation(orientation);
2479 }
2480
2481 void TestRunner::DidChangeBatteryStatus(bool charging,
2482                                         double chargingTime,
2483                                         double dischargingTime,
2484                                         double level) {
2485   blink::WebBatteryStatus status;
2486   status.charging = charging;
2487   status.chargingTime = chargingTime;
2488   status.dischargingTime = dischargingTime;
2489   status.level = level;
2490   delegate_->DidChangeBatteryStatus(status);
2491 }
2492
2493 void TestRunner::ResetBatteryStatus() {
2494   blink::WebBatteryStatus status;
2495   delegate_->DidChangeBatteryStatus(status);
2496 }
2497
2498 void TestRunner::DidAcquirePointerLock() {
2499   DidAcquirePointerLockInternal();
2500 }
2501
2502 void TestRunner::DidNotAcquirePointerLock() {
2503   DidNotAcquirePointerLockInternal();
2504 }
2505
2506 void TestRunner::DidLosePointerLock() {
2507   DidLosePointerLockInternal();
2508 }
2509
2510 void TestRunner::SetPointerLockWillFailSynchronously() {
2511   pointer_lock_planned_result_ = PointerLockWillFailSync;
2512 }
2513
2514 void TestRunner::SetPointerLockWillRespondAsynchronously() {
2515   pointer_lock_planned_result_ = PointerLockWillRespondAsync;
2516 }
2517
2518 void TestRunner::SetPopupBlockingEnabled(bool block_popups) {
2519   delegate_->Preferences()->java_script_can_open_windows_automatically =
2520       !block_popups;
2521   delegate_->ApplyPreferences();
2522 }
2523
2524 void TestRunner::SetJavaScriptCanAccessClipboard(bool can_access) {
2525   delegate_->Preferences()->java_script_can_access_clipboard = can_access;
2526   delegate_->ApplyPreferences();
2527 }
2528
2529 void TestRunner::SetXSSAuditorEnabled(bool enabled) {
2530   delegate_->Preferences()->xss_auditor_enabled = enabled;
2531   delegate_->ApplyPreferences();
2532 }
2533
2534 void TestRunner::SetAllowUniversalAccessFromFileURLs(bool allow) {
2535   delegate_->Preferences()->allow_universal_access_from_file_urls = allow;
2536   delegate_->ApplyPreferences();
2537 }
2538
2539 void TestRunner::SetAllowFileAccessFromFileURLs(bool allow) {
2540   delegate_->Preferences()->allow_file_access_from_file_urls = allow;
2541   delegate_->ApplyPreferences();
2542 }
2543
2544 void TestRunner::OverridePreference(const std::string key,
2545                                     v8::Local<v8::Value> value) {
2546   TestPreferences* prefs = delegate_->Preferences();
2547   if (key == "WebKitDefaultFontSize") {
2548     prefs->default_font_size = value->Int32Value();
2549   } else if (key == "WebKitMinimumFontSize") {
2550     prefs->minimum_font_size = value->Int32Value();
2551   } else if (key == "WebKitDefaultTextEncodingName") {
2552     v8::Isolate* isolate = blink::mainThreadIsolate();
2553     prefs->default_text_encoding_name =
2554         V8StringToWebString(value->ToString(isolate));
2555   } else if (key == "WebKitJavaScriptEnabled") {
2556     prefs->java_script_enabled = value->BooleanValue();
2557   } else if (key == "WebKitSupportsMultipleWindows") {
2558     prefs->supports_multiple_windows = value->BooleanValue();
2559   } else if (key == "WebKitDisplayImagesKey") {
2560     prefs->loads_images_automatically = value->BooleanValue();
2561   } else if (key == "WebKitPluginsEnabled") {
2562     prefs->plugins_enabled = value->BooleanValue();
2563   } else if (key == "WebKitJavaEnabled") {
2564     prefs->java_enabled = value->BooleanValue();
2565   } else if (key == "WebKitOfflineWebApplicationCacheEnabled") {
2566     prefs->offline_web_application_cache_enabled = value->BooleanValue();
2567   } else if (key == "WebKitTabToLinksPreferenceKey") {
2568     prefs->tabs_to_links = value->BooleanValue();
2569   } else if (key == "WebKitWebGLEnabled") {
2570     prefs->experimental_webgl_enabled = value->BooleanValue();
2571   } else if (key == "WebKitCSSRegionsEnabled") {
2572     prefs->experimental_css_regions_enabled = value->BooleanValue();
2573   } else if (key == "WebKitCSSGridLayoutEnabled") {
2574     prefs->experimental_css_grid_layout_enabled = value->BooleanValue();
2575   } else if (key == "WebKitHyperlinkAuditingEnabled") {
2576     prefs->hyperlink_auditing_enabled = value->BooleanValue();
2577   } else if (key == "WebKitEnableCaretBrowsing") {
2578     prefs->caret_browsing_enabled = value->BooleanValue();
2579   } else if (key == "WebKitAllowDisplayingInsecureContent") {
2580     prefs->allow_display_of_insecure_content = value->BooleanValue();
2581   } else if (key == "WebKitAllowRunningInsecureContent") {
2582     prefs->allow_running_of_insecure_content = value->BooleanValue();
2583   } else if (key == "WebKitDisableReadingFromCanvas") {
2584     prefs->disable_reading_from_canvas = value->BooleanValue();
2585   } else if (key == "WebKitStrictMixedContentChecking") {
2586     prefs->strict_mixed_content_checking = value->BooleanValue();
2587   } else if (key == "WebKitStrictPowerfulFeatureRestrictions") {
2588     prefs->strict_powerful_feature_restrictions = value->BooleanValue();
2589   } else if (key == "WebKitShouldRespectImageOrientation") {
2590     prefs->should_respect_image_orientation = value->BooleanValue();
2591   } else if (key == "WebKitWebAudioEnabled") {
2592     DCHECK(value->BooleanValue());
2593   } else if (key == "WebKitWebSecurityEnabled") {
2594     prefs->web_security_enabled = value->BooleanValue();
2595   } else {
2596     std::string message("Invalid name for preference: ");
2597     message.append(key);
2598     delegate_->PrintMessage(std::string("CONSOLE MESSAGE: ") + message + "\n");
2599   }
2600   delegate_->ApplyPreferences();
2601 }
2602
2603 void TestRunner::SetAcceptLanguages(const std::string& accept_languages) {
2604   proxy_->SetAcceptLanguages(accept_languages);
2605 }
2606
2607 void TestRunner::SetPluginsEnabled(bool enabled) {
2608   delegate_->Preferences()->plugins_enabled = enabled;
2609   delegate_->ApplyPreferences();
2610 }
2611
2612 void TestRunner::DumpEditingCallbacks() {
2613   dump_editting_callbacks_ = true;
2614 }
2615
2616 void TestRunner::DumpAsMarkup() {
2617   dump_as_markup_ = true;
2618   generate_pixel_results_ = false;
2619 }
2620
2621 void TestRunner::DumpAsText() {
2622   dump_as_text_ = true;
2623   generate_pixel_results_ = false;
2624 }
2625
2626 void TestRunner::DumpAsTextWithPixelResults() {
2627   dump_as_text_ = true;
2628   generate_pixel_results_ = true;
2629 }
2630
2631 void TestRunner::DumpChildFrameScrollPositions() {
2632   dump_child_frame_scroll_positions_ = true;
2633 }
2634
2635 void TestRunner::DumpChildFramesAsMarkup() {
2636   dump_child_frames_as_markup_ = true;
2637 }
2638
2639 void TestRunner::DumpChildFramesAsText() {
2640   dump_child_frames_as_text_ = true;
2641 }
2642
2643 void TestRunner::DumpIconChanges() {
2644   dump_icon_changes_ = true;
2645 }
2646
2647 void TestRunner::SetAudioData(const gin::ArrayBufferView& view) {
2648   unsigned char* bytes = static_cast<unsigned char*>(view.bytes());
2649   audio_data_.resize(view.num_bytes());
2650   std::copy(bytes, bytes + view.num_bytes(), audio_data_.begin());
2651   dump_as_audio_ = true;
2652 }
2653
2654 void TestRunner::DumpFrameLoadCallbacks() {
2655   dump_frame_load_callbacks_ = true;
2656 }
2657
2658 void TestRunner::DumpPingLoaderCallbacks() {
2659   dump_ping_loader_callbacks_ = true;
2660 }
2661
2662 void TestRunner::DumpUserGestureInFrameLoadCallbacks() {
2663   dump_user_gesture_in_frame_load_callbacks_ = true;
2664 }
2665
2666 void TestRunner::DumpTitleChanges() {
2667   dump_title_changes_ = true;
2668 }
2669
2670 void TestRunner::DumpCreateView() {
2671   dump_create_view_ = true;
2672 }
2673
2674 void TestRunner::SetCanOpenWindows() {
2675   can_open_windows_ = true;
2676 }
2677
2678 void TestRunner::DumpResourceLoadCallbacks() {
2679   dump_resource_load_callbacks_ = true;
2680 }
2681
2682 void TestRunner::DumpResourceRequestCallbacks() {
2683   dump_resource_request_callbacks_ = true;
2684 }
2685
2686 void TestRunner::DumpResourceResponseMIMETypes() {
2687   dump_resource_response_mime_types_ = true;
2688 }
2689
2690 void TestRunner::SetImagesAllowed(bool allowed) {
2691   web_content_settings_->SetImagesAllowed(allowed);
2692 }
2693
2694 void TestRunner::SetMediaAllowed(bool allowed) {
2695   web_content_settings_->SetMediaAllowed(allowed);
2696 }
2697
2698 void TestRunner::SetScriptsAllowed(bool allowed) {
2699   web_content_settings_->SetScriptsAllowed(allowed);
2700 }
2701
2702 void TestRunner::SetStorageAllowed(bool allowed) {
2703   web_content_settings_->SetStorageAllowed(allowed);
2704 }
2705
2706 void TestRunner::SetPluginsAllowed(bool allowed) {
2707   web_content_settings_->SetPluginsAllowed(allowed);
2708 }
2709
2710 void TestRunner::SetAllowDisplayOfInsecureContent(bool allowed) {
2711   web_content_settings_->SetDisplayingInsecureContentAllowed(allowed);
2712 }
2713
2714 void TestRunner::SetAllowRunningOfInsecureContent(bool allowed) {
2715   web_content_settings_->SetRunningInsecureContentAllowed(allowed);
2716 }
2717
2718 void TestRunner::DumpPermissionClientCallbacks() {
2719   web_content_settings_->SetDumpCallbacks(true);
2720 }
2721
2722 void TestRunner::DumpWindowStatusChanges() {
2723   dump_window_status_changes_ = true;
2724 }
2725
2726 void TestRunner::DumpProgressFinishedCallback() {
2727   dump_progress_finished_callback_ = true;
2728 }
2729
2730 void TestRunner::DumpSpellCheckCallbacks() {
2731   dump_spell_check_callbacks_ = true;
2732 }
2733
2734 void TestRunner::DumpBackForwardList() {
2735   dump_back_forward_list_ = true;
2736 }
2737
2738 void TestRunner::DumpSelectionRect() {
2739   dump_selection_rect_ = true;
2740 }
2741
2742 void TestRunner::SetPrinting() {
2743   is_printing_ = true;
2744 }
2745
2746 void TestRunner::ClearPrinting() {
2747   is_printing_ = false;
2748 }
2749
2750 void TestRunner::SetShouldStayOnPageAfterHandlingBeforeUnload(bool value) {
2751   should_stay_on_page_after_handling_before_unload_ = value;
2752 }
2753
2754 void TestRunner::SetWillSendRequestClearHeader(const std::string& header) {
2755   if (!header.empty())
2756     http_headers_to_clear_.insert(header);
2757 }
2758
2759 void TestRunner::DumpResourceRequestPriorities() {
2760   should_dump_resource_priorities_ = true;
2761 }
2762
2763 void TestRunner::SetUseMockTheme(bool use) {
2764   use_mock_theme_ = use;
2765 }
2766
2767 void TestRunner::ShowWebInspector(const std::string& str,
2768                                   const std::string& frontend_url) {
2769   ShowDevTools(str, frontend_url);
2770 }
2771
2772 void TestRunner::WaitUntilExternalURLLoad() {
2773   wait_until_external_url_load_ = true;
2774 }
2775
2776 void TestRunner::DumpDragImage() {
2777   DumpAsTextWithPixelResults();
2778   dump_drag_image_ = true;
2779 }
2780
2781 void TestRunner::DumpNavigationPolicy() {
2782   dump_navigation_policy_ = true;
2783 }
2784
2785 void TestRunner::CloseWebInspector() {
2786   delegate_->CloseDevTools();
2787 }
2788
2789 bool TestRunner::IsChooserShown() {
2790   return proxy_->IsChooserShown();
2791 }
2792
2793 void TestRunner::EvaluateInWebInspector(int call_id,
2794                                         const std::string& script) {
2795   delegate_->EvaluateInWebInspector(call_id, script);
2796 }
2797
2798 void TestRunner::ClearAllDatabases() {
2799   delegate_->ClearAllDatabases();
2800 }
2801
2802 void TestRunner::SetDatabaseQuota(int quota) {
2803   delegate_->SetDatabaseQuota(quota);
2804 }
2805
2806 void TestRunner::SetAlwaysAcceptCookies(bool accept) {
2807   delegate_->SetAcceptAllCookies(accept);
2808 }
2809
2810 void TestRunner::SetWindowIsKey(bool value) {
2811   delegate_->SetFocus(proxy_, value);
2812 }
2813
2814 std::string TestRunner::PathToLocalResource(const std::string& path) {
2815   return delegate_->PathToLocalResource(path);
2816 }
2817
2818 void TestRunner::SetBackingScaleFactor(double value,
2819                                        v8::Local<v8::Function> callback) {
2820   delegate_->SetDeviceScaleFactor(value);
2821   delegate_->PostTask(new InvokeCallbackTask(this, callback));
2822 }
2823
2824 void TestRunner::SetColorProfile(const std::string& name,
2825                                  v8::Local<v8::Function> callback) {
2826   delegate_->SetDeviceColorProfile(name);
2827   delegate_->PostTask(new InvokeCallbackTask(this, callback));
2828 }
2829
2830 void TestRunner::SetBluetoothMockDataSet(const std::string& name) {
2831   delegate_->SetBluetoothMockDataSet(name);
2832 }
2833
2834 void TestRunner::SetGeofencingMockProvider(bool service_available) {
2835   delegate_->SetGeofencingMockProvider(service_available);
2836 }
2837
2838 void TestRunner::ClearGeofencingMockProvider() {
2839   delegate_->ClearGeofencingMockProvider();
2840 }
2841
2842 void TestRunner::SetGeofencingMockPosition(double latitude, double longitude) {
2843   delegate_->SetGeofencingMockPosition(latitude, longitude);
2844 }
2845
2846 void TestRunner::SetPermission(const std::string& name,
2847                                const std::string& value,
2848                                const GURL& origin,
2849                                const GURL& embedding_origin) {
2850   delegate_->SetPermission(name, value, origin, embedding_origin);
2851 }
2852
2853 void TestRunner::DispatchBeforeInstallPromptEvent(
2854     int request_id,
2855     const std::vector<std::string>& event_platforms,
2856     v8::Local<v8::Function> callback) {
2857   scoped_ptr<InvokeCallbackTask> task(
2858       new InvokeCallbackTask(this, callback));
2859
2860   delegate_->DispatchBeforeInstallPromptEvent(
2861       request_id, event_platforms,
2862       base::Bind(&TestRunner::DispatchBeforeInstallPromptCallback,
2863                  weak_factory_.GetWeakPtr(), base::Passed(&task)));
2864 }
2865
2866 void TestRunner::ResolveBeforeInstallPromptPromise(
2867     int request_id,
2868     const std::string& platform) {
2869   delegate_->ResolveBeforeInstallPromptPromise(request_id, platform);
2870 }
2871
2872 void TestRunner::SetPOSIXLocale(const std::string& locale) {
2873   delegate_->SetLocale(locale);
2874 }
2875
2876 void TestRunner::SetMIDIAccessorResult(bool result) {
2877   midi_accessor_result_ = result;
2878 }
2879
2880 void TestRunner::SimulateWebNotificationClick(const std::string& title) {
2881   delegate_->SimulateWebNotificationClick(title);
2882 }
2883
2884 void TestRunner::AddMockSpeechRecognitionResult(const std::string& transcript,
2885                                                 double confidence) {
2886   proxy_->GetSpeechRecognizerMock()->AddMockResult(
2887       WebString::fromUTF8(transcript), confidence);
2888 }
2889
2890 void TestRunner::SetMockSpeechRecognitionError(const std::string& error,
2891                                                const std::string& message) {
2892   proxy_->GetSpeechRecognizerMock()->SetError(WebString::fromUTF8(error),
2893                                               WebString::fromUTF8(message));
2894 }
2895
2896 bool TestRunner::WasMockSpeechRecognitionAborted() {
2897   return proxy_->GetSpeechRecognizerMock()->WasAborted();
2898 }
2899
2900 void TestRunner::AddMockCredentialManagerResponse(const std::string& id,
2901                                                   const std::string& name,
2902                                                   const std::string& avatar,
2903                                                   const std::string& password) {
2904   proxy_->GetCredentialManagerClientMock()->SetResponse(
2905       new WebPasswordCredential(WebString::fromUTF8(id),
2906                                 WebString::fromUTF8(password),
2907                                 WebString::fromUTF8(name),
2908                                 WebURL(GURL(avatar))));
2909 }
2910
2911 void TestRunner::AddWebPageOverlay() {
2912   if (web_view_ && !page_overlay_) {
2913     page_overlay_ = new TestPageOverlay;
2914     web_view_->addPageOverlay(page_overlay_, 0);
2915   }
2916 }
2917
2918 void TestRunner::RemoveWebPageOverlay() {
2919   if (web_view_ && page_overlay_) {
2920     web_view_->removePageOverlay(page_overlay_);
2921     delete page_overlay_;
2922     page_overlay_ = nullptr;
2923   }
2924 }
2925
2926 void TestRunner::LayoutAndPaintAsync() {
2927   proxy_->LayoutAndPaintAsyncThen(base::Closure());
2928 }
2929
2930 void TestRunner::LayoutAndPaintAsyncThen(v8::Local<v8::Function> callback) {
2931   scoped_ptr<InvokeCallbackTask> task(
2932       new InvokeCallbackTask(this, callback));
2933   proxy_->LayoutAndPaintAsyncThen(base::Bind(&TestRunner::InvokeCallback,
2934                                              weak_factory_.GetWeakPtr(),
2935                                              base::Passed(&task)));
2936 }
2937
2938 void TestRunner::GetManifestThen(v8::Local<v8::Function> callback) {
2939   scoped_ptr<InvokeCallbackTask> task(
2940       new InvokeCallbackTask(this, callback));
2941
2942   delegate_->FetchManifest(
2943       web_view_, web_view_->mainFrame()->document().manifestURL(),
2944       base::Bind(&TestRunner::GetManifestCallback, weak_factory_.GetWeakPtr(),
2945                  base::Passed(&task)));
2946 }
2947
2948 void TestRunner::CapturePixelsAsyncThen(v8::Local<v8::Function> callback) {
2949   scoped_ptr<InvokeCallbackTask> task(
2950       new InvokeCallbackTask(this, callback));
2951   proxy_->CapturePixelsAsync(base::Bind(&TestRunner::CapturePixelsCallback,
2952                                         weak_factory_.GetWeakPtr(),
2953                                         base::Passed(&task)));
2954 }
2955
2956 void TestRunner::ForceNextWebGLContextCreationToFail() {
2957   if (web_view_)
2958     web_view_->forceNextWebGLContextCreationToFail();
2959 }
2960
2961 void TestRunner::ForceNextDrawingBufferCreationToFail() {
2962   if (web_view_)
2963     web_view_->forceNextDrawingBufferCreationToFail();
2964 }
2965
2966 void TestRunner::CopyImageAtAndCapturePixelsAsyncThen(
2967     int x, int y, v8::Local<v8::Function> callback) {
2968   scoped_ptr<InvokeCallbackTask> task(
2969       new InvokeCallbackTask(this, callback));
2970   proxy_->CopyImageAtAndCapturePixels(
2971       x, y, base::Bind(&TestRunner::CapturePixelsCallback,
2972                        weak_factory_.GetWeakPtr(),
2973                        base::Passed(&task)));
2974 }
2975
2976 void TestRunner::GetManifestCallback(scoped_ptr<InvokeCallbackTask> task,
2977                                      const blink::WebURLResponse& response,
2978                                      const std::string& data) {
2979   InvokeCallback(task.Pass());
2980 }
2981
2982 void TestRunner::CapturePixelsCallback(scoped_ptr<InvokeCallbackTask> task,
2983                                        const SkBitmap& snapshot) {
2984   v8::Isolate* isolate = blink::mainThreadIsolate();
2985   v8::HandleScope handle_scope(isolate);
2986
2987   v8::Local<v8::Context> context =
2988       web_view_->mainFrame()->mainWorldScriptContext();
2989   if (context.IsEmpty())
2990     return;
2991
2992   v8::Context::Scope context_scope(context);
2993   v8::Local<v8::Value> argv[3];
2994   SkAutoLockPixels snapshot_lock(snapshot);
2995
2996   // Size can be 0 for cases where copyImageAt was called on position
2997   // that doesn't have an image.
2998   int width = snapshot.info().width();
2999   argv[0] = v8::Number::New(isolate, width);
3000
3001   int height = snapshot.info().height();
3002   argv[1] = v8::Number::New(isolate, height);
3003
3004   blink::WebArrayBuffer buffer =
3005       blink::WebArrayBuffer::create(snapshot.getSize(), 1);
3006   memcpy(buffer.data(), snapshot.getPixels(), buffer.byteLength());
3007 #if (SK_R32_SHIFT == 16) && !SK_B32_SHIFT
3008   {
3009     // Skia's internal byte order is BGRA. Must swap the B and R channels in
3010     // order to provide a consistent ordering to the layout tests.
3011     unsigned char* pixels = static_cast<unsigned char*>(buffer.data());
3012     unsigned len = buffer.byteLength();
3013     for (unsigned i = 0; i < len; i += 4) {
3014       std::swap(pixels[i], pixels[i + 2]);
3015     }
3016   }
3017 #endif
3018
3019   argv[2] = blink::WebArrayBufferConverter::toV8Value(
3020       &buffer, context->Global(), isolate);
3021
3022   task->SetArguments(3, argv);
3023   InvokeCallback(task.Pass());
3024 }
3025
3026 void TestRunner::DispatchBeforeInstallPromptCallback(
3027     scoped_ptr<InvokeCallbackTask> task,
3028     bool canceled) {
3029   v8::Isolate* isolate = blink::mainThreadIsolate();
3030   v8::HandleScope handle_scope(isolate);
3031
3032   v8::Local<v8::Context> context =
3033       web_view_->mainFrame()->mainWorldScriptContext();
3034   if (context.IsEmpty())
3035     return;
3036
3037   v8::Context::Scope context_scope(context);
3038   v8::Local<v8::Value> argv[1];
3039   argv[0] = v8::Boolean::New(isolate, canceled);
3040
3041   task->SetArguments(1, argv);
3042   InvokeCallback(task.Pass());
3043 }
3044
3045 void TestRunner::LocationChangeDone() {
3046   web_history_item_count_ = delegate_->NavigationEntryCount();
3047
3048   // No more new work after the first complete load.
3049   work_queue_.set_frozen(true);
3050
3051   if (!wait_until_done_)
3052     work_queue_.ProcessWorkSoon();
3053 }
3054
3055 void TestRunner::CheckResponseMimeType() {
3056   // Text output: the test page can request different types of output which we
3057   // handle here.
3058   if (!dump_as_text_) {
3059     std::string mimeType =
3060         web_view_->mainFrame()->dataSource()->response().mimeType().utf8();
3061     if (mimeType == "text/plain") {
3062       dump_as_text_ = true;
3063       generate_pixel_results_ = false;
3064     }
3065   }
3066 }
3067
3068 void TestRunner::CompleteNotifyDone() {
3069   if (wait_until_done_ && !topLoadingFrame() && work_queue_.is_empty())
3070     delegate_->TestFinished();
3071   wait_until_done_ = false;
3072 }
3073
3074 void TestRunner::DidAcquirePointerLockInternal() {
3075   pointer_locked_ = true;
3076   web_view_->didAcquirePointerLock();
3077
3078   // Reset planned result to default.
3079   pointer_lock_planned_result_ = PointerLockWillSucceed;
3080 }
3081
3082 void TestRunner::DidNotAcquirePointerLockInternal() {
3083   DCHECK(!pointer_locked_);
3084   pointer_locked_ = false;
3085   web_view_->didNotAcquirePointerLock();
3086
3087   // Reset planned result to default.
3088   pointer_lock_planned_result_ = PointerLockWillSucceed;
3089 }
3090
3091 void TestRunner::DidLosePointerLockInternal() {
3092   bool was_locked = pointer_locked_;
3093   pointer_locked_ = false;
3094   if (was_locked)
3095     web_view_->didLosePointerLock();
3096 }
3097
3098 }  // namespace test_runner