Use MojoCompositorFrameSink in RendererCompositorFrameSink

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 43 matching lines @@
 #include "content/common/input_messages.h"
 #include "content/common/text_input_state.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/keyboard_event_processing_result.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents_view_delegate.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/context_menu_params.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
+#include "content/test/fake_renderer_compositor_frame_sink.h"
 #include "content/test/test_render_view_host.h"
 #include "content/test/test_web_contents.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_test_sink.h"
 #include "media/base/video_frame.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/window_parenting_client.h"
@@ skipping 331 matching lines @@
 
 class FakeRenderWidgetHostViewAura : public RenderWidgetHostViewAura {
  public:
   FakeRenderWidgetHostViewAura(RenderWidgetHost* widget,
                                bool is_guest_view_hack)
       : RenderWidgetHostViewAura(widget, is_guest_view_hack),
         delegated_frame_host_client_(
             new FakeDelegatedFrameHostClientAura(this)) {
     InstallDelegatedFrameHostClient(
         this, base::WrapUnique(delegated_frame_host_client_));
+    CreateNewRendererCompositorFrameSink();
   }
 
   ~FakeRenderWidgetHostViewAura() override {}
 
+  void CreateNewRendererCompositorFrameSink() {
+    cc::mojom::MojoCompositorFrameSinkPtr sink;
+    cc::mojom::MojoCompositorFrameSinkRequest sink_request =
+        mojo::MakeRequest(&sink);
+    cc::mojom::MojoCompositorFrameSinkClientRequest client_request =
+        mojo::MakeRequest(&renderer_compositor_frame_sink_ptr_);
+    renderer_compositor_frame_sink_ =
+        base::MakeUnique<FakeRendererCompositorFrameSink>(
+            std::move(sink), std::move(client_request));
+    DidCreateNewRendererCompositorFrameSink(
+        renderer_compositor_frame_sink_ptr_.get());
+  }
+
   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));
   }
 
@@ skipping 41 matching lines @@
   bool resize_locked() const {
     return delegated_frame_host_client_->resize_locked();
   }
   bool compositor_locked() const {
     return delegated_frame_host_client_->compositor_locked();
   }
 
   gfx::Size last_frame_size_;
   std::unique_ptr<cc::CopyOutputRequest> last_copy_request_;
   FakeWindowEventDispatcher* dispatcher_;
+  std::unique_ptr<FakeRendererCompositorFrameSink>
+      renderer_compositor_frame_sink_;
 
  private:
   FakeDelegatedFrameHostClientAura* delegated_frame_host_client_;
+  cc::mojom::MojoCompositorFrameSinkClientPtr
+      renderer_compositor_frame_sink_ptr_;
 
   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 {}
 
@@ skipping 1544 matching lines @@
       gfx::Rect());
   view_->SetSize(view_size);
   view_->Show();
   sink_->ClearMessages();
 
   // Accumulate some returned resources. This should trigger an IPC.
   cc::ReturnedResourceArray resources;
   cc::ReturnedResource resource;
   resource.id = 1;
   resources.push_back(resource);
+  view_->renderer_compositor_frame_sink_->Reset();
   view_->ReclaimResources(resources);
-  EXPECT_EQ(1u, sink_->message_count());
-  {
-    const IPC::Message* msg = sink_->GetMessageAt(0);
-    EXPECT_EQ(ViewMsg_ReclaimCompositorResources::ID, msg->type());
-    ViewMsg_ReclaimCompositorResources::Param params;
-    ViewMsg_ReclaimCompositorResources::Read(msg, &params);
-    EXPECT_FALSE(std::get<1>(params));   // is_swap_ack
-  }
+  view_->renderer_compositor_frame_sink_->Flush();
+  EXPECT_FALSE(view_->renderer_compositor_frame_sink_->did_receive_ack());
+  EXPECT_FALSE(
+      view_->renderer_compositor_frame_sink_->last_reclaimed_resources()
+          .empty());
 }
 
 // This test verifies that when the compositor_frame_sink_id changes, the old
 // resources are not returned.
 TEST_F(RenderWidgetHostViewAuraTest, TwoOutputSurfaces) {
   FakeSurfaceObserver manager_observer;
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   cc::SurfaceManager* manager =
       factory->GetContextFactoryPrivate()->GetSurfaceManager();
   manager->AddObserver(&manager_observer);
@@ skipping 11 matching lines @@
 
   // Submit a frame with resources.
   cc::CompositorFrame frame = MakeDelegatedFrame(1.f, view_size, view_rect);
   cc::TransferableResource resource;
   resource.id = 1;
   frame.resource_list.push_back(resource);
   view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId, std::move(frame));
   EXPECT_EQ(0u, sink_->message_count());
 
   // Signal that a new RendererCompositorFrameSink was created by the renderer.
-  view_->DidCreateNewRendererCompositorFrameSink();
+  view_->CreateNewRendererCompositorFrameSink();
 
   // Submit another frame. The resources for the previous frame belong to the
   // old RendererCompositorFrameSink and should not be returned.
   view_->SubmitCompositorFrame(CreateLocalSurfaceId(),
                                MakeDelegatedFrame(1.f, view_size, view_rect));
   EXPECT_EQ(0u, sink_->message_count());
 
   // Report that the surface is drawn to trigger an ACK.
+  view_->renderer_compositor_frame_sink_->Reset();
   cc::Surface* surface = manager->GetSurfaceForId(view_->surface_id());
   EXPECT_TRUE(surface);
   surface->RunDrawCallbacks();
-  EXPECT_EQ(1u, sink_->message_count());
-  {
-    const IPC::Message* msg = sink_->GetMessageAt(0);
-    EXPECT_EQ(ViewMsg_ReclaimCompositorResources::ID, msg->type());
-    ViewMsg_ReclaimCompositorResources::Param params;
-    ViewMsg_ReclaimCompositorResources::Read(msg, &params);
-    EXPECT_EQ(true, std::get<1>(params));  // is_swap_ack
-  }
+  view_->renderer_compositor_frame_sink_->Flush();
+  EXPECT_TRUE(view_->renderer_compositor_frame_sink_->did_receive_ack());
 
   manager->RemoveObserver(&manager_observer);
 }
 
 // Resizing in fullscreen mode should send the up-to-date screen info.
 // http://crbug.com/324350
 TEST_F(RenderWidgetHostViewAuraTest, DISABLED_FullscreenResize) {
   aura::Window* root_window = aura_test_helper_->root_window();
   root_window->SetLayoutManager(new FullscreenLayoutManager(root_window));
   view_->InitAsFullscreen(parent_view_);
@@ skipping 212 matching lines @@
   sink_->ClearMessages();
 
   // Resize renderer again, before receiving a frame. Should not produce a
   // Resize message.
   view_->SetSize(size3);
   EXPECT_EQ(size2.ToString(), view_->GetRequestedRendererSize().ToString());
   EXPECT_EQ(0u, sink_->message_count());
 
   // Receive a frame of the new size, should be skipped and not produce a Resize
   // message.
+  view_->renderer_compositor_frame_sink_->Reset();
   view_->SubmitCompositorFrame(
       kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, size3, gfx::Rect(size3)));
+  view_->renderer_compositor_frame_sink_->Flush();
   // Expect the frame ack;
-  EXPECT_EQ(1u, sink_->message_count());
-  EXPECT_EQ(ViewMsg_ReclaimCompositorResources::ID,
-            sink_->GetMessageAt(0)->type());
-  sink_->ClearMessages();
+  EXPECT_TRUE(view_->renderer_compositor_frame_sink_->did_receive_ack());
   EXPECT_EQ(size2.ToString(), view_->GetRequestedRendererSize().ToString());
 
   // Receive a frame of the correct size, should not be skipped and, and should
   // produce a Resize message after the commit.
+  view_->renderer_compositor_frame_sink_->Reset();
   view_->SubmitCompositorFrame(
       kArbitraryLocalSurfaceId,
       MakeDelegatedFrame(1.f, size2, gfx::Rect(size2)));
+  view_->renderer_compositor_frame_sink_->Flush();
   cc::SurfaceId surface_id = view_->surface_id();
   if (!surface_id.is_valid()) {
     // No frame ack yet.
-    EXPECT_EQ(0u, sink_->message_count());
+    EXPECT_FALSE(view_->renderer_compositor_frame_sink_->did_receive_ack());
   } else {
     // Frame isn't desired size, so early ack.
-    EXPECT_EQ(1u, sink_->message_count());
+    EXPECT_TRUE(view_->renderer_compositor_frame_sink_->did_receive_ack());
   }
   EXPECT_EQ(size2.ToString(), view_->GetRequestedRendererSize().ToString());
 
   // Wait for commit, then we should unlock the compositor and send a Resize
   // message (and a frame ack)
   ui::DrawWaiterForTest::WaitForCommit(
       root_window->GetHost()->compositor());
 
   bool has_resize = false;
   for (uint32_t i = 0; i < sink_->message_count(); ++i) {
     const IPC::Message* msg = sink_->GetMessageAt(i);
     switch (msg->type()) {
       case InputMsg_HandleInputEvent::ID: {
         // On some platforms, the call to view_->Show() causes a posted task to
         // call
         // ui::WindowEventDispatcher::SynthesizeMouseMoveAfterChangeToWindow,
         // which the above WaitForCommit may cause to be picked up. Be robust
         // to this extra IPC coming in.
         InputMsg_HandleInputEvent::Param params;
         InputMsg_HandleInputEvent::Read(msg, &params);
         const blink::WebInputEvent* event = std::get<0>(params);
         EXPECT_EQ(blink::WebInputEvent::kMouseMove, event->GetType());
         break;
       }
-      case ViewMsg_ReclaimCompositorResources::ID:
-        break;
       case ViewMsg_Resize::ID: {
         EXPECT_FALSE(has_resize);
         ViewMsg_Resize::Param params;
         ViewMsg_Resize::Read(msg, &params);
         EXPECT_EQ(size3.ToString(), std::get<0>(params).new_size.ToString());
         has_resize = true;
         break;
       }
       default:
         ADD_FAILURE() << "Unexpected message " << msg->type();
@@ skipping 219 matching lines @@
   view_->window_->AddObserver(&observer);
 
   // Swap a frame.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
   view_->SubmitCompositorFrame(kArbitraryLocalSurfaceId,
                                MakeDelegatedFrame(1.f, frame_size, view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   // Signal that a new RendererCompositorFrameSink was created.
-  view_->DidCreateNewRendererCompositorFrameSink();
+  view_->CreateNewRendererCompositorFrameSink();
 
   // Submit a frame from the new RendererCompositorFrameSink.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
   view_->SubmitCompositorFrame(CreateLocalSurfaceId(),
                                MakeDelegatedFrame(1.f, frame_size, view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   // Signal that a new RendererCompositorFrameSink was created.
-  view_->DidCreateNewRendererCompositorFrameSink();
+  view_->CreateNewRendererCompositorFrameSink();
 
   // Submit a frame from the new RendererCompositorFrameSink.
   view_->SubmitCompositorFrame(
       CreateLocalSurfaceId(),
       MakeDelegatedFrame(1.f, gfx::Size(), gfx::Rect()));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   // Signal that a new RendererCompositorFrameSink was created.
-  view_->DidCreateNewRendererCompositorFrameSink();
+  view_->CreateNewRendererCompositorFrameSink();
 
   // Swap another frame, with a different surface id.
   EXPECT_CALL(observer, OnDelegatedFrameDamage(view_->window_, view_rect));
   view_->SubmitCompositorFrame(CreateLocalSurfaceId(),
                                MakeDelegatedFrame(1.f, frame_size, view_rect));
   testing::Mock::VerifyAndClearExpectations(&observer);
   view_->RunOnCompositingDidCommit();
 
   view_->window_->RemoveObserver(&observer);
 }
@@ skipping 2775 matching lines @@
     // There is no composition in the beginning.
     EXPECT_FALSE(has_composition_text());
     SetHasCompositionTextToTrue();
     view->ImeCancelComposition();
     // The composition must have been canceled.
     EXPECT_FALSE(has_composition_text());
   }
 }
 
 }  // namespace content