Mus+Ash: Unify CompositorFrameSinks

services/ui/ws/frame_generator.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 "base/containers/adapters.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
+#include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_id.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
-#include "services/ui/surfaces/display_compositor_frame_sink.h"
+#include "services/ui/surfaces/display_compositor.h"
+#include "services/ui/surfaces/surfaces_context_provider.h"
 #include "services/ui/ws/frame_generator_delegate.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/server_window_compositor_frame_sink.h"
 #include "services/ui/ws/server_window_compositor_frame_sink_manager.h"
 
 namespace ui {
 
 namespace ws {
 
 FrameGenerator::FrameGenerator(
     FrameGeneratorDelegate* delegate,
     ServerWindow* root_window,
     scoped_refptr<DisplayCompositor> display_compositor)
     : delegate_(delegate),
       display_compositor_(display_compositor),
       frame_sink_id_(
           WindowIdToTransportId(root_window->id()),
           static_cast<uint32_t>(mojom::CompositorFrameSinkType::DEFAULT)),
+      root_window_(root_window),
       draw_timer_(false, false),
+      binding_(this),
       weak_factory_(this) {
   DCHECK(delegate_);
   surface_sequence_generator_.set_frame_sink_id(frame_sink_id_);
 }
 
 FrameGenerator::~FrameGenerator() {
   ReleaseAllSurfaceReferences();
   // Invalidate WeakPtrs now to avoid callbacks back into the
   // FrameGenerator during destruction of |compositor_frame_sink_|.
   weak_factory_.InvalidateWeakPtrs();
   compositor_frame_sink_.reset();
 }
 
 void FrameGenerator::OnGpuChannelEstablished(
     scoped_refptr<gpu::GpuChannelHost> channel) {
   if (widget_ != gfx::kNullAcceleratedWidget) {
-    compositor_frame_sink_ = base::MakeUnique<DisplayCompositorFrameSink>(
-        frame_sink_id_, base::ThreadTaskRunnerHandle::Get(), widget_,
-        std::move(channel), display_compositor_);
+    cc::mojom::MojoCompositorFrameSinkRequest request =
+        mojo::GetProxy(&compositor_frame_sink_);
+    // TODO(fsamuel): FrameGenerator should not know about
+    // SurfacesContextProvider. In fact, FrameGenerator should not know
+    // about GpuChannelHost.
+    root_window_->CreateCompositorFrameSink(
+        mojom::CompositorFrameSinkType::DEFAULT, widget_,
+        channel->gpu_memory_buffer_manager(),
+        new SurfacesContextProvider(widget_, channel), std::move(request),
+        binding_.CreateInterfacePtrAndBind());
   } else {
     gpu_channel_ = std::move(channel);
   }
 }
 
 void FrameGenerator::RequestRedraw(const gfx::Rect& redraw_region) {
   dirty_rect_.Union(redraw_region);
   WantToDraw();
 }
 
 void FrameGenerator::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget) {
   widget_ = widget;
   if (gpu_channel_ && widget != gfx::kNullAcceleratedWidget) {
-    compositor_frame_sink_ = base::MakeUnique<DisplayCompositorFrameSink>(
-        frame_sink_id_, base::ThreadTaskRunnerHandle::Get(), widget_,
-        std::move(gpu_channel_), display_compositor_);
+    cc::mojom::MojoCompositorFrameSinkRequest request =
+        mojo::GetProxy(&compositor_frame_sink_);
+    root_window_->CreateCompositorFrameSink(
+        mojom::CompositorFrameSinkType::DEFAULT, widget_,
+        gpu_channel_->gpu_memory_buffer_manager(),
+        new SurfacesContextProvider(widget_, std::move(gpu_channel_)),
+        std::move(request), binding_.CreateInterfacePtrAndBind());
   }
 }
 
+void FrameGenerator::DidReceiveCompositorFrameAck() {
+  frame_pending_ = false;
+  if (!dirty_rect_.IsEmpty())
+    WantToDraw();
+}
+
+void FrameGenerator::ReclaimResources(
+    const cc::ReturnedResourceArray& resources) {
+  // Nothing to do here because FrameGenerator CompositorFrames don't reference
+  // any resources.
+}
+
 void FrameGenerator::WantToDraw() {
   if (draw_timer_.IsRunning() || frame_pending_)
     return;
 
   // TODO(rjkroege): Use vblank to kick off Draw.
   draw_timer_.Start(
       FROM_HERE, base::TimeDelta(),
       base::Bind(&FrameGenerator::Draw, weak_factory_.GetWeakPtr()));
 }
 
 void FrameGenerator::Draw() {
   if (!delegate_->GetRootWindow()->visible())
     return;
 
   const gfx::Rect output_rect(delegate_->GetViewportMetrics().pixel_size);
   dirty_rect_.Intersect(output_rect);
   // TODO(fsamuel): We should add a trace for generating a top level frame.
   cc::CompositorFrame frame(GenerateCompositorFrame(output_rect));
   if (compositor_frame_sink_) {
     frame_pending_ = true;
-    compositor_frame_sink_->SubmitCompositorFrame(
-        std::move(frame),
-        base::Bind(&FrameGenerator::DidDraw, weak_factory_.GetWeakPtr()));
+    compositor_frame_sink_->SubmitCompositorFrame(std::move(frame));
   }
   dirty_rect_ = gfx::Rect();
 }
 
-void FrameGenerator::DidDraw() {
-  frame_pending_ = false;
-  if (!dirty_rect_.IsEmpty())
-    WantToDraw();
-}
-
 cc::CompositorFrame FrameGenerator::GenerateCompositorFrame(
     const gfx::Rect& output_rect) {
   const cc::RenderPassId render_pass_id(1, 1);
   std::unique_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
   render_pass->SetNew(render_pass_id, output_rect, dirty_rect_,
                       gfx::Transform());
 
   DrawWindowTree(render_pass.get(), delegate_->GetRootWindow(), gfx::Vector2d(),
                  1.0f);
 
@@ skipping 190 matching lines @@
   cc::SurfaceId underlay_surface_id =
       window->compositor_frame_sink_manager()->GetLatestSurfaceId(
           mojom::CompositorFrameSinkType::UNDERLAY);
   if (!underlay_surface_id.is_null())
     ReleaseFrameSinkReference(underlay_surface_id.frame_sink_id());
 }
 
 }  // namespace ws
 
 }  // namespace ui