Mus: Remove dependency on ServerWindowCompositorFrameSink from FrameGenerator

services/ui/ws/frame_generator_unittest.cc

 // Copyright 2016 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 "services/ui/ws/frame_generator.h"
 
 #include <memory>
 
 #include "base/test/test_message_loop.h"
 #include "cc/quads/render_pass.h"
@@ skipping 13 matching lines @@
 namespace {
 
 // Typical id for the display root ServerWindow.
 constexpr WindowId kRootDisplayId(0, 2);
 
 // Makes the window visible and creates the default surface for it.
 void InitWindow(ServerWindow* window) {
   window->SetVisible(true);
   ServerWindowCompositorFrameSinkManager* compositor_frame_sink_manager =
       window->GetOrCreateCompositorFrameSinkManager();
-  compositor_frame_sink_manager->CreateCompositorFrameSink(
+  compositor_frame_sink_manager->SetLatestSurfaceInfo(
       mojom::CompositorFrameSinkType::DEFAULT,
-      mojo::InterfaceRequest<cc::mojom::MojoCompositorFrameSink>(),
-      cc::mojom::MojoCompositorFrameSinkClientPtr());
+      cc::SurfaceId(
+          cc::FrameSinkId(
+              WindowIdToTransportId(window->id()),
+              static_cast<uint32_t>(mojom::CompositorFrameSinkType::DEFAULT)),
+          cc::LocalFrameId(1u, 1u)),
+      gfx::Size(100, 100));
 }
 
 }  // namespace
 
 class FrameGeneratorTest : public testing::Test {
  public:
   FrameGeneratorTest()
       : display_compositor_(new DisplayCompositor(nullptr)),
         root_window_(base::MakeUnique<ServerWindow>(&window_delegate_,
                                                     kRootDisplayId)) {}
@@ skipping 19 matching lines @@
   TestServerWindowDelegate window_delegate_;
   std::unique_ptr<ServerWindow> root_window_;
 
   // Needed so that Mojo classes can be initialized for ServerWindow use.
   base::TestMessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameGeneratorTest);
 };
 
 void FrameGeneratorTest::DrawWindowTree(cc::RenderPass* pass) {
-  frame_generator_->DrawWindowTree(pass,
-                                   frame_generator_delegate_->GetRootWindow(),
-                                   gfx::Vector2d(), 1.0f, nullptr);
+  frame_generator_->DrawWindowTree(
+      pass, frame_generator_delegate_->GetRootWindow(), gfx::Vector2d(), 1.0f);
 }
 
 void FrameGeneratorTest::SetUp() {
   testing::Test::SetUp();
   frame_generator_delegate_ = base::MakeUnique<TestFrameGeneratorDelegate>(
       base::MakeUnique<ServerWindow>(&window_delegate_, WindowId()));
   PlatformDisplayInitParams init_params;
   frame_generator_ = base::MakeUnique<FrameGenerator>(
       frame_generator_delegate_.get(), root_window_.get(), display_compositor_);
   InitWindow(root_window());
@@ skipping 23 matching lines @@
   // Both child and root have a DEFAULT Surface and no underlay Surfaces, so
   // there should be two SharedQuadStates in the list.
   EXPECT_EQ(2u, quad_state_list->size());
   cc::SharedQuadState* root_sqs = quad_state_list->back();
   cc::SharedQuadState* child_sqs = quad_state_list->front();
   EXPECT_EQ(root_opacity, root_sqs->opacity);
   // Child's SharedQuadState contains the effective opacity of the child layer,
   // which should be a product of the child and the parent opacity.
   EXPECT_EQ(child_opacity * root_opacity, child_sqs->opacity);
 
-  // Create the UNDERLAY Surface for the child window, and confirm that this
-  // creates an extra SharedQuadState in the CompositorFrame.
-  child_window.GetOrCreateCompositorFrameSinkManager()
-      ->CreateCompositorFrameSink(
-          mojom::CompositorFrameSinkType::UNDERLAY,
-          cc::mojom::MojoCompositorFrameSinkRequest(),
-          cc::mojom::MojoCompositorFrameSinkClientPtr());
+  // Pretend to create the UNDERLAY Surface for the child window, and confirm
+  // that this creates an extra SharedQuadState in the CompositorFrame.
+  child_window.GetOrCreateCompositorFrameSinkManager()->SetLatestSurfaceInfo(
+      mojom::CompositorFrameSinkType::UNDERLAY,
+      cc::SurfaceId(
+          cc::FrameSinkId(
+              WindowIdToTransportId(child_window.id()),
+              static_cast<uint32_t>(mojom::CompositorFrameSinkType::UNDERLAY)),
+          cc::LocalFrameId(1u, 1u)),
+      gfx::Size(100, 100));
 
   render_pass = cc::RenderPass::Create();
   DrawWindowTree(render_pass.get());
   quad_state_list = &render_pass->shared_quad_state_list;
   EXPECT_EQ(3u, quad_state_list->size());
   auto it = quad_state_list->begin();
   EXPECT_EQ(child_opacity * root_opacity, (*it)->opacity);
   EXPECT_EQ(child_opacity * root_opacity, (*++it)->opacity);
   EXPECT_EQ(root_opacity, (*++it)->opacity);
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui