Extract WebViewClient implementation out of WebTestProxyBase.

content/shell/renderer/layout_test/blink_test_runner.cc

 // Copyright (c) 2012 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 "content/shell/renderer/layout_test/blink_test_runner.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <clocale>
 #include <cmath>
@@ skipping 110 matching lines @@
   ~SyncNavigationStateVisitor() override {}
 
   bool Visit(RenderView* render_view) override {
     SyncNavigationState(render_view);
     return true;
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(SyncNavigationStateVisitor);
 };
 
-class ProxyToRenderViewVisitor : public RenderViewVisitor {
- public:
-  explicit ProxyToRenderViewVisitor(test_runner::WebTestProxyBase* proxy)
-      : proxy_(proxy),
-        render_view_(NULL) {
-  }
-  ~ProxyToRenderViewVisitor() override {}
-
-  RenderView* render_view() const { return render_view_; }
-
-  bool Visit(RenderView* render_view) override {
-    BlinkTestRunner* test_runner = BlinkTestRunner::Get(render_view);
-    if (!test_runner) {
-      NOTREACHED();
-      return true;
-    }
-    if (test_runner->proxy() == proxy_) {
-      render_view_ = render_view;
-      return false;
-    }
-    return true;
-  }
-
- private:
-  test_runner::WebTestProxyBase* proxy_;
-  RenderView* render_view_;
-
-  DISALLOW_COPY_AND_ASSIGN(ProxyToRenderViewVisitor);
-};
-
 class UseSynchronousResizeModeVisitor : public RenderViewVisitor {
  public:
   explicit UseSynchronousResizeModeVisitor(bool enable) : enable_(enable) {}
   ~UseSynchronousResizeModeVisitor() override {}
 
   bool Visit(RenderView* render_view) override {
     UseSynchronousResizeMode(render_view, enable_);
     return true;
   }
 
@@ skipping 338 matching lines @@
 
 void BlinkTestRunner::ClearGeofencingMockProvider() {
   content::ClearGeofencingMockProvider();
 }
 
 void BlinkTestRunner::SetGeofencingMockPosition(double latitude,
                                                 double longitude) {
   content::SetGeofencingMockPosition(latitude, longitude);
 }
 
-void BlinkTestRunner::SetFocus(test_runner::WebTestProxyBase* proxy,
-                               bool focus) {
-  ProxyToRenderViewVisitor visitor(proxy);
-  RenderView::ForEach(&visitor);
-  if (!visitor.render_view()) {
+void BlinkTestRunner::SetFocus(blink::WebView* web_view, bool focus) {
+  RenderView* render_view = RenderView::FromWebView(web_view);
+  if (!render_view) {
     NOTREACHED();
     return;
   }
 
   // Check whether the focused view was closed meanwhile.
   if (!BlinkTestRunner::Get(focused_view_))
     focused_view_ = NULL;
 
   if (focus) {
-    if (focused_view_ != visitor.render_view()) {
+    if (focused_view_ != render_view) {
       if (focused_view_)
         SetFocusAndActivate(focused_view_, false);
-      SetFocusAndActivate(visitor.render_view(), true);
-      focused_view_ = visitor.render_view();
+      SetFocusAndActivate(render_view, true);
+      focused_view_ = render_view;
     }
   } else {
-    if (focused_view_ == visitor.render_view()) {
-      SetFocusAndActivate(visitor.render_view(), false);
+    if (focused_view_ == render_view) {
+      SetFocusAndActivate(render_view, false);
       focused_view_ = NULL;
     }
   }
 }
 
 void BlinkTestRunner::SetAcceptAllCookies(bool accept) {
   Send(new LayoutTestHostMsg_AcceptAllCookies(routing_id(), accept));
 }
 
 std::string BlinkTestRunner::PathToLocalResource(const std::string& resource) {
@@ skipping 258 matching lines @@
 }
 
 void BlinkTestRunner::DidFailProvisionalLoad(WebLocalFrame* frame,
                                              const WebURLError& error) {
   focus_on_next_commit_ = false;
 }
 
 // Public methods - -----------------------------------------------------------
 
 void BlinkTestRunner::Reset(bool for_new_test) {
-  // The proxy_ is always non-NULL, it is set right after construction.
-  proxy_->set_widget(render_view()->GetWebView());
-  proxy_->Reset();
   prefs_.Reset();
   routing_ids_.clear();
   session_histories_.clear();
   current_entry_indexes_.clear();
 
   render_view()->ClearEditCommands();
   if (for_new_test) {
     if (render_view()->GetWebView()->mainFrame()->isWebLocalFrame())
       render_view()->GetWebView()->mainFrame()->setName(WebString());
     render_view()->GetWebView()->mainFrame()->clearOpener();
@@ skipping 132 matching lines @@
                                       params.enable_pixel_dumping);
 }
 
 void BlinkTestRunner::OnSetTestConfiguration(
     const ShellTestConfiguration& params) {
   OnReplicateTestConfiguration(params);
 
   ForceResizeRenderView(
       render_view(),
       WebSize(params.initial_size.width(), params.initial_size.height()));
-  SetFocus(proxy_, true);
+  SetFocus(proxy_->web_view(), true);
 }
 
 void BlinkTestRunner::OnSessionHistory(
     const std::vector<int>& routing_ids,
     const std::vector<std::vector<PageState>>& session_histories,
     const std::vector<unsigned>& current_entry_indexes) {
   routing_ids_ = routing_ids;
   session_histories_ = session_histories;
   current_entry_indexes_ = current_entry_indexes;
   CaptureDump();
@@ skipping 31 matching lines @@
   get_bluetooth_events_callbacks_.pop_front();
   callback.Run(events);
 }
 
 void BlinkTestRunner::ReportLeakDetectionResult(
     const LeakDetectionResult& report) {
   Send(new ShellViewHostMsg_LeakDetectionDone(routing_id(), report));
 }
 
 }  // namespace content