Remove uses of external begin frame sources

content/renderer/gpu/compositor_output_surface.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/renderer/gpu/compositor_output_surface.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/location.h"
@@ skipping 11 matching lines @@
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/ipc/client/command_buffer_proxy_impl.h"
 #include "ipc/ipc_sync_channel.h"
 
 namespace content {
 
 CompositorOutputSurface::CompositorOutputSurface(
     int32_t routing_id,
     uint32_t output_surface_id,
+    std::unique_ptr<cc::BeginFrameSource> begin_frame_source,
     scoped_refptr<cc::ContextProvider> context_provider,
     scoped_refptr<cc::ContextProvider> worker_context_provider,
     scoped_refptr<FrameSwapMessageQueue> swap_frame_message_queue)
     : OutputSurface(std::move(context_provider),
                     std::move(worker_context_provider),
                     nullptr),
       output_surface_id_(output_surface_id),
       output_surface_filter_(
           RenderThreadImpl::current()->compositor_message_filter()),
       message_sender_(RenderThreadImpl::current()->sync_message_filter()),
       frame_swap_message_queue_(swap_frame_message_queue),
+      begin_frame_source_(std::move(begin_frame_source)),
       routing_id_(routing_id) {
   DCHECK(output_surface_filter_);
   DCHECK(frame_swap_message_queue_);
   DCHECK(message_sender_);
+  DCHECK(begin_frame_source_);
   capabilities_.delegated_rendering = true;
 }
 
 CompositorOutputSurface::CompositorOutputSurface(
     int32_t routing_id,
     uint32_t output_surface_id,
+    std::unique_ptr<cc::BeginFrameSource> begin_frame_source,
     scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider,
     scoped_refptr<FrameSwapMessageQueue> swap_frame_message_queue)
     : OutputSurface(std::move(vulkan_context_provider)),
       output_surface_id_(output_surface_id),
       output_surface_filter_(
           RenderThreadImpl::current()->compositor_message_filter()),
       message_sender_(RenderThreadImpl::current()->sync_message_filter()),
       frame_swap_message_queue_(swap_frame_message_queue),
+      begin_frame_source_(std::move(begin_frame_source)),
       routing_id_(routing_id) {
   DCHECK(output_surface_filter_);
   DCHECK(frame_swap_message_queue_);
   DCHECK(message_sender_);
+  DCHECK(begin_frame_source_);
   capabilities_.delegated_rendering = true;
 }
 
 CompositorOutputSurface::~CompositorOutputSurface() = default;
 
 bool CompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* client) {
   if (!cc::OutputSurface::BindToClient(client))
     return false;
 
+  DCHECK(begin_frame_source_);
+  client_->SetBeginFrameSource(begin_frame_source_.get());
+
   output_surface_proxy_ = new CompositorOutputSurfaceProxy(this);
   output_surface_filter_handler_ =
       base::Bind(&CompositorOutputSurfaceProxy::OnMessageReceived,
                  output_surface_proxy_);
   output_surface_filter_->AddHandlerOnCompositorThread(
                               routing_id_,
                               output_surface_filter_handler_);
 
   if (!context_provider()) {
     // Without a GPU context, the memory policy otherwise wouldn't be set.
     client->SetMemoryPolicy(cc::ManagedMemoryPolicy(
         128 * 1024 * 1024,
         gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
         base::SharedMemory::GetHandleLimit() / 3));
   }
 
   return true;
 }
 
 void CompositorOutputSurface::DetachFromClient() {
   if (!HasClient())
     return;
+  client_->SetBeginFrameSource(nullptr);
+  // Destroy the begin frame source on the same thread it was bound on.
+  // The OutputSurface itself is destroyed on the main thread.
+  begin_frame_source_ = nullptr;
+
   if (output_surface_proxy_) {
     output_surface_proxy_->ClearOutputSurface();
     output_surface_filter_->RemoveHandlerOnCompositorThread(
         routing_id_, output_surface_filter_handler_);
   }
   cc::OutputSurface::DetachFromClient();
 }
 
 void CompositorOutputSurface::SwapBuffers(cc::CompositorFrame frame) {
   {
@@ skipping 44 matching lines @@
   ReclaimResources(resources);
   if (is_swap_ack)
     client_->DidSwapBuffersComplete();
 }
 
 bool CompositorOutputSurface::Send(IPC::Message* message) {
   return message_sender_->Send(message);
 }
 
 }  // namespace content