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 385 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 45 matching lines @@
 }
 
 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();
@@ skipping 56 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);
 }
 
@@ skipping 83 matching lines @@
 
 void TestRunner::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 TestRunner::PostV8Callback(const v8::Local<v8::Function>& callback) {
-  PostTask(base::Bind(&TestRunner::InvokeV8Callback, weak_factory_.GetWeakPtr(),
+void TestRunnerForSpecificView::PostTask(const base::Closure& callback) {
+  delegate()->PostTask(new WebCallbackTask(callback));
+}
+
+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 321 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 461 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 35 matching lines @@
       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 55 matching lines @@
   pointer_lock_planned_result_ = PointerLockWillSucceed;
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
+TestRunnerForSpecificView::TestRunnerForSpecificView(
+    WebTestProxyBase* web_test_proxy_base)
+    : web_test_proxy_base_(web_test_proxy_base), weak_factory_(this) {}
+
+TestRunnerForSpecificView::~TestRunnerForSpecificView() {}
+
+void TestRunnerForSpecificView::Install(blink::WebLocalFrame* frame) {
+  web_test_proxy_base_->test_interfaces()->GetTestRunner()->Install(
+      frame, weak_factory_.GetWeakPtr());
+}
+
+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