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