Use correct WebView from TestRunner methods called via testRunner bindings.

components/test_runner/test_runner.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/test_runner/test_runner.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
@@ skipping 83 matching lines @@
   }
   return 1.f;
 }
 
 }  // namespace
 
 class TestRunnerBindings : public gin::Wrappable<TestRunnerBindings> {
  public:
   static gin::WrapperInfo kWrapperInfo;
 
-  static void Install(base::WeakPtr<TestRunner> controller,
-                      WebFrame* frame);
+  static void Install(base::WeakPtr<TestRunner> test_runner,
+                      base::WeakPtr<TestRunnerForSpecificView> view_test_runner,
+                      WebLocalFrame* frame);
 
  private:
   explicit TestRunnerBindings(
-      base::WeakPtr<TestRunner> controller);
+      base::WeakPtr<TestRunner> test_runner,
+      base::WeakPtr<TestRunnerForSpecificView> view_test_runner);
   ~TestRunnerBindings() override;
 
   // gin::Wrappable:
   gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate) override;
 
   void AddMockSpeechRecognitionResult(const std::string& transcript,
                                       double confidence);
   void AddOriginAccessWhitelistEntry(const std::string& source_origin,
                                      const std::string& destination_protocol,
@@ skipping 165 matching lines @@
   bool IsCommandEnabled(const std::string& command);
   std::string PathToLocalResource(const std::string& path);
   std::string PlatformName();
   std::string SelectionAsMarkup();
   std::string TooltipText();
 
   int WebHistoryItemCount();
   int WindowCount();
 
   base::WeakPtr<TestRunner> runner_;
+  base::WeakPtr<TestRunnerForSpecificView> view_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRunnerBindings);
 };
 
 gin::WrapperInfo TestRunnerBindings::kWrapperInfo = {
     gin::kEmbedderNativeGin};
 
 // static
-void TestRunnerBindings::Install(base::WeakPtr<TestRunner> runner,
-                                 WebFrame* frame) {
+void TestRunnerBindings::Install(
+    base::WeakPtr<TestRunner> test_runner,
+    base::WeakPtr<TestRunnerForSpecificView> view_test_runner,
+    WebLocalFrame* frame) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
 
-  TestRunnerBindings* wrapped = new TestRunnerBindings(runner);
+  TestRunnerBindings* wrapped =
+      new TestRunnerBindings(test_runner, view_test_runner);
   gin::Handle<TestRunnerBindings> bindings =
       gin::CreateHandle(isolate, wrapped);
   if (bindings.IsEmpty())
     return;
   v8::Local<v8::Object> global = context->Global();
   v8::Local<v8::Value> v8_bindings = bindings.ToV8();
 
   std::vector<std::string> names;
   names.push_back("testRunner");
   names.push_back("layoutTestController");
   for (size_t i = 0; i < names.size(); ++i)
     global->Set(gin::StringToV8(isolate, names[i].c_str()), v8_bindings);
 }
 
-TestRunnerBindings::TestRunnerBindings(base::WeakPtr<TestRunner> runner)
-    : runner_(runner) {}
+TestRunnerBindings::TestRunnerBindings(
+    base::WeakPtr<TestRunner> runner,
+    base::WeakPtr<TestRunnerForSpecificView> view_runner)
+    : runner_(runner), view_runner_(view_runner) {}
 
 TestRunnerBindings::~TestRunnerBindings() {}
 
 gin::ObjectTemplateBuilder TestRunnerBindings::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return gin::Wrappable<TestRunnerBindings>::GetObjectTemplateBuilder(isolate)
       .SetMethod("abortModal", &TestRunnerBindings::NotImplemented)
       .SetMethod("addDisallowedURL", &TestRunnerBindings::NotImplemented)
       .SetMethod("addMockCredentialManagerError",
                  &TestRunnerBindings::AddMockCredentialManagerError)
@@ skipping 332 matching lines @@
     runner_->SetCloseRemainingWindowsWhenComplete(close_remaining_windows);
 }
 
 void TestRunnerBindings::ResetTestHelperControllers() {
   if (runner_)
     runner_->ResetTestHelperControllers();
 }
 
 void TestRunnerBindings::SetTabKeyCyclesThroughElements(
     bool tab_key_cycles_through_elements) {
-  if (runner_)
-    runner_->SetTabKeyCyclesThroughElements(tab_key_cycles_through_elements);
+  if (view_runner_)
+    view_runner_->SetTabKeyCyclesThroughElements(
+        tab_key_cycles_through_elements);
 }
 
 void TestRunnerBindings::ExecCommand(gin::Arguments* args) {
-  if (runner_)
-    runner_->ExecCommand(args);
+  if (view_runner_)
+    view_runner_->ExecCommand(args);
 }
 
 bool TestRunnerBindings::IsCommandEnabled(const std::string& command) {
-  if (runner_)
-    return runner_->IsCommandEnabled(command);
+  if (view_runner_)
+    return view_runner_->IsCommandEnabled(command);
   return false;
 }
 
 bool TestRunnerBindings::CallShouldCloseOnWebView() {
-  if (runner_)
-    return runner_->CallShouldCloseOnWebView();
+  if (view_runner_)
+    return view_runner_->CallShouldCloseOnWebView();
   return false;
 }
 
 void TestRunnerBindings::SetDomainRelaxationForbiddenForURLScheme(
     bool forbidden, const std::string& scheme) {
-  if (runner_)
-    runner_->SetDomainRelaxationForbiddenForURLScheme(forbidden, scheme);
+  if (view_runner_)
+    view_runner_->SetDomainRelaxationForbiddenForURLScheme(forbidden, scheme);
 }
 
 v8::Local<v8::Value>
 TestRunnerBindings::EvaluateScriptInIsolatedWorldAndReturnValue(
     int world_id, const std::string& script) {
-  if (!runner_ || world_id <= 0 || world_id >= (1 << 29))
+  if (!view_runner_ || world_id <= 0 || world_id >= (1 << 29))
     return v8::Local<v8::Value>();
-  return runner_->EvaluateScriptInIsolatedWorldAndReturnValue(world_id,
-                                                              script);
+  return view_runner_->EvaluateScriptInIsolatedWorldAndReturnValue(world_id,
+                                                                   script);
 }
 
 void TestRunnerBindings::EvaluateScriptInIsolatedWorld(
     int world_id, const std::string& script) {
-  if (runner_ && world_id > 0 && world_id < (1 << 29))
-    runner_->EvaluateScriptInIsolatedWorld(world_id, script);
+  if (view_runner_ && world_id > 0 && world_id < (1 << 29))
+    view_runner_->EvaluateScriptInIsolatedWorld(world_id, script);
 }
 
 void TestRunnerBindings::SetIsolatedWorldSecurityOrigin(
     int world_id, v8::Local<v8::Value> origin) {
-  if (runner_)
-    runner_->SetIsolatedWorldSecurityOrigin(world_id, origin);
+  if (view_runner_)
+    view_runner_->SetIsolatedWorldSecurityOrigin(world_id, origin);
 }
 
 void TestRunnerBindings::SetIsolatedWorldContentSecurityPolicy(
     int world_id, const std::string& policy) {
-  if (runner_)
-    runner_->SetIsolatedWorldContentSecurityPolicy(world_id, policy);
+  if (view_runner_)
+    view_runner_->SetIsolatedWorldContentSecurityPolicy(world_id, policy);
 }
 
 void TestRunnerBindings::AddOriginAccessWhitelistEntry(
     const std::string& source_origin,
     const std::string& destination_protocol,
     const std::string& destination_host,
     bool allow_destination_subdomains) {
   if (runner_) {
     runner_->AddOriginAccessWhitelistEntry(source_origin,
                                            destination_protocol,
                                            destination_host,
                                            allow_destination_subdomains);
   }
 }
 
 void TestRunnerBindings::RemoveOriginAccessWhitelistEntry(
     const std::string& source_origin,
     const std::string& destination_protocol,
     const std::string& destination_host,
     bool allow_destination_subdomains) {
   if (runner_) {
     runner_->RemoveOriginAccessWhitelistEntry(source_origin,
                                               destination_protocol,
                                               destination_host,
                                               allow_destination_subdomains);
   }
 }
 
 bool TestRunnerBindings::HasCustomPageSizeStyle(int page_index) {
-  if (runner_)
-    return runner_->HasCustomPageSizeStyle(page_index);
+  if (view_runner_)
+    return view_runner_->HasCustomPageSizeStyle(page_index);
   return false;
 }
 
 void TestRunnerBindings::ForceRedSelectionColors() {
-  if (runner_)
-    runner_->ForceRedSelectionColors();
+  if (view_runner_)
+    view_runner_->ForceRedSelectionColors();
 }
 
 void TestRunnerBindings::InsertStyleSheet(const std::string& source_code) {
   if (runner_)
     runner_->InsertStyleSheet(source_code);
 }
 
 bool TestRunnerBindings::FindString(
     const std::string& search_text,
     const std::vector<std::string>& options_array) {
-  if (runner_)
-    return runner_->FindString(search_text, options_array);
+  if (view_runner_)
+    return view_runner_->FindString(search_text, options_array);
   return false;
 }
 
 std::string TestRunnerBindings::SelectionAsMarkup() {
-  if (runner_)
-    return runner_->SelectionAsMarkup();
+  if (view_runner_)
+    return view_runner_->SelectionAsMarkup();
   return std::string();
 }
 
 void TestRunnerBindings::SetTextSubpixelPositioning(bool value) {
   if (runner_)
     runner_->SetTextSubpixelPositioning(value);
 }
 
 void TestRunnerBindings::SetPageVisibility(const std::string& new_visibility) {
-  if (runner_)
-    runner_->SetPageVisibility(new_visibility);
+  if (view_runner_)
+    view_runner_->SetPageVisibility(new_visibility);
 }
 
 void TestRunnerBindings::SetTextDirection(const std::string& direction_name) {
-  if (runner_)
-    runner_->SetTextDirection(direction_name);
+  if (view_runner_)
+    view_runner_->SetTextDirection(direction_name);
 }
 
 void TestRunnerBindings::UseUnfortunateSynchronousResizeMode() {
   if (runner_)
     runner_->UseUnfortunateSynchronousResizeMode();
 }
 
 bool TestRunnerBindings::EnableAutoResizeMode(int min_width,
                                               int min_height,
                                               int max_width,
@@ skipping 117 matching lines @@
 
   runner_->SetMockScreenOrientation(orientation);
 }
 
 void TestRunnerBindings::DisableMockScreenOrientation() {
   if (runner_)
     runner_->DisableMockScreenOrientation();
 }
 
 void TestRunnerBindings::DidAcquirePointerLock() {
-  if (runner_)
-    runner_->DidAcquirePointerLock();
+  if (view_runner_)
+    view_runner_->DidAcquirePointerLock();
 }
 
 void TestRunnerBindings::DidNotAcquirePointerLock() {
-  if (runner_)
-    runner_->DidNotAcquirePointerLock();
+  if (view_runner_)
+    view_runner_->DidNotAcquirePointerLock();
 }
 
 void TestRunnerBindings::DidLosePointerLock() {
-  if (runner_)
-    runner_->DidLosePointerLock();
+  if (view_runner_)
+    view_runner_->DidLosePointerLock();
 }
 
 void TestRunnerBindings::SetPointerLockWillFailSynchronously() {
-  if (runner_)
-    runner_->SetPointerLockWillFailSynchronously();
+  if (view_runner_)
+    view_runner_->SetPointerLockWillFailSynchronously();
 }
 
 void TestRunnerBindings::SetPointerLockWillRespondAsynchronously() {
-  if (runner_)
-    runner_->SetPointerLockWillRespondAsynchronously();
+  if (view_runner_)
+    view_runner_->SetPointerLockWillRespondAsynchronously();
 }
 
 void TestRunnerBindings::SetPopupBlockingEnabled(bool block_popups) {
   if (runner_)
     runner_->SetPopupBlockingEnabled(block_popups);
 }
 
 void TestRunnerBindings::SetJavaScriptCanAccessClipboard(bool can_access) {
   if (runner_)
     runner_->SetJavaScriptCanAccessClipboard(can_access);
@@ skipping 226 matching lines @@
   if (runner_)
     runner_->DumpDragImage();
 }
 
 void TestRunnerBindings::DumpNavigationPolicy() {
   if (runner_)
     runner_->DumpNavigationPolicy();
 }
 
 void TestRunnerBindings::DumpPageImportanceSignals() {
-  if (runner_)
-    runner_->DumpPageImportanceSignals();
+  if (view_runner_)
+    view_runner_->DumpPageImportanceSignals();
 }
 
 void TestRunnerBindings::ShowWebInspector(gin::Arguments* args) {
   if (runner_) {
     std::string settings;
     args->GetNext(&settings);
     std::string frontend_url;
     args->GetNext(&frontend_url);
     runner_->ShowWebInspector(settings, frontend_url);
   }
@@ skipping 33 matching lines @@
   if (runner_)
     runner_->SetDatabaseQuota(quota);
 }
 
 void TestRunnerBindings::SetAlwaysAcceptCookies(bool accept) {
   if (runner_)
     runner_->SetAlwaysAcceptCookies(accept);
 }
 
 void TestRunnerBindings::SetWindowIsKey(bool value) {
-  if (runner_)
-    runner_->SetWindowIsKey(value);
+  if (view_runner_)
+    view_runner_->SetWindowIsKey(value);
 }
 
 std::string TestRunnerBindings::PathToLocalResource(const std::string& path) {
   if (runner_)
     return runner_->PathToLocalResource(path);
   return std::string();
 }
 
 void TestRunnerBindings::SetBackingScaleFactor(
     double value, v8::Local<v8::Function> callback) {
-  if (runner_)
-    runner_->SetBackingScaleFactor(value, callback);
+  if (view_runner_)
+    view_runner_->SetBackingScaleFactor(value, callback);
 }
 
 void TestRunnerBindings::EnableUseZoomForDSF(
     v8::Local<v8::Function> callback) {
-  if (runner_)
-    runner_->EnableUseZoomForDSF(callback);
+  if (view_runner_)
+    view_runner_->EnableUseZoomForDSF(callback);
 }
 
 void TestRunnerBindings::SetColorProfile(
     const std::string& name, v8::Local<v8::Function> callback) {
-  if (runner_)
-    runner_->SetColorProfile(name, callback);
+  if (view_runner_)
+    view_runner_->SetColorProfile(name, callback);
 }
 
 void TestRunnerBindings::SetBluetoothFakeAdapter(
     const std::string& adapter_name,
     v8::Local<v8::Function> callback) {
-  if (runner_)
-    runner_->SetBluetoothFakeAdapter(adapter_name, callback);
+  if (view_runner_)
+    view_runner_->SetBluetoothFakeAdapter(adapter_name, callback);
 }
 
 void TestRunnerBindings::SetBluetoothManualChooser(bool enable) {
-  if (runner_)
-    runner_->SetBluetoothManualChooser(enable);
+  if (view_runner_)
+    view_runner_->SetBluetoothManualChooser(enable);
 }
 
 void TestRunnerBindings::GetBluetoothManualChooserEvents(
     v8::Local<v8::Function> callback) {
-  if (runner_)
-    return runner_->GetBluetoothManualChooserEvents(callback);
+  if (view_runner_)
+    return view_runner_->GetBluetoothManualChooserEvents(callback);
 }
 
 void TestRunnerBindings::SendBluetoothManualChooserEvent(
     const std::string& event,
     const std::string& argument) {
-  if (runner_)
-    runner_->SendBluetoothManualChooserEvent(event, argument);
+  if (view_runner_)
+    view_runner_->SendBluetoothManualChooserEvent(event, argument);
 }
 
 void TestRunnerBindings::SetPOSIXLocale(const std::string& locale) {
   if (runner_)
     runner_->SetPOSIXLocale(locale);
 }
 
 void TestRunnerBindings::SetMIDIAccessorResult(bool result) {
   if (runner_)
     runner_->SetMIDIAccessorResult(result);
@@ skipping 34 matching lines @@
     runner_->AddMockCredentialManagerResponse(id, name, avatar, password);
 }
 
 void TestRunnerBindings::AddMockCredentialManagerError(
     const std::string& error) {
   if (runner_)
     runner_->AddMockCredentialManagerError(error);
 }
 
 void TestRunnerBindings::AddWebPageOverlay() {
-  if (runner_)
-    runner_->AddWebPageOverlay();
+  if (view_runner_)
+    view_runner_->AddWebPageOverlay();
 }
 
 void TestRunnerBindings::RemoveWebPageOverlay() {
-  if (runner_)
-    runner_->RemoveWebPageOverlay();
+  if (view_runner_)
+    view_runner_->RemoveWebPageOverlay();
 }
 
 void TestRunnerBindings::LayoutAndPaintAsync() {
-  if (runner_)
-    runner_->LayoutAndPaintAsync();
+  if (view_runner_)
+    view_runner_->LayoutAndPaintAsync();
 }
 
 void TestRunnerBindings::LayoutAndPaintAsyncThen(
     v8::Local<v8::Function> callback) {
-  if (runner_)
-    runner_->LayoutAndPaintAsyncThen(callback);
+  if (view_runner_)
+    view_runner_->LayoutAndPaintAsyncThen(callback);
 }
 
 void TestRunnerBindings::GetManifestThen(v8::Local<v8::Function> callback) {
-  if (runner_)
-    runner_->GetManifestThen(callback);
+  if (view_runner_)
+    view_runner_->GetManifestThen(callback);
 }
 
 void TestRunnerBindings::CapturePixelsAsyncThen(
     v8::Local<v8::Function> callback) {
-  if (runner_)
-    runner_->CapturePixelsAsyncThen(callback);
+  if (view_runner_)
+    view_runner_->CapturePixelsAsyncThen(callback);
 }
 
 void TestRunnerBindings::CopyImageAtAndCapturePixelsAsyncThen(
     int x, int y, v8::Local<v8::Function> callback) {
-  if (runner_)
-    runner_->CopyImageAtAndCapturePixelsAsyncThen(x, y, callback);
+  if (view_runner_)
+    view_runner_->CopyImageAtAndCapturePixelsAsyncThen(x, y, callback);
 }
 
 void TestRunnerBindings::SetCustomTextOutput(const std::string& output) {
   if (runner_)
     runner_->setCustomTextOutput(output);
 }
 
 void TestRunnerBindings::SetViewSourceForFrame(const std::string& name,
                                                bool enabled) {
-  if (runner_ && runner_->web_view_) {
-    WebFrame* target_frame =
-        runner_->web_view_->findFrameByName(WebString::fromUTF8(name));
-    if (target_frame)
-      target_frame->enableViewSourceMode(enabled);
-  }
+  if (view_runner_)
+    view_runner_->SetViewSourceForFrame(name, enabled);
 }
 
 void TestRunnerBindings::SetGeofencingMockProvider(bool service_available) {
   if (runner_)
     runner_->SetGeofencingMockProvider(service_available);
 }
 
 void TestRunnerBindings::ClearGeofencingMockProvider() {
   if (runner_)
     runner_->ClearGeofencingMockProvider();
@@ skipping 13 matching lines @@
     return;
 
   return runner_->SetPermission(
       name, value, GURL(origin), GURL(embedding_origin));
 }
 
 void TestRunnerBindings::DispatchBeforeInstallPromptEvent(
     int request_id,
     const std::vector<std::string>& event_platforms,
     v8::Local<v8::Function> callback) {
-  if (!runner_)
+  if (!view_runner_)
     return;
 
-  return runner_->DispatchBeforeInstallPromptEvent(request_id, event_platforms,
-                                                   callback);
+  return view_runner_->DispatchBeforeInstallPromptEvent(
+      request_id, event_platforms, callback);
 }
 
 void TestRunnerBindings::ResolveBeforeInstallPromptPromise(
     int request_id,
     const std::string& platform) {
   if (!runner_)
     return;
 
   runner_->ResolveBeforeInstallPromptPromise(request_id, platform);
 }
 
 void TestRunnerBindings::RunIdleTasks(v8::Local<v8::Function> callback) {
-  if (!runner_)
+  if (!view_runner_)
     return;
-  runner_->RunIdleTasks(callback);
+  view_runner_->RunIdleTasks(callback);
 }
 
 std::string TestRunnerBindings::PlatformName() {
   if (runner_)
     return runner_->platform_name_;
   return std::string();
 }
 
 std::string TestRunnerBindings::TooltipText() {
   if (runner_)
@@ skipping 14 matching lines @@
 }
 
 void TestRunnerBindings::SetInterceptPostMessage(bool value) {
   if (runner_) {
     runner_->layout_test_runtime_flags_.set_intercept_post_message(value);
     runner_->OnLayoutTestRuntimeFlagsChanged();
   }
 }
 
 void TestRunnerBindings::ForceNextWebGLContextCreationToFail() {
-  if (runner_)
-    runner_->ForceNextWebGLContextCreationToFail();
+  if (view_runner_)
+    view_runner_->ForceNextWebGLContextCreationToFail();
 }
 
 void TestRunnerBindings::ForceNextDrawingBufferCreationToFail() {
-  if (runner_)
-    runner_->ForceNextDrawingBufferCreationToFail();
+  if (view_runner_)
+    view_runner_->ForceNextDrawingBufferCreationToFail();
 }
 
 void TestRunnerBindings::NotImplemented(const gin::Arguments& args) {
 }
 
 TestRunner::WorkQueue::WorkQueue(TestRunner* controller)
     : frozen_(false), controller_(controller), weak_factory_(this) {}
 
 TestRunner::WorkQueue::~WorkQueue() {
   Reset();
 }
 
 void TestRunner::WorkQueue::ProcessWorkSoon() {
   if (controller_->topLoadingFrame())
     return;
 
   if (!queue_.empty()) {
     // We delay processing queued work to avoid recursion problems.
-    controller_->PostTask(base::Bind(&TestRunner::WorkQueue::ProcessWork,
-                                     weak_factory_.GetWeakPtr()));
+    controller_->delegate_->PostTask(new WebCallbackTask(base::Bind(
+        &TestRunner::WorkQueue::ProcessWork, weak_factory_.GetWeakPtr())));
   } else if (!controller_->layout_test_runtime_flags_.wait_until_done()) {
     controller_->delegate_->TestFinished();
   }
 }
 
 void TestRunner::WorkQueue::Reset() {
   frozen_ = false;
   while (!queue_.empty()) {
     delete queue_.front();
     queue_.pop_front();
@@ skipping 36 matching lines @@
           new MockContentSettingsClient(&layout_test_runtime_flags_)),
       credential_manager_client_(new MockCredentialManagerClient),
       mock_screen_orientation_client_(new MockScreenOrientationClient),
       spellcheck_(new SpellCheckClient(this)),
       chooser_count_(0),
       previously_focused_view_(nullptr),
       weak_factory_(this) {}
 
 TestRunner::~TestRunner() {}
 
-void TestRunner::Install(WebFrame* frame) {
-  TestRunnerBindings::Install(weak_factory_.GetWeakPtr(), frame);
+void TestRunner::Install(
+    WebLocalFrame* frame,
+    base::WeakPtr<TestRunnerForSpecificView> view_test_runner) {
+  TestRunnerBindings::Install(weak_factory_.GetWeakPtr(), view_test_runner,
+                              frame);
 }
 
 void TestRunner::SetDelegate(WebTestDelegate* delegate) {
   delegate_ = delegate;
   mock_content_settings_client_->SetDelegate(delegate);
   spellcheck_->SetDelegate(delegate);
   if (speech_recognizer_)
     speech_recognizer_->SetDelegate(delegate);
 }
 
 void TestRunner::SetWebView(WebView* webView) {
   web_view_ = webView;
 }
 
 void TestRunner::Reset() {
-  if (web_view_) {
-    web_view_->setZoomLevel(0);
-    web_view_->setTextZoomFactor(1);
-    web_view_->setTabKeyCyclesThroughElements(true);
-#if !defined(OS_MACOSX) && !defined(OS_WIN)
-    // (Constants copied because we can't depend on the header that defined
-    // them from this file.)
-    web_view_->setSelectionColors(
-        0xff1e90ff, 0xff000000, 0xffc8c8c8, 0xff323232);
-#endif
-    web_view_->setVisibilityState(WebPageVisibilityStateVisible, true);
-    web_view_->mainFrame()->enableViewSourceMode(false);
-
-    web_view_->setPageOverlayColor(SK_ColorTRANSPARENT);
-  }
-
   top_loading_frame_ = nullptr;
   layout_test_runtime_flags_.Reset();
   mock_screen_orientation_client_->ResetData();
   drag_image_.reset();
   views_with_scheduled_animations_.clear();
 
   WebSecurityPolicy::resetOriginAccessWhitelists();
 #if defined(__linux__) || defined(ANDROID)
   WebFontRendering::setSubpixelPositioning(false);
 #endif
@@ skipping 27 matching lines @@
   custom_text_output_.clear();
 
   http_headers_to_clear_.clear();
 
   platform_name_ = "chromium";
   tooltip_text_ = std::string();
   web_history_item_count_ = 0;
 
   SetUseMockTheme(true);
 
-  pointer_locked_ = false;
-  pointer_lock_planned_result_ = PointerLockWillSucceed;
-
   weak_factory_.InvalidateWeakPtrs();
   work_queue_.Reset();
 
   if (close_remaining_windows_ && delegate_)
     delegate_->CloseRemainingWindows();
   else
     close_remaining_windows_ = true;
 }
 
 void TestRunner::SetTestIsRunning(bool running) {
   test_is_running_ = running;
 }
 
-void TestRunner::PostTask(const base::Closure& callback) {
-  delegate_->PostTask(new WebCallbackTask(callback));
+void TestRunnerForSpecificView::PostTask(const base::Closure& callback) {
+  delegate()->PostTask(new WebCallbackTask(callback));
 }
 
-void TestRunner::PostDelayedTask(long long delay,
-                                 const base::Closure& callback) {
-  delegate_->PostDelayedTask(new WebCallbackTask(callback), delay);
+void TestRunnerForSpecificView::PostDelayedTask(long long delay,
+                                                const base::Closure& callback) {
+  delegate()->PostDelayedTask(new WebCallbackTask(callback), delay);
 }
 
-void TestRunner::PostV8Callback(const v8::Local<v8::Function>& callback) {
-  PostTask(base::Bind(&TestRunner::InvokeV8Callback, weak_factory_.GetWeakPtr(),
+void TestRunnerForSpecificView::PostV8Callback(
+    const v8::Local<v8::Function>& callback) {
+  PostTask(base::Bind(&TestRunnerForSpecificView::InvokeV8Callback,
+                      weak_factory_.GetWeakPtr(),
                       v8::UniquePersistent<v8::Function>(
                           blink::mainThreadIsolate(), callback)));
 }
 
-void TestRunner::PostV8CallbackWithArgs(
+void TestRunnerForSpecificView::PostV8CallbackWithArgs(
     v8::UniquePersistent<v8::Function> callback,
     int argc,
     v8::Local<v8::Value> argv[]) {
   std::vector<v8::UniquePersistent<v8::Value>> args;
   for (int i = 0; i < argc; i++) {
     args.push_back(
         v8::UniquePersistent<v8::Value>(blink::mainThreadIsolate(), argv[i]));
   }
 
-  PostTask(base::Bind(&TestRunner::InvokeV8CallbackWithArgs,
+  PostTask(base::Bind(&TestRunnerForSpecificView::InvokeV8CallbackWithArgs,
                       weak_factory_.GetWeakPtr(), std::move(callback),
                       std::move(args)));
 }
 
-void TestRunner::InvokeV8Callback(
+void TestRunnerForSpecificView::InvokeV8Callback(
     const v8::UniquePersistent<v8::Function>& callback) {
   std::vector<v8::UniquePersistent<v8::Value>> empty_args;
   InvokeV8CallbackWithArgs(callback, std::move(empty_args));
 }
 
-void TestRunner::InvokeV8CallbackWithArgs(
+void TestRunnerForSpecificView::InvokeV8CallbackWithArgs(
     const v8::UniquePersistent<v8::Function>& callback,
     const std::vector<v8::UniquePersistent<v8::Value>>& args) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
 
-  if (!web_view_)
-    return;
-  WebFrame* frame = web_view_->mainFrame();
+  WebFrame* frame = web_view()->mainFrame();
   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
   v8::Context::Scope context_scope(context);
 
   std::vector<v8::Local<v8::Value>> local_args;
   for (const auto& arg : args) {
     local_args.push_back(v8::Local<v8::Value>::New(isolate, arg));
   }
 
   frame->callFunctionEvenIfScriptDisabled(
       v8::Local<v8::Function>::New(isolate, callback), context->Global(),
       local_args.size(), local_args.data());
 }
 
-base::Closure TestRunner::CreateClosureThatPostsV8Callback(
+base::Closure TestRunnerForSpecificView::CreateClosureThatPostsV8Callback(
     const v8::Local<v8::Function>& callback) {
-  return base::Bind(
-      &TestRunner::PostTask, weak_factory_.GetWeakPtr(),
-      base::Bind(&TestRunner::InvokeV8Callback, weak_factory_.GetWeakPtr(),
-                 v8::UniquePersistent<v8::Function>(blink::mainThreadIsolate(),
-                                                    callback)));
+  return base::Bind(&TestRunnerForSpecificView::PostTask,
+                    weak_factory_.GetWeakPtr(),
+                    base::Bind(&TestRunnerForSpecificView::InvokeV8Callback,
+                               weak_factory_.GetWeakPtr(),
+                               v8::UniquePersistent<v8::Function>(
+                                   blink::mainThreadIsolate(), callback)));
 }
 
 bool TestRunner::shouldDumpEditingCallbacks() const {
   return layout_test_runtime_flags_.dump_editting_callbacks();
 }
 
 void TestRunner::setShouldDumpAsText(bool value) {
   layout_test_runtime_flags_.set_dump_as_text(value);
   OnLayoutTestRuntimeFlagsChanged();
 }
@@ skipping 63 matching lines @@
         bitmap.eraseColor(0);
       }
       callback.Run(bitmap);
       return;
     }
 
     callback.Run(drag_image_.getSkBitmap());
     return;
   }
 
-  test_runner::DumpPixelsAsync(web_view_, layout_test_runtime_flags_,
+  test_runner::DumpPixelsAsync(web_view, layout_test_runtime_flags_,
                                delegate_->GetDeviceScaleFactorForTest(),
                                callback);
 }
 
 void TestRunner::ReplicateLayoutTestRuntimeFlagsChanges(
     const base::DictionaryValue& changed_values) {
   DCHECK(test_is_running_);
   layout_test_runtime_flags_.tracked_dictionary().ApplyUntrackedChanges(
       changed_values);
 }
@@ skipping 16 matching lines @@
   layout_test_runtime_flags_.set_dump_frame_load_callbacks(value);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 bool TestRunner::shouldDumpPingLoaderCallbacks() const {
   return test_is_running_ &&
          layout_test_runtime_flags_.dump_ping_loader_callbacks();
 }
 
 void TestRunner::setShouldEnableViewSource(bool value) {
+  // TODO(lukasza): This flag should be 1) replicated across OOPIFs and
+  // 2) applied to all views, not just the main window view.
   web_view_->mainFrame()->enableViewSourceMode(value);
 }
 
 bool TestRunner::shouldDumpUserGestureInFrameLoadCallbacks() const {
   return test_is_running_ &&
          layout_test_runtime_flags_.dump_user_gesture_in_frame_load_callbacks();
 }
 
 bool TestRunner::shouldDumpTitleChanges() const {
   return layout_test_runtime_flags_.dump_title_changes();
@@ skipping 91 matching lines @@
 }
 
 bool TestRunner::shouldInterceptPostMessage() const {
   return layout_test_runtime_flags_.intercept_post_message();
 }
 
 bool TestRunner::shouldDumpResourcePriorities() const {
   return layout_test_runtime_flags_.dump_resource_priorities();
 }
 
-bool TestRunner::RequestPointerLock() {
+bool TestRunnerForSpecificView::RequestPointerLock() {
   switch (pointer_lock_planned_result_) {
     case PointerLockWillSucceed:
-      PostDelayedTask(0, base::Bind(&TestRunner::DidAcquirePointerLockInternal,
-                                    weak_factory_.GetWeakPtr()));
+      PostDelayedTask(
+          0,
+          base::Bind(&TestRunnerForSpecificView::DidAcquirePointerLockInternal,
+                     weak_factory_.GetWeakPtr()));
       return true;
     case PointerLockWillRespondAsync:
       DCHECK(!pointer_locked_);
       return true;
     case PointerLockWillFailSync:
       DCHECK(!pointer_locked_);
       return false;
     default:
       NOTREACHED();
       return false;
   }
 }
 
-void TestRunner::RequestPointerUnlock() {
-  PostDelayedTask(0, base::Bind(&TestRunner::DidLosePointerLockInternal,
-                                weak_factory_.GetWeakPtr()));
+void TestRunnerForSpecificView::RequestPointerUnlock() {
+  PostDelayedTask(
+      0, base::Bind(&TestRunnerForSpecificView::DidLosePointerLockInternal,
+                    weak_factory_.GetWeakPtr()));
 }
 
-bool TestRunner::isPointerLocked() {
+bool TestRunnerForSpecificView::isPointerLocked() {
   return pointer_locked_;
 }
 
 void TestRunner::setToolTipText(const WebString& text) {
   tooltip_text_ = text.utf8();
 }
 
 void TestRunner::setDragImage(
     const blink::WebImage& drag_image) {
   if (layout_test_runtime_flags_.dump_drag_image()) {
@@ skipping 150 matching lines @@
 
 void TestRunner::SetCloseRemainingWindowsWhenComplete(
     bool close_remaining_windows) {
   close_remaining_windows_ = close_remaining_windows;
 }
 
 void TestRunner::ResetTestHelperControllers() {
   test_interfaces_->ResetTestHelperControllers();
 }
 
-void TestRunner::SetTabKeyCyclesThroughElements(
+void TestRunnerForSpecificView::SetTabKeyCyclesThroughElements(
     bool tab_key_cycles_through_elements) {
-  web_view_->setTabKeyCyclesThroughElements(tab_key_cycles_through_elements);
+  web_view()->setTabKeyCyclesThroughElements(tab_key_cycles_through_elements);
 }
 
-void TestRunner::ExecCommand(gin::Arguments* args) {
+void TestRunnerForSpecificView::ExecCommand(gin::Arguments* args) {
   std::string command;
   args->GetNext(&command);
 
   std::string value;
   if (args->Length() >= 3) {
     // Ignore the second parameter (which is userInterface)
     // since this command emulates a manual action.
     args->Skip();
     args->GetNext(&value);
   }
 
   // Note: webkit's version does not return the boolean, so neither do we.
-  web_view_->focusedFrame()->executeCommand(WebString::fromUTF8(command),
-                                            WebString::fromUTF8(value));
+  web_view()->focusedFrame()->executeCommand(WebString::fromUTF8(command),
+                                             WebString::fromUTF8(value));
 }
 
-bool TestRunner::IsCommandEnabled(const std::string& command) {
-  return web_view_->focusedFrame()->isCommandEnabled(
+bool TestRunnerForSpecificView::IsCommandEnabled(const std::string& command) {
+  return web_view()->focusedFrame()->isCommandEnabled(
       WebString::fromUTF8(command));
 }
 
-bool TestRunner::CallShouldCloseOnWebView() {
-  return web_view_->mainFrame()->dispatchBeforeUnloadEvent();
+bool TestRunnerForSpecificView::CallShouldCloseOnWebView() {
+  return web_view()->mainFrame()->dispatchBeforeUnloadEvent();
 }
 
-void TestRunner::SetDomainRelaxationForbiddenForURLScheme(
-    bool forbidden, const std::string& scheme) {
-  web_view_->setDomainRelaxationForbidden(forbidden,
-                                          WebString::fromUTF8(scheme));
+void TestRunnerForSpecificView::SetDomainRelaxationForbiddenForURLScheme(
+    bool forbidden,
+    const std::string& scheme) {
+  web_view()->setDomainRelaxationForbidden(forbidden,
+                                           WebString::fromUTF8(scheme));
 }
 
-v8::Local<v8::Value> TestRunner::EvaluateScriptInIsolatedWorldAndReturnValue(
+v8::Local<v8::Value>
+TestRunnerForSpecificView::EvaluateScriptInIsolatedWorldAndReturnValue(
     int world_id,
     const std::string& script) {
   WebVector<v8::Local<v8::Value>> values;
   WebScriptSource source(WebString::fromUTF8(script));
   // This relies on the iframe focusing itself when it loads. This is a bit
   // sketchy, but it seems to be what other tests do.
-  web_view_->focusedFrame()->executeScriptInIsolatedWorld(
-      world_id, &source, 1, 1, &values);
+  web_view()->focusedFrame()->executeScriptInIsolatedWorld(world_id, &source, 1,
+                                                           1, &values);
   // Since only one script was added, only one result is expected
   if (values.size() == 1 && !values[0].IsEmpty())
     return values[0];
   return v8::Local<v8::Value>();
 }
 
-void TestRunner::EvaluateScriptInIsolatedWorld(int world_id,
-                                               const std::string& script) {
+void TestRunnerForSpecificView::EvaluateScriptInIsolatedWorld(
+    int world_id,
+    const std::string& script) {
   WebScriptSource source(WebString::fromUTF8(script));
-  web_view_->focusedFrame()->executeScriptInIsolatedWorld(
-      world_id, &source, 1, 1);
+  web_view()->focusedFrame()->executeScriptInIsolatedWorld(world_id, &source, 1,
+                                                           1);
 }
 
-void TestRunner::SetIsolatedWorldSecurityOrigin(int world_id,
-                                                v8::Local<v8::Value> origin) {
+void TestRunnerForSpecificView::SetIsolatedWorldSecurityOrigin(
+    int world_id,
+    v8::Local<v8::Value> origin) {
   if (!(origin->IsString() || !origin->IsNull()))
     return;
 
   WebSecurityOrigin web_origin;
   if (origin->IsString()) {
     web_origin = WebSecurityOrigin::createFromString(
         V8StringToWebString(origin.As<v8::String>()));
   }
-  web_view_->focusedFrame()->setIsolatedWorldSecurityOrigin(world_id,
-                                                            web_origin);
+  web_view()->focusedFrame()->setIsolatedWorldSecurityOrigin(world_id,
+                                                             web_origin);
 }
 
-void TestRunner::SetIsolatedWorldContentSecurityPolicy(
+void TestRunnerForSpecificView::SetIsolatedWorldContentSecurityPolicy(
     int world_id,
     const std::string& policy) {
-  web_view_->focusedFrame()->setIsolatedWorldContentSecurityPolicy(
+  web_view()->focusedFrame()->setIsolatedWorldContentSecurityPolicy(
       world_id, WebString::fromUTF8(policy));
 }
 
 void TestRunner::AddOriginAccessWhitelistEntry(
     const std::string& source_origin,
     const std::string& destination_protocol,
     const std::string& destination_host,
     bool allow_destination_subdomains) {
   WebURL url((GURL(source_origin)));
   if (!url.isValid())
@@ skipping 15 matching lines @@
   if (!url.isValid())
     return;
 
   WebSecurityPolicy::removeOriginAccessWhitelistEntry(
       url,
       WebString::fromUTF8(destination_protocol),
       WebString::fromUTF8(destination_host),
       allow_destination_subdomains);
 }
 
-bool TestRunner::HasCustomPageSizeStyle(int page_index) {
-  WebFrame* frame = web_view_->mainFrame();
+bool TestRunnerForSpecificView::HasCustomPageSizeStyle(int page_index) {
+  WebFrame* frame = web_view()->mainFrame();
   if (!frame)
     return false;
   return frame->hasCustomPageSizeStyle(page_index);
 }
 
-void TestRunner::ForceRedSelectionColors() {
-  web_view_->setSelectionColors(0xffee0000, 0xff00ee00, 0xff000000, 0xffc0c0c0);
+void TestRunnerForSpecificView::ForceRedSelectionColors() {
+  web_view()->setSelectionColors(
+      0xffee0000, 0xff00ee00, 0xff000000, 0xffc0c0c0);
 }
 
 void TestRunner::InsertStyleSheet(const std::string& source_code) {
   WebLocalFrame::frameForCurrentContext()->document().insertStyleSheet(
       WebString::fromUTF8(source_code));
 }
 
-bool TestRunner::FindString(const std::string& search_text,
-                            const std::vector<std::string>& options_array) {
+bool TestRunnerForSpecificView::FindString(
+    const std::string& search_text,
+    const std::vector<std::string>& options_array) {
   WebFindOptions find_options;
   bool wrap_around = false;
   find_options.matchCase = true;
   find_options.findNext = true;
 
   for (const std::string& option : options_array) {
     if (option == "CaseInsensitive")
       find_options.matchCase = false;
     else if (option == "Backwards")
       find_options.forward = false;
     else if (option == "StartInSelection")
       find_options.findNext = false;
     else if (option == "AtWordStarts")
       find_options.wordStart = true;
     else if (option == "TreatMedialCapitalAsWordStart")
       find_options.medialCapitalAsWordStart = true;
     else if (option == "WrapAround")
       wrap_around = true;
   }
 
-  WebLocalFrame* frame = web_view_->mainFrame()->toWebLocalFrame();
+  WebLocalFrame* frame = web_view()->mainFrame()->toWebLocalFrame();
   const bool find_result = frame->find(0, WebString::fromUTF8(search_text),
                                        find_options, wrap_around, 0);
   frame->stopFinding(false);
   return find_result;
 }
 
-std::string TestRunner::SelectionAsMarkup() {
-  return web_view_->mainFrame()->selectionAsMarkup().utf8();
+std::string TestRunnerForSpecificView::SelectionAsMarkup() {
+  return web_view()->mainFrame()->selectionAsMarkup().utf8();
 }
 
 void TestRunner::SetTextSubpixelPositioning(bool value) {
 #if defined(__linux__) || defined(ANDROID)
   // Since FontConfig doesn't provide a variable to control subpixel
   // positioning, we'll fall back to setting it globally for all fonts.
   WebFontRendering::setSubpixelPositioning(value);
 #endif
 }
 
-void TestRunner::SetPageVisibility(const std::string& new_visibility) {
+void TestRunnerForSpecificView::SetPageVisibility(
+    const std::string& new_visibility) {
   if (new_visibility == "visible")
-    web_view_->setVisibilityState(WebPageVisibilityStateVisible, false);
+    web_view()->setVisibilityState(WebPageVisibilityStateVisible, false);
   else if (new_visibility == "hidden")
-    web_view_->setVisibilityState(WebPageVisibilityStateHidden, false);
+    web_view()->setVisibilityState(WebPageVisibilityStateHidden, false);
   else if (new_visibility == "prerender")
-    web_view_->setVisibilityState(WebPageVisibilityStatePrerender, false);
+    web_view()->setVisibilityState(WebPageVisibilityStatePrerender, false);
 }
 
-void TestRunner::SetTextDirection(const std::string& direction_name) {
+void TestRunnerForSpecificView::SetTextDirection(
+    const std::string& direction_name) {
   // Map a direction name to a WebTextDirection value.
   WebTextDirection direction;
   if (direction_name == "auto")
     direction = WebTextDirectionDefault;
   else if (direction_name == "rtl")
     direction = WebTextDirectionRightToLeft;
   else if (direction_name == "ltr")
     direction = WebTextDirectionLeftToRight;
   else
     return;
 
-  web_view_->setTextDirection(direction);
+  web_view()->setTextDirection(direction);
 }
 
 void TestRunner::UseUnfortunateSynchronousResizeMode() {
   delegate_->UseUnfortunateSynchronousResizeMode(true);
 }
 
 bool TestRunner::EnableAutoResizeMode(int min_width,
                                       int min_height,
                                       int max_width,
                                       int max_height) {
@@ skipping 115 matching lines @@
     orientation = WebScreenOrientationPortraitPrimary;
   } else if (orientation_str == "portrait-secondary") {
     orientation = WebScreenOrientationPortraitSecondary;
   } else if (orientation_str == "landscape-primary") {
     orientation = WebScreenOrientationLandscapePrimary;
   } else {
     DCHECK_EQ("landscape-secondary", orientation_str);
     orientation = WebScreenOrientationLandscapeSecondary;
   }
 
-  // TODO(lukasza): This is broken for OOPIFs.
-  WebLocalFrame* main_frame = web_view_->mainFrame()->toWebLocalFrame();
-  mock_screen_orientation_client_->UpdateDeviceOrientation(
-      main_frame, orientation);
+  for (WebTestProxyBase* window : test_interfaces_->GetWindowList()) {
+    WebFrame* main_frame = window->web_view()->mainFrame();
+    // TODO(lukasza): Need to make this work for remote frames.
+    if (main_frame->isWebLocalFrame()) {
+      mock_screen_orientation_client_->UpdateDeviceOrientation(
+          main_frame->toWebLocalFrame(), orientation);
+    }
+  }
 }
 
 void TestRunner::DisableMockScreenOrientation() {
   mock_screen_orientation_client_->SetDisabled(true);
 }
 
 void TestRunner::DidOpenChooser() {
   chooser_count_++;
 }
 
 void TestRunner::DidCloseChooser() {
   chooser_count_--;
   DCHECK_LE(0, chooser_count_);
 }
 
-void TestRunner::DidAcquirePointerLock() {
+void TestRunnerForSpecificView::DidAcquirePointerLock() {
   DidAcquirePointerLockInternal();
 }
 
-void TestRunner::DidNotAcquirePointerLock() {
+void TestRunnerForSpecificView::DidNotAcquirePointerLock() {
   DidNotAcquirePointerLockInternal();
 }
 
-void TestRunner::DidLosePointerLock() {
+void TestRunnerForSpecificView::DidLosePointerLock() {
   DidLosePointerLockInternal();
 }
 
-void TestRunner::SetPointerLockWillFailSynchronously() {
+void TestRunnerForSpecificView::SetPointerLockWillFailSynchronously() {
   pointer_lock_planned_result_ = PointerLockWillFailSync;
 }
 
-void TestRunner::SetPointerLockWillRespondAsynchronously() {
+void TestRunnerForSpecificView::SetPointerLockWillRespondAsynchronously() {
   pointer_lock_planned_result_ = PointerLockWillRespondAsync;
 }
 
 void TestRunner::SetPopupBlockingEnabled(bool block_popups) {
   delegate_->Preferences()->java_script_can_open_windows_automatically =
       !block_popups;
   delegate_->ApplyPreferences();
 }
 
 void TestRunner::SetJavaScriptCanAccessClipboard(bool can_access) {
@@ skipping 70 matching lines @@
 std::string TestRunner::GetAcceptLanguages() const {
   return layout_test_runtime_flags_.accept_languages();
 }
 
 void TestRunner::SetAcceptLanguages(const std::string& accept_languages) {
   if (accept_languages == GetAcceptLanguages())
     return;
 
   layout_test_runtime_flags_.set_accept_languages(accept_languages);
   OnLayoutTestRuntimeFlagsChanged();
-  web_view_->acceptLanguagesChanged();
+
+  for (WebTestProxyBase* window : test_interfaces_->GetWindowList())
+    window->web_view()->acceptLanguagesChanged();
 }
 
 void TestRunner::SetPluginsEnabled(bool enabled) {
   delegate_->Preferences()->plugins_enabled = enabled;
   delegate_->ApplyPreferences();
 }
 
 bool TestRunner::GetAnimationScheduled() const {
   bool is_animation_scheduled = !views_with_scheduled_animations_.empty();
   return is_animation_scheduled;
@@ skipping 199 matching lines @@
   layout_test_runtime_flags_.set_dump_drag_image(true);
   DumpAsTextWithPixelResults();
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::DumpNavigationPolicy() {
   layout_test_runtime_flags_.set_dump_navigation_policy(true);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
-void TestRunner::DumpPageImportanceSignals() {
+void TestRunnerForSpecificView::DumpPageImportanceSignals() {
   blink::WebPageImportanceSignals* signals =
-    web_view_->pageImportanceSignals();
+      web_view()->pageImportanceSignals();
   if (!signals)
     return;
 
   std::string message = base::StringPrintf(
       "WebPageImportanceSignals:\n"
       "  hadFormInteraction: %s\n"
       "  issuedNonGetFetchFromScript: %s\n",
       signals->hadFormInteraction() ? "true" : "false",
       signals->issuedNonGetFetchFromScript() ? "true" : "false");
-  if (delegate_)
-    delegate_->PrintMessage(message);
+  if (delegate())
+    delegate()->PrintMessage(message);
 }
 
 void TestRunner::CloseWebInspector() {
   delegate_->CloseDevTools();
 }
 
 bool TestRunner::IsChooserShown() {
   return 0 < chooser_count_;
 }
 
@@ skipping 12 matching lines @@
 }
 
 void TestRunner::SetDatabaseQuota(int quota) {
   delegate_->SetDatabaseQuota(quota);
 }
 
 void TestRunner::SetAlwaysAcceptCookies(bool accept) {
   delegate_->SetAcceptAllCookies(accept);
 }
 
-void TestRunner::SetWindowIsKey(bool value) {
-  SetFocus(web_view_, value);
+void TestRunnerForSpecificView::SetWindowIsKey(bool value) {
+  web_test_proxy_base_->test_interfaces()->GetTestRunner()->SetFocus(web_view(),
+                                                                     value);
 }
 
 void TestRunner::SetFocus(blink::WebView* web_view, bool focus) {
   if (focus) {
     if (previously_focused_view_ != web_view) {
       delegate_->SetFocus(previously_focused_view_, false);
       delegate_->SetFocus(web_view, true);
       previously_focused_view_ = web_view;
     }
   } else {
     if (previously_focused_view_ == web_view) {
       delegate_->SetFocus(web_view, false);
       previously_focused_view_ = nullptr;
     }
   }
 }
 
 std::string TestRunner::PathToLocalResource(const std::string& path) {
   return delegate_->PathToLocalResource(path);
 }
 
-void TestRunner::SetBackingScaleFactor(double value,
-                                       v8::Local<v8::Function> callback) {
-  delegate_->SetDeviceScaleFactor(value);
+void TestRunnerForSpecificView::SetBackingScaleFactor(
+    double value,
+    v8::Local<v8::Function> callback) {
+  delegate()->SetDeviceScaleFactor(value);
   PostV8Callback(callback);
 }
 
-void TestRunner::EnableUseZoomForDSF(v8::Local<v8::Function> callback) {
-  delegate_->EnableUseZoomForDSF();
+void TestRunnerForSpecificView::EnableUseZoomForDSF(
+    v8::Local<v8::Function> callback) {
+  delegate()->EnableUseZoomForDSF();
   PostV8Callback(callback);
 }
 
-void TestRunner::SetColorProfile(const std::string& name,
-                                 v8::Local<v8::Function> callback) {
-  delegate_->SetDeviceColorProfile(name);
+void TestRunnerForSpecificView::SetColorProfile(
+    const std::string& name,
+    v8::Local<v8::Function> callback) {
+  delegate()->SetDeviceColorProfile(name);
   PostV8Callback(callback);
 }
 
-void TestRunner::SetBluetoothFakeAdapter(const std::string& adapter_name,
-                                         v8::Local<v8::Function> callback) {
-  delegate_->SetBluetoothFakeAdapter(
+void TestRunnerForSpecificView::SetBluetoothFakeAdapter(
+    const std::string& adapter_name,
+    v8::Local<v8::Function> callback) {
+  delegate()->SetBluetoothFakeAdapter(
       adapter_name, CreateClosureThatPostsV8Callback(callback));
 }
 
-void TestRunner::SetBluetoothManualChooser(bool enable) {
-  delegate_->SetBluetoothManualChooser(enable);
+void TestRunnerForSpecificView::SetBluetoothManualChooser(bool enable) {
+  delegate()->SetBluetoothManualChooser(enable);
 }
 
-void TestRunner::GetBluetoothManualChooserEvents(
+void TestRunnerForSpecificView::GetBluetoothManualChooserEvents(
     v8::Local<v8::Function> callback) {
-  return delegate_->GetBluetoothManualChooserEvents(
-      base::Bind(&TestRunner::GetBluetoothManualChooserEventsCallback,
-                 weak_factory_.GetWeakPtr(),
-                 base::Passed(v8::UniquePersistent<v8::Function>(
-                     blink::mainThreadIsolate(), callback))));
+  return delegate()->GetBluetoothManualChooserEvents(base::Bind(
+      &TestRunnerForSpecificView::GetBluetoothManualChooserEventsCallback,
+      weak_factory_.GetWeakPtr(),
+      base::Passed(v8::UniquePersistent<v8::Function>(
+          blink::mainThreadIsolate(), callback))));
 }
 
-void TestRunner::SendBluetoothManualChooserEvent(const std::string& event,
-                                                 const std::string& argument) {
-  delegate_->SendBluetoothManualChooserEvent(event, argument);
+void TestRunnerForSpecificView::SendBluetoothManualChooserEvent(
+    const std::string& event,
+    const std::string& argument) {
+  delegate()->SendBluetoothManualChooserEvent(event, argument);
 }
 
 void TestRunner::SetGeofencingMockProvider(bool service_available) {
   delegate_->SetGeofencingMockProvider(service_available);
 }
 
 void TestRunner::ClearGeofencingMockProvider() {
   delegate_->ClearGeofencingMockProvider();
 }
 
 void TestRunner::SetGeofencingMockPosition(double latitude, double longitude) {
   delegate_->SetGeofencingMockPosition(latitude, longitude);
 }
 
 void TestRunner::SetPermission(const std::string& name,
                                const std::string& value,
                                const GURL& origin,
                                const GURL& embedding_origin) {
   delegate_->SetPermission(name, value, origin, embedding_origin);
 }
 
-void TestRunner::DispatchBeforeInstallPromptEvent(
+void TestRunnerForSpecificView::DispatchBeforeInstallPromptEvent(
     int request_id,
     const std::vector<std::string>& event_platforms,
     v8::Local<v8::Function> callback) {
-  delegate_->DispatchBeforeInstallPromptEvent(
+  delegate()->DispatchBeforeInstallPromptEvent(
       request_id, event_platforms,
-      base::Bind(&TestRunner::DispatchBeforeInstallPromptCallback,
-                 weak_factory_.GetWeakPtr(),
-                 base::Passed(v8::UniquePersistent<v8::Function>(
-                     blink::mainThreadIsolate(), callback))));
+      base::Bind(
+          &TestRunnerForSpecificView::DispatchBeforeInstallPromptCallback,
+          weak_factory_.GetWeakPtr(),
+          base::Passed(v8::UniquePersistent<v8::Function>(
+              blink::mainThreadIsolate(), callback))));
 }
 
 void TestRunner::ResolveBeforeInstallPromptPromise(
     int request_id,
     const std::string& platform) {
   if (!test_interfaces_->GetAppBannerClient())
     return;
   test_interfaces_->GetAppBannerClient()->ResolvePromise(request_id, platform);
 }
 
-void TestRunner::RunIdleTasks(v8::Local<v8::Function> callback) {
-    delegate_->RunIdleTasks(
-        CreateClosureThatPostsV8Callback(callback));
+void TestRunnerForSpecificView::RunIdleTasks(v8::Local<v8::Function> callback) {
+  delegate()->RunIdleTasks(CreateClosureThatPostsV8Callback(callback));
 }
 
 void TestRunner::SetPOSIXLocale(const std::string& locale) {
   delegate_->SetLocale(locale);
 }
 
 void TestRunner::SetMIDIAccessorResult(bool result) {
   midi_accessor_result_ = result;
 }
 
@@ skipping 25 matching lines @@
                                                   const std::string& password) {
   credential_manager_client_->SetResponse(new WebPasswordCredential(
       WebString::fromUTF8(id), WebString::fromUTF8(password),
       WebString::fromUTF8(name), WebURL(GURL(avatar))));
 }
 
 void TestRunner::AddMockCredentialManagerError(const std::string& error) {
   credential_manager_client_->SetError(error);
 }
 
-void TestRunner::AddWebPageOverlay() {
-  if (web_view_)
-    web_view_->setPageOverlayColor(SK_ColorCYAN);
+void TestRunnerForSpecificView::AddWebPageOverlay() {
+  web_view()->setPageOverlayColor(SK_ColorCYAN);
 }
 
-void TestRunner::RemoveWebPageOverlay() {
-  if (web_view_)
-    web_view_->setPageOverlayColor(SK_ColorTRANSPARENT);
+void TestRunnerForSpecificView::RemoveWebPageOverlay() {
+  web_view()->setPageOverlayColor(SK_ColorTRANSPARENT);
 }
 
-void TestRunner::LayoutAndPaintAsync() {
-  test_runner::LayoutAndPaintAsyncThen(web_view_, base::Closure());
+void TestRunnerForSpecificView::LayoutAndPaintAsync() {
+  test_runner::LayoutAndPaintAsyncThen(web_view(), base::Closure());
 }
 
-void TestRunner::LayoutAndPaintAsyncThen(v8::Local<v8::Function> callback) {
+void TestRunnerForSpecificView::LayoutAndPaintAsyncThen(
+    v8::Local<v8::Function> callback) {
   test_runner::LayoutAndPaintAsyncThen(
-      web_view_, CreateClosureThatPostsV8Callback(callback));
+      web_view(), CreateClosureThatPostsV8Callback(callback));
 }
 
-void TestRunner::GetManifestThen(v8::Local<v8::Function> callback) {
+void TestRunnerForSpecificView::GetManifestThen(
+    v8::Local<v8::Function> callback) {
   v8::UniquePersistent<v8::Function> persistent_callback(
       blink::mainThreadIsolate(), callback);
 
-  if (!web_view_) {
-    WebURLResponse response;
-    response.setHTTPStatusCode(404);
-    GetManifestCallback(std::move(persistent_callback), response, "");
-    return;
-  }
-
-  delegate_->FetchManifest(
-      web_view_, web_view_->mainFrame()->document().manifestURL(),
-      base::Bind(&TestRunner::GetManifestCallback, weak_factory_.GetWeakPtr(),
+  delegate()->FetchManifest(
+      web_view(), web_view()->mainFrame()->document().manifestURL(),
+      base::Bind(&TestRunnerForSpecificView::GetManifestCallback,
+                 weak_factory_.GetWeakPtr(),
                  base::Passed(std::move(persistent_callback))));
 }
 
-void TestRunner::CapturePixelsAsyncThen(v8::Local<v8::Function> callback) {
+void TestRunnerForSpecificView::CapturePixelsAsyncThen(
+    v8::Local<v8::Function> callback) {
   v8::UniquePersistent<v8::Function> persistent_callback(
       blink::mainThreadIsolate(), callback);
 
-  if (!web_view_) {
-    CapturePixelsCallback(std::move(persistent_callback), SkBitmap());
-    return;
-  }
-
-  DumpPixelsAsync(
-      web_view_,
-      base::Bind(&TestRunner::CapturePixelsCallback, weak_factory_.GetWeakPtr(),
-                 base::Passed(std::move(persistent_callback))));
+  web_test_proxy_base_->test_interfaces()->GetTestRunner()->DumpPixelsAsync(
+      web_view(), base::Bind(&TestRunnerForSpecificView::CapturePixelsCallback,
+                             weak_factory_.GetWeakPtr(),
+                             base::Passed(std::move(persistent_callback))));
 }
 
 void TestRunner::OnLayoutTestRuntimeFlagsChanged() {
   if (layout_test_runtime_flags_.tracked_dictionary().changed_values().empty())
     return;
 
   delegate_->OnLayoutTestRuntimeFlagsChanged(
       layout_test_runtime_flags_.tracked_dictionary().changed_values());
   layout_test_runtime_flags_.tracked_dictionary().ResetChangeTracking();
 }
 
-void TestRunner::ForceNextWebGLContextCreationToFail() {
-  if (web_view_)
-    web_view_->forceNextWebGLContextCreationToFail();
+void TestRunnerForSpecificView::ForceNextWebGLContextCreationToFail() {
+  web_view()->forceNextWebGLContextCreationToFail();
 }
 
-void TestRunner::ForceNextDrawingBufferCreationToFail() {
-  if (web_view_)
-    web_view_->forceNextDrawingBufferCreationToFail();
+void TestRunnerForSpecificView::ForceNextDrawingBufferCreationToFail() {
+  web_view()->forceNextDrawingBufferCreationToFail();
 }
 
-void TestRunner::CopyImageAtAndCapturePixelsAsyncThen(
-    int x, int y, v8::Local<v8::Function> callback) {
+void TestRunnerForSpecificView::CopyImageAtAndCapturePixelsAsyncThen(
+    int x,
+    int y,
+    v8::Local<v8::Function> callback) {
   v8::UniquePersistent<v8::Function> persistent_callback(
       blink::mainThreadIsolate(), callback);
 
-  if (!web_view_) {
-    CapturePixelsCallback(std::move(persistent_callback), SkBitmap());
-    return;
-  }
-
   CopyImageAtAndCapturePixels(
-      web_view_, x, y,
-      base::Bind(&TestRunner::CapturePixelsCallback, weak_factory_.GetWeakPtr(),
+      web_view(), x, y,
+      base::Bind(&TestRunnerForSpecificView::CapturePixelsCallback,
+                 weak_factory_.GetWeakPtr(),
                  base::Passed(std::move(persistent_callback))));
 }
 
-void TestRunner::GetManifestCallback(
+void TestRunnerForSpecificView::GetManifestCallback(
     v8::UniquePersistent<v8::Function> callback,
     const blink::WebURLResponse& response,
     const std::string& data) {
   PostV8CallbackWithArgs(std::move(callback), 0, nullptr);
 }
 
-void TestRunner::CapturePixelsCallback(
+void TestRunnerForSpecificView::CapturePixelsCallback(
     v8::UniquePersistent<v8::Function> callback,
     const SkBitmap& snapshot) {
-  if (!web_view_)
-    return;
-
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
 
   v8::Local<v8::Context> context =
-      web_view_->mainFrame()->mainWorldScriptContext();
+      web_view()->mainFrame()->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
   v8::Local<v8::Value> argv[3];
   SkAutoLockPixels snapshot_lock(snapshot);
 
   // Size can be 0 for cases where copyImageAt was called on position
   // that doesn't have an image.
   int width = snapshot.info().width();
@@ skipping 16 matching lines @@
     // We only expect readPixels to fail for null bitmaps.
     DCHECK(snapshot.isNull());
   }
 
   argv[2] = blink::WebArrayBufferConverter::toV8Value(
       &buffer, context->Global(), isolate);
 
   PostV8CallbackWithArgs(std::move(callback), arraysize(argv), argv);
 }
 
-void TestRunner::DispatchBeforeInstallPromptCallback(
+void TestRunnerForSpecificView::DispatchBeforeInstallPromptCallback(
     v8::UniquePersistent<v8::Function> callback,
     bool canceled) {
-  if (!web_view_)
-    return;
-
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
 
   v8::Local<v8::Context> context =
-      web_view_->mainFrame()->mainWorldScriptContext();
+      web_view()->mainFrame()->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
   v8::Local<v8::Value> arg;
   arg = v8::Boolean::New(isolate, canceled);
 
   PostV8CallbackWithArgs(std::move(callback), 1, &arg);
 }
 
-void TestRunner::GetBluetoothManualChooserEventsCallback(
+void TestRunnerForSpecificView::GetBluetoothManualChooserEventsCallback(
     v8::UniquePersistent<v8::Function> callback,
     const std::vector<std::string>& events) {
-  if (!web_view_)
-    return;
-
   // Build the V8 context.
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context =
-      web_view_->mainFrame()->mainWorldScriptContext();
+      web_view()->mainFrame()->mainWorldScriptContext();
   if (context.IsEmpty())
     return;
   v8::Context::Scope context_scope(context);
 
   // Convert the argument.
   v8::Local<v8::Value> arg;
   if (!gin::TryConvertToV8(isolate, events, &arg))
     return;
 
   // Call the callback.
@@ skipping 31 matching lines @@
 }
 
 void TestRunner::CompleteNotifyDone() {
   if (layout_test_runtime_flags_.wait_until_done() && !topLoadingFrame() &&
       work_queue_.is_empty())
     delegate_->TestFinished();
   layout_test_runtime_flags_.set_wait_until_done(false);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
-void TestRunner::DidAcquirePointerLockInternal() {
+void TestRunnerForSpecificView::DidAcquirePointerLockInternal() {
   pointer_locked_ = true;
-  web_view_->didAcquirePointerLock();
+  web_view()->didAcquirePointerLock();
 
   // Reset planned result to default.
   pointer_lock_planned_result_ = PointerLockWillSucceed;
 }
 
-void TestRunner::DidNotAcquirePointerLockInternal() {
+void TestRunnerForSpecificView::DidNotAcquirePointerLockInternal() {
   DCHECK(!pointer_locked_);
   pointer_locked_ = false;
-  web_view_->didNotAcquirePointerLock();
+  web_view()->didNotAcquirePointerLock();
 
   // Reset planned result to default.
   pointer_lock_planned_result_ = PointerLockWillSucceed;
 }
 
-void TestRunner::DidLosePointerLockInternal() {
+void TestRunnerForSpecificView::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
-    web_view_->didLosePointerLock();
+    web_view()->didLosePointerLock();
+}
+
+TestRunnerForSpecificView::TestRunnerForSpecificView(
+    WebTestProxyBase* web_test_proxy_base)
+    : web_test_proxy_base_(web_test_proxy_base), weak_factory_(this) {
+  Reset();
+}
+
+TestRunnerForSpecificView::~TestRunnerForSpecificView() {}
+
+void TestRunnerForSpecificView::Install(blink::WebLocalFrame* frame) {
+  web_test_proxy_base_->test_interfaces()->GetTestRunner()->Install(
+      frame, weak_factory_.GetWeakPtr());
+}
+
+void TestRunnerForSpecificView::Reset() {
+  pointer_locked_ = false;
+  pointer_lock_planned_result_ = PointerLockWillSucceed;
+
+  if (web_view() && web_view()->mainFrame()) {
+    RemoveWebPageOverlay();
+    SetTabKeyCyclesThroughElements(true);
+
+#if !defined(OS_MACOSX) && !defined(OS_WIN)
+    // (Constants copied because we can't depend on the header that defined
+    // them from this file.)
+    web_view()->setSelectionColors(
+        0xff1e90ff, 0xff000000, 0xffc8c8c8, 0xff323232);
+#endif
+    web_view()->setVisibilityState(WebPageVisibilityStateVisible, true);
+    if (web_view()->mainFrame()->isWebLocalFrame()) {
+      web_view()->mainFrame()->enableViewSourceMode(false);
+      web_view()->setTextZoomFactor(1);
+      web_view()->setZoomLevel(0);
+    }
+  }
+}
+
+void TestRunnerForSpecificView::SetViewSourceForFrame(const std::string& name,
+                                                      bool enabled) {
+  WebFrame* target_frame =
+      web_view()->findFrameByName(WebString::fromUTF8(name));
+  if (target_frame)
+    target_frame->enableViewSourceMode(enabled);
+}
+
+blink::WebView* TestRunnerForSpecificView::web_view() {
+  return web_test_proxy_base_->web_view();
+}
+
+WebTestDelegate* TestRunnerForSpecificView::delegate() {
+  return web_test_proxy_base_->delegate();
 }
 
 }  // namespace test_runner