Extract WebWidgetTestClient out of WebTestProxyBase and WebViewTestClient.

components/test_runner/web_test_proxy.h

 // 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.
 
 #ifndef COMPONENTS_TEST_RUNNER_WEB_TEST_PROXY_H_
 #define COMPONENTS_TEST_RUNNER_WEB_TEST_PROXY_H_
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "build/build_config.h"
 #include "components/test_runner/test_runner_export.h"
 #include "components/test_runner/web_view_test_client.h"
+#include "components/test_runner/web_widget_test_client.h"
 #include "third_party/WebKit/public/platform/WebDragOperation.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebDOMMessageEvent.h"
 #include "third_party/WebKit/public/web/WebHistoryCommitType.h"
 #include "third_party/WebKit/public/web/WebNavigationPolicy.h"
 #include "third_party/WebKit/public/web/WebTextDirection.h"
 #include "third_party/WebKit/public/web/WebViewClient.h"
@@ skipping 43 matching lines @@
     web_view_ = view;
   }
 
   void set_view_test_client(
       std::unique_ptr<WebViewTestClient> view_test_client) {
     DCHECK(view_test_client);
     DCHECK(!view_test_client_);
     view_test_client_ = std::move(view_test_client);
   }
 
+  void set_widget_test_client(
+      std::unique_ptr<WebWidgetTestClient> widget_test_client) {
+    DCHECK(widget_test_client);
+    DCHECK(!widget_test_client_);
+    widget_test_client_ = std::move(widget_test_client);
+  }
+
   WebTestDelegate* delegate() { return delegate_; }
   void set_delegate(WebTestDelegate* delegate) {
     DCHECK(delegate);
     DCHECK(!delegate_);
     delegate_ = delegate;
   }
 
   TestInterfaces* test_interfaces() { return test_interfaces_; }
   void SetInterfaces(WebTestInterfaces* web_test_interfaces);
 
@@ skipping 11 matching lines @@
   void Reset();
   void BindTo(blink::WebLocalFrame* frame);
 
   void GetScreenOrientationForTesting(blink::WebScreenInfo&);
 
  protected:
   WebTestProxyBase();
   ~WebTestProxyBase();
 
   blink::WebViewClient* view_test_client() { return view_test_client_.get(); }
+  blink::WebWidgetClient* widget_test_client() {
+    return widget_test_client_.get();
+  }
 
  private:
   TestInterfaces* test_interfaces_;
   WebTestDelegate* delegate_;
   blink::WebView* web_view_;
   blink::WebWidget* web_widget_;
   std::unique_ptr<WebViewTestClient> view_test_client_;
+  std::unique_ptr<WebWidgetTestClient> widget_test_client_;
   std::unique_ptr<AccessibilityController> accessibility_controller_;
   std::unique_ptr<EventSender> event_sender_;
   std::unique_ptr<TextInputController> text_input_controller_;
   std::unique_ptr<TestRunnerForSpecificView> view_test_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(WebTestProxyBase);
 };
 
 // WebTestProxy is used during LayoutTests and always instantiated, at time of
 // writing with Base=RenderViewImpl. It does not directly inherit from it for
@@ skipping 18 matching lines @@
 #pragma warning(disable: 4250)
 #endif
 template <class Base, typename... Args>
 class WebTestProxy : public Base, public WebTestProxyBase {
  public:
   explicit WebTestProxy(Args... args) : Base(args...) {}
 
   // WebWidgetClient implementation.
   blink::WebScreenInfo screenInfo() override {
     blink::WebScreenInfo info = Base::screenInfo();
-    WebTestProxyBase::GetScreenOrientationForTesting(info);
+    blink::WebScreenInfo test_info = widget_test_client()->screenInfo();
+    if (test_info.orientationType != blink::WebScreenOrientationUndefined) {
+      info.orientationType = test_info.orientationType;
+      info.orientationAngle = test_info.orientationAngle;
+    }
     return info;
   }
+  void scheduleAnimation() override {
+    widget_test_client()->scheduleAnimation();
+  }
+  bool requestPointerLock() override {
+    return widget_test_client()->requestPointerLock();
+  }
+  void requestPointerUnlock() override {
+    widget_test_client()->requestPointerUnlock();
+  }
+  bool isPointerLocked() override {
+    return widget_test_client()->isPointerLocked();
+  }
+  void didFocus() override {
+    widget_test_client()->didFocus();
+    Base::didFocus();
+  }
+  void setToolTipText(const blink::WebString& text,
+                      blink::WebTextDirection hint) override {
+    widget_test_client()->setToolTipText(text, hint);
+    Base::setToolTipText(text, hint);
+  }
+  void resetInputMethod() override { widget_test_client()->resetInputMethod(); }
 
   // WebViewClient implementation.
-  void scheduleAnimation() override { view_test_client()->scheduleAnimation(); }
   void startDragging(blink::WebLocalFrame* frame,
                      const blink::WebDragData& data,
                      blink::WebDragOperationsMask mask,
                      const blink::WebImage& image,
                      const blink::WebPoint& point) override {
     view_test_client()->startDragging(frame, data, mask, image, point);
     // Don't forward this call to Base because we don't want to do a real
     // drag-and-drop.
   }
   void didChangeContents() override {
@@ skipping 15 matching lines @@
   void setStatusText(const blink::WebString& text) override {
     view_test_client()->setStatusText(text);
     Base::setStatusText(text);
   }
   void printPage(blink::WebLocalFrame* frame) override {
     view_test_client()->printPage(frame);
   }
   blink::WebSpeechRecognizer* speechRecognizer() override {
     return view_test_client()->speechRecognizer();
   }
-  bool requestPointerLock() override {
-    return view_test_client()->requestPointerLock();
-  }
-  void requestPointerUnlock() override {
-    view_test_client()->requestPointerUnlock();
-  }
-  bool isPointerLocked() override {
-    return view_test_client()->isPointerLocked();
-  }
-  void didFocus() override {
-    view_test_client()->didFocus();
-    Base::didFocus();
-  }
-  void setToolTipText(const blink::WebString& text,
-                      blink::WebTextDirection hint) override {
-    view_test_client()->setToolTipText(text, hint);
-    Base::setToolTipText(text, hint);
-  }
-  void resetInputMethod() override { view_test_client()->resetInputMethod(); }
   bool runFileChooser(const blink::WebFileChooserParams& params,
                       blink::WebFileChooserCompletion* completion) override {
     return view_test_client()->runFileChooser(params, completion);
   }
   void showValidationMessage(
       const blink::WebRect& anchor_in_root_view,
       const blink::WebString& main_message,
       blink::WebTextDirection main_message_hint,
       const blink::WebString& sub_message,
       blink::WebTextDirection sub_message_hint) override {
     view_test_client()->showValidationMessage(anchor_in_root_view, main_message,
                                               main_message_hint, sub_message,
                                               sub_message_hint);
   }
   blink::WebString acceptLanguages() override {
     return view_test_client()->acceptLanguages();
   }
 
  private:
   virtual ~WebTestProxy() {}
 
   DISALLOW_COPY_AND_ASSIGN(WebTestProxy);
 };
 
 }  // namespace test_runner
 
 #endif  // COMPONENTS_TEST_RUNNER_WEB_TEST_PROXY_H_