Removes WebContentsViewMus/RenderWidgetHostViewMus

content/browser/renderer_host/render_widget_host_view_aura_unittest.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/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <tuple>
@@ skipping 15 matching lines @@
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_manager.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/compositor/test/no_transport_image_transport_factory.h"
 #include "content/browser/frame_host/render_widget_host_view_guest.h"
 #include "content/browser/gpu/compositor_util.h"
+#include "content/browser/renderer_host/delegated_frame_host.h"
+#include "content/browser/renderer_host/delegated_frame_host_client_aura.h"
 #include "content/browser/renderer_host/input/input_router.h"
 #include "content/browser/renderer_host/input/mouse_wheel_event_queue.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/browser/renderer_host/overscroll_controller_delegate.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_event_handler.h"
 #include "content/browser/renderer_host/resize_lock.h"
 #include "content/browser/renderer_host/text_input_manager.h"
@@ skipping 53 matching lines @@
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using ui::WebInputEventTraits;
 
 namespace content {
+
+void InstallDelegatedFrameHostClient(
+    RenderWidgetHostViewAura* render_widget_host_view,
+    std::unique_ptr<DelegatedFrameHostClient> delegated_frame_host_client);
+
 namespace {
 
 class TestOverscrollDelegate : public OverscrollControllerDelegate {
  public:
   explicit TestOverscrollDelegate(RenderWidgetHostView* view)
       : view_(view),
         current_mode_(OVERSCROLL_NONE),
         completed_mode_(OVERSCROLL_NONE),
         delta_x_(0.f),
         delta_y_(0.f) {}
@@ skipping 197 matching lines @@
   size_t GetAndResetProcessedTouchEventCount() {
     size_t count = processed_touch_event_count_;
     processed_touch_event_count_ = 0;
     return count;
   }
 
  private:
   size_t processed_touch_event_count_;
 };
 
+class FakeDelegatedFrameHostClientAura : public DelegatedFrameHostClientAura {
+ public:
+  explicit FakeDelegatedFrameHostClientAura(
+      RenderWidgetHostViewAura* render_widget_host_view)
+      : DelegatedFrameHostClientAura(render_widget_host_view) {}
+  ~FakeDelegatedFrameHostClientAura() override {}
+
+  void DisableResizeLock() { can_create_resize_lock_ = false; }
+
+ private:
+  // A lock that doesn't actually do anything to the compositor, and does not
+  // time out.
+  class FakeResizeLock : public ResizeLock {
+   public:
+    FakeResizeLock(const gfx::Size new_size, bool defer_compositor_lock)
+        : ResizeLock(new_size, defer_compositor_lock) {}
+  };
+
+  // DelegatedFrameHostClientAura:
+  std::unique_ptr<ResizeLock> DelegatedFrameHostCreateResizeLock(
+      bool defer_compositor_lock) override {
+    gfx::Size desired_size =
+        render_widget_host_view()->GetNativeView()->bounds().size();
+    return std::unique_ptr<ResizeLock>(
+        new FakeResizeLock(desired_size, defer_compositor_lock));
+  }
+  bool DelegatedFrameCanCreateResizeLock() const override {
+    return can_create_resize_lock_;
+  }
+
+  bool can_create_resize_lock_ = true;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeDelegatedFrameHostClientAura);
+};
+
 class FakeRenderWidgetHostViewAura : public RenderWidgetHostViewAura {
  public:
   FakeRenderWidgetHostViewAura(RenderWidgetHost* widget,
                                bool is_guest_view_hack)
       : RenderWidgetHostViewAura(widget, is_guest_view_hack),
-        can_create_resize_lock_(true) {}
+        delegated_frame_host_client_(
+            new FakeDelegatedFrameHostClientAura(this)) {
+    std::unique_ptr<DelegatedFrameHostClient> client(
+        delegated_frame_host_client_);
+    InstallDelegatedFrameHostClient(this, std::move(client));
+  }
+
+  ~FakeRenderWidgetHostViewAura() override {}
+
+  void DisableResizeLock() {
+    delegated_frame_host_client_->DisableResizeLock();
+  }
 
   void UseFakeDispatcher() {
     dispatcher_ = new FakeWindowEventDispatcher(window()->GetHost());
     std::unique_ptr<aura::WindowEventDispatcher> dispatcher(dispatcher_);
     aura::test::SetHostDispatcher(window()->GetHost(), std::move(dispatcher));
   }
 
-  ~FakeRenderWidgetHostViewAura() override {}
-
-  std::unique_ptr<ResizeLock> DelegatedFrameHostCreateResizeLock(
-      bool defer_compositor_lock) override {
-    gfx::Size desired_size = window()->bounds().size();
-    return std::unique_ptr<ResizeLock>(
-        new FakeResizeLock(desired_size, defer_compositor_lock));
-  }
-
-  bool DelegatedFrameCanCreateResizeLock() const override {
-    return can_create_resize_lock_;
-  }
-
   void RunOnCompositingDidCommit() {
     GetDelegatedFrameHost()->OnCompositingDidCommitForTesting(
         window()->GetHost()->compositor());
   }
 
   void InterceptCopyOfOutput(std::unique_ptr<cc::CopyOutputRequest> request) {
     last_copy_request_ = std::move(request);
     if (last_copy_request_->has_texture_mailbox()) {
       // Give the resulting texture a size.
       display_compositor::GLHelper* gl_helper =
@@ skipping 19 matching lines @@
   bool released_front_lock_active() const {
     return GetDelegatedFrameHost()->ReleasedFrontLockActiveForTesting();
   }
 
   void ReturnResources(const cc::ReturnedResourceArray& resources) {
     GetDelegatedFrameHost()->ReturnResources(resources);
   }
 
   void ResetCompositor() { GetDelegatedFrameHost()->ResetCompositor(); }
 
-  // A lock that doesn't actually do anything to the compositor, and does not
-  // time out.
-  class FakeResizeLock : public ResizeLock {
-   public:
-    FakeResizeLock(const gfx::Size new_size, bool defer_compositor_lock)
-        : ResizeLock(new_size, defer_compositor_lock) {}
-  };
-
   const ui::MotionEventAura& pointer_state_for_test() {
     return event_handler()->pointer_state();
   }
 
-  bool can_create_resize_lock_;
   gfx::Size last_frame_size_;
   std::unique_ptr<cc::CopyOutputRequest> last_copy_request_;
   FakeWindowEventDispatcher* dispatcher_;
+
+ private:
+  FakeDelegatedFrameHostClientAura* delegated_frame_host_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeRenderWidgetHostViewAura);
 };
 
 // A layout manager that always resizes a child to the root window size.
 class FullscreenLayoutManager : public aura::LayoutManager {
  public:
   explicit FullscreenLayoutManager(aura::Window* owner) : owner_(owner) {}
   ~FullscreenLayoutManager() override {}
 
   // Overridden from aura::LayoutManager:
   void OnWindowResized() override {
@@ skipping 67 matching lines @@
 }
 
 }  // namespace
 
 class RenderWidgetHostViewAuraTest : public testing::Test {
  public:
   RenderWidgetHostViewAuraTest()
       : widget_host_uses_shutdown_to_destroy_(false),
         is_guest_view_hack_(false) {}
 
+  static void InstallDelegatedFrameHostClient(
+      RenderWidgetHostViewAura* render_widget_host_view,
+      std::unique_ptr<DelegatedFrameHostClient> delegated_frame_host_client) {
+    render_widget_host_view->delegated_frame_host_client_ =
+        std::move(delegated_frame_host_client);
+  }
+
   void SetUpEnvironment() {
     ImageTransportFactory::InitializeForUnitTests(
         std::unique_ptr<ImageTransportFactory>(
             new NoTransportImageTransportFactory));
     aura_test_helper_.reset(
         new aura::test::AuraTestHelper(base::MessageLoopForUI::current()));
     aura_test_helper_->SetUp(
         ImageTransportFactory::GetInstance()->GetContextFactory(),
         ImageTransportFactory::GetInstance()->GetContextFactoryPrivate());
     new wm::DefaultActivationClient(aura_test_helper_->root_window());
@@ skipping 179 matching lines @@
   // destruction.
   MockRenderWidgetHostImpl* widget_host_;
   FakeRenderWidgetHostViewAura* view_;
 
   IPC::TestSink* sink_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAuraTest);
 };
 
+void InstallDelegatedFrameHostClient(
+    RenderWidgetHostViewAura* render_widget_host_view,
+    std::unique_ptr<DelegatedFrameHostClient> delegated_frame_host_client) {
+  RenderWidgetHostViewAuraTest::InstallDelegatedFrameHostClient(
+      render_widget_host_view, std::move(delegated_frame_host_client));
+}
+
 // Helper class to instantiate RenderWidgetHostViewGuest which is backed
 // by an aura platform view.
 class RenderWidgetHostViewGuestAuraTest : public RenderWidgetHostViewAuraTest {
  public:
   RenderWidgetHostViewGuestAuraTest() {
     // Use RWH::Shutdown to destroy RWH, instead of deleting.
     // This will ensure that the RenderWidgetHostViewGuest is not leaked and
     // is deleted properly upon RWH going away.
     set_widget_host_uses_shutdown_to_destroy(true);
   }
@@ skipping 1232 matching lines @@
 }
 
 // If the view size is larger than the compositor frame then extra layers
 // should be created to fill the gap.
 TEST_F(RenderWidgetHostViewAuraTest, DelegatedFrameGutter) {
   gfx::Size large_size(100, 100);
   gfx::Size small_size(40, 45);
   gfx::Size medium_size(40, 95);
 
   // Prevent the DelegatedFrameHost from skipping frames.
-  view_->can_create_resize_lock_ = false;
+  // XXX
+  view_->DisableResizeLock();
 
   view_->InitAsChild(nullptr);
   aura::client::ParentWindowWithContext(
       view_->GetNativeView(), parent_view_->GetNativeView()->GetRootWindow(),
       gfx::Rect());
   view_->SetSize(large_size);
   view_->Show();
   cc::CompositorFrame frame =
       MakeDelegatedFrame(1.f, small_size, gfx::Rect(small_size));
   frame.metadata.root_background_color = SK_ColorRED;
@@ skipping 2721 matching lines @@
 
     // Retrieve the selected text from clipboard and verify it is as expected.
     base::string16 result_text;
     clipboard->ReadText(ui::CLIPBOARD_TYPE_SELECTION, &result_text);
     EXPECT_EQ(expected_text, result_text);
   }
 }
 #endif
 
 }  // namespace content