Mus+Ash: Towards Unifying CompositorFrameSink terminology

content/browser/compositor/mus_browser_compositor_output_surface.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 "content/browser/compositor/mus_browser_compositor_output_surface.h"
 
 #include <utility>
 
 #include "cc/output/compositor_frame.h"
 #include "cc/output/output_surface_frame.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "components/display_compositor/compositor_overlay_candidate_validator.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/ipc/client/command_buffer_proxy_impl.h"
+#include "services/ui/public/cpp/compositor_frame_sink.h"
 #include "services/ui/public/cpp/window.h"
 #include "services/ui/public/cpp/window_surface.h"
 
 namespace content {
 
 MusBrowserCompositorOutputSurface::MusBrowserCompositorOutputSurface(
     ui::Window* window,
     scoped_refptr<ContextProviderCommandBuffer> context,
     scoped_refptr<ui::CompositorVSyncManager> vsync_manager,
     cc::SyntheticBeginFrameSource* begin_frame_source,
     std::unique_ptr<display_compositor::CompositorOverlayCandidateValidator>
         overlay_candidate_validator)
     : GpuBrowserCompositorOutputSurface(std::move(context),
                                         std::move(vsync_manager),
                                         begin_frame_source,
                                         std::move(overlay_candidate_validator)),
       ui_window_(window) {
-  ui_window_surface_ =
-      ui_window_->RequestSurface(ui::mojom::SurfaceType::DEFAULT);
+  ui_compositor_frame_sink_ = ui_window_->RequestCompositorFrameSink(
+      ui::mojom::SurfaceType::DEFAULT, context);
 }
 
 MusBrowserCompositorOutputSurface::~MusBrowserCompositorOutputSurface() {}
 
 void MusBrowserCompositorOutputSurface::SwapBuffers(
     cc::OutputSurfaceFrame frame) {
   const gfx::Rect bounds(ui_window_->bounds().size());
   cc::CompositorFrame ui_frame;
   ui_frame.metadata.latency_info = std::move(frame.latency_info);
   // Reset latency_info to known empty state after moving contents.
@@ skipping 52 matching lines @@
   const bool secure_output_only = false;
 
   cc::TextureDrawQuad* quad =
       pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
   quad->SetAll(sqs, rect, rect, rect, needs_blending, resource.id, gfx::Size(),
                premultiplied_alpha, uv_top_left, uv_bottom_right,
                background_color, vertex_opacity, y_flipped, nearest_neighbor,
                secure_output_only);
 
   ui_frame.delegated_frame_data->render_pass_list.push_back(std::move(pass));
-  // ui_frame_surface_ will be destroyed by MusBrowserCompositorOutputSurface's
-  // destructor, and the callback of SubmitCompositorFrame() will not be fired
-  // after ui_window_surface_ is destroyed, so it is safe to use
-  // base::Unretained(this) here.
-  ui_window_surface_->SubmitCompositorFrame(
-      std::move(ui_frame),
-      base::Bind(&MusBrowserCompositorOutputSurface::OnGpuSwapBuffersCompleted,
-                 base::Unretained(this), std::vector<ui::LatencyInfo>(),
-                 gfx::SwapResult::SWAP_ACK, nullptr));
+  ui_compositor_frame_sink_->SubmitCompositorFrame(std::move(ui_frame));
   return;
 }
 
 bool MusBrowserCompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* client) {
   if (!GpuBrowserCompositorOutputSurface::BindToClient(client))
     return false;
-  ui_window_surface_->BindToThread();
-  ui_window_surface_->set_client(this);
+  ui_compositor_frame_sink_->BindToClient(this);
   return true;
 }
 
-void MusBrowserCompositorOutputSurface::OnResourcesReturned(
-    ui::WindowSurface* surface,
+void MusBrowserCompositorOutputSurface::SetBeginFrameSource(
+    cc::BeginFrameSource* source) {}
+
+void MusBrowserCompositorOutputSurface::ReclaimResources(
     const cc::ReturnedResourceArray& resources) {
   for (const auto& resource : resources) {
     DCHECK_EQ(1, resource.count);
     const gpu::Mailbox& mailbox = GetMailboxFromResourceId(resource.id);
     GetCommandBufferProxy()->ReturnFrontBuffer(mailbox, resource.sync_token,
                                                resource.lost);
     FreeResourceId(resource.id);
   }
 }
 
+void MusBrowserCompositorOutputSurface::SetTreeActivationCallback(
+    const base::Closure& callback) {}
+
+void MusBrowserCompositorOutputSurface::DidReceiveCompositorFrameAck() {
+  OnGpuSwapBuffersCompleted(std::vector<ui::LatencyInfo>(),
+                            gfx::SwapResult::SWAP_ACK, nullptr);
+}
+
+void MusBrowserCompositorOutputSurface::DidLoseCompositorFrameSink() {}
+
+void MusBrowserCompositorOutputSurface::OnDraw(
+    const gfx::Transform& transform,
+    const gfx::Rect& viewport,
+    bool resourceless_software_draw) {}
+
+void MusBrowserCompositorOutputSurface::SetMemoryPolicy(
+    const cc::ManagedMemoryPolicy& policy) {}
+
+void MusBrowserCompositorOutputSurface::SetExternalTilePriorityConstraints(
+    const gfx::Rect& viewport_rect,
+    const gfx::Transform& transform) {}
+
 uint32_t MusBrowserCompositorOutputSurface::AllocateResourceId() {
   if (!free_resource_ids_.empty()) {
     uint32_t id = free_resource_ids_.back();
     free_resource_ids_.pop_back();
     return id;
   }
   // If there is no free resource id, we generate a new mailbox in the mailbox
   // vector, and the index of the new mailbox is the new allocated resource id.
   uint32_t id = mailboxes_.size();
   mailboxes_.push_back(gpu::Mailbox::Generate());
   return id;
 }
 
 void MusBrowserCompositorOutputSurface::FreeResourceId(uint32_t id) {
   DCHECK_LT(id, mailboxes_.size());
   DCHECK(std::find(free_resource_ids_.begin(), free_resource_ids_.end(), id) ==
          free_resource_ids_.end());
   free_resource_ids_.push_back(id);
 }
 
 const gpu::Mailbox& MusBrowserCompositorOutputSurface::GetMailboxFromResourceId(
     uint32_t id) {
   DCHECK_LT(id, mailboxes_.size());
   DCHECK(std::find(free_resource_ids_.begin(), free_resource_ids_.end(), id) ==
          free_resource_ids_.end());
   return mailboxes_[id];
 }
 
 }  // namespace content