DelegatedFrameHost should use CompositorFrameSinkSupport

content/browser/renderer_host/delegated_frame_host.cc

 // Copyright 2014 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/delegated_frame_host.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/default_tick_clock.h"
 #include "cc/base/switches.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/resources/texture_mailbox.h"
+#include "cc/surfaces/compositor_frame_sink_support.h"
 #include "cc/surfaces/local_surface_id_allocator.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_hittest.h"
 #include "cc/surfaces/surface_manager.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/compositor/surface_utils.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/renderer_host/render_widget_host_view_frame_subscriber.h"
 #include "content/browser/renderer_host/resize_lock.h"
@@ skipping 11 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost
 
 DelegatedFrameHost::DelegatedFrameHost(const cc::FrameSinkId& frame_sink_id,
                                        DelegatedFrameHostClient* client)
     : frame_sink_id_(frame_sink_id),
       client_(client),
       compositor_(nullptr),
       tick_clock_(new base::DefaultTickClock()),
       last_compositor_frame_sink_id_(0),
-      pending_delegated_ack_count_(0),
       skipped_frames_(false),
       background_color_(SK_ColorRED),
       current_scale_factor_(1.f),
       can_lock_compositor_(YES_CAN_LOCK),
       delegated_frame_evictor_(new DelegatedFrameEvictor(this)) {
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   factory->GetContextFactory()->AddObserver(this);
   id_allocator_.reset(new cc::LocalSurfaceIdAllocator());
   factory->GetContextFactoryPrivate()->GetSurfaceManager()->RegisterFrameSinkId(
       frame_sink_id_);
-  factory->GetContextFactoryPrivate()
-      ->GetSurfaceManager()
-      ->RegisterSurfaceFactoryClient(frame_sink_id_, this);
-  surface_factory_ = base::MakeUnique<cc::SurfaceFactory>(
-      frame_sink_id_, factory->GetContextFactoryPrivate()->GetSurfaceManager(),
-      this);
+  CreateCompositorFrameSinkSupport();
+  begin_frame_source_ = base::MakeUnique<cc::ExternalBeginFrameSource>(this);
+  client_->SetBeginFrameSource(begin_frame_source_.get());
 }
 
 void DelegatedFrameHost::WasShown(const ui::LatencyInfo& latency_info) {
   delegated_frame_evictor_->SetVisible(true);
 
   if (!local_surface_id_.is_valid() && !released_front_lock_.get()) {
     if (compositor_)
       released_front_lock_ = compositor_->GetCompositorLock();
   }
 
@@ skipping 293 matching lines @@
         subscriber_texture->target()));
   }
 
   if (local_surface_id_.is_valid()) {
     // To avoid unnecessary composites, go directly to the Surface rather than
     // through RequestCopyOfOutput (which goes through the browser
     // compositor).
     if (!request_copy_of_output_callback_for_testing_.is_null())
       request_copy_of_output_callback_for_testing_.Run(std::move(request));
     else
-      surface_factory_->RequestCopyOfSurface(std::move(request));
+      support_->RequestCopyOfSurface(std::move(request));
   } else {
     request->set_area(gfx::Rect(current_frame_size_in_dip_));
     RequestCopyOfOutput(std::move(request));
   }
 }
 
 void DelegatedFrameHost::SwapDelegatedFrame(uint32_t compositor_frame_sink_id,
                                             cc::CompositorFrame frame) {
 #if defined(OS_CHROMEOS)
   DCHECK(!resize_lock_ || !client_->IsAutoResizeEnabled());
@@ skipping 39 matching lines @@
 
   if (compositor_frame_sink_id != last_compositor_frame_sink_id_) {
     // Resource ids are scoped by the output surface.
     // If the originating output surface doesn't match the last one, it
     // indicates the renderer's output surface may have been recreated, in which
     // case we should recreate the DelegatedRendererLayer, to avoid matching
     // resources from the old one with resources from the new one which would
     // have the same id. Changing the layer to showing painted content destroys
     // the DelegatedRendererLayer.
     EvictDelegatedFrame();
-    surface_factory_->Reset();
-    surface_returned_resources_.clear();
+    ResetCompositorFrameSinkSupport();
+    CreateCompositorFrameSinkSupport();
     last_compositor_frame_sink_id_ = compositor_frame_sink_id;
   }
-  pending_delegated_ack_count_++;
 
   background_color_ = frame.metadata.root_background_color;
 
   if (frame_size.IsEmpty()) {
     DCHECK(frame.resource_list.empty());
     EvictDelegatedFrame();
   } else {
     ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
     cc::SurfaceManager* manager =
         factory->GetContextFactoryPrivate()->GetSurfaceManager();
@@ skipping 10 matching lines @@
                                         frame.metadata.latency_info.begin(),
                                         frame.metadata.latency_info.end());
       frame.metadata.latency_info.clear();
     } else {
       frame.metadata.latency_info.insert(frame.metadata.latency_info.end(),
                                          skipped_latency_info_list_.begin(),
                                          skipped_latency_info_list_.end());
       skipped_latency_info_list_.clear();
     }
 
-    auto ack_callback = base::Bind(&DelegatedFrameHost::SurfaceDrawn,
-                                   AsWeakPtr(), compositor_frame_sink_id);
-    surface_factory_->SubmitCompositorFrame(local_surface_id_, std::move(frame),
-                                            ack_callback);
+    support_->SubmitCompositorFrame(local_surface_id_, std::move(frame));
+
     if (allocated_new_local_surface_id) {
       // manager must outlive compositors using it.
       cc::SurfaceId surface_id(frame_sink_id_, local_surface_id_);
       cc::SurfaceInfo surface_info(surface_id, frame_device_scale_factor,
                                    frame_size);
       client_->DelegatedFrameHostGetLayer()->SetShowSurface(
           surface_info, manager->reference_factory());
       current_surface_size_ = frame_size;
       current_scale_factor_ = frame_device_scale_factor;
     }
@@ skipping 17 matching lines @@
         client_->DelegatedFrameHostIsVisible());
   }
   // Note: the frame may have been evicted immediately.
 }
 
 void DelegatedFrameHost::ClearDelegatedFrame() {
   if (local_surface_id_.is_valid())
     EvictDelegatedFrame();
 }
 
-void DelegatedFrameHost::SendReclaimCompositorResources(
-    uint32_t compositor_frame_sink_id,
-    bool is_swap_ack) {
+void DelegatedFrameHost::DidReceiveCompositorFrameAck() {
   client_->DelegatedFrameHostSendReclaimCompositorResources(
-      compositor_frame_sink_id, is_swap_ack, surface_returned_resources_);
-  surface_returned_resources_.clear();
-  if (is_swap_ack) {
-    DCHECK_GT(pending_delegated_ack_count_, 0);
-    pending_delegated_ack_count_--;
-  }
+      last_compositor_frame_sink_id_, true /* is_swap_ack */,
+      cc::ReturnedResourceArray());
 }
 
-void DelegatedFrameHost::SurfaceDrawn(uint32_t compositor_frame_sink_id) {
-  SendReclaimCompositorResources(compositor_frame_sink_id,
-                                 true /* is_swap_ack */);
-}
-
-void DelegatedFrameHost::ReturnResources(
+void DelegatedFrameHost::ReclaimResources(
     const cc::ReturnedResourceArray& resources) {
-  if (resources.empty())
-    return;
-  std::copy(resources.begin(), resources.end(),
-            std::back_inserter(surface_returned_resources_));
-  if (!pending_delegated_ack_count_) {
-    SendReclaimCompositorResources(last_compositor_frame_sink_id_,
-                                   false /* is_swap_ack */);
-  }
+  client_->DelegatedFrameHostSendReclaimCompositorResources(
+      last_compositor_frame_sink_id_, false /* is_swap_ack */, resources);
 }
 
 void DelegatedFrameHost::WillDrawSurface(const cc::LocalSurfaceId& id,
                                          const gfx::Rect& damage_rect) {
   // Frame subscribers are only interested in changes to the target surface, so
   // do not attempt capture if |damage_rect| is empty.  This prevents the draws
   // of parent surfaces from triggering extra frame captures, which can affect
   // smoothness.
   if (id != local_surface_id_ || damage_rect.IsEmpty())
     return;
   AttemptFrameSubscriberCapture(damage_rect);
 }
 
-void DelegatedFrameHost::SetBeginFrameSource(
-    cc::BeginFrameSource* begin_frame_source) {
-  client_->SetBeginFrameSource(begin_frame_source);
+void DelegatedFrameHost::OnBeginFrame(const cc::BeginFrameArgs& args) {
+  begin_frame_source_->OnBeginFrame(args);
 }
 
 void DelegatedFrameHost::EvictDelegatedFrame() {
   client_->DelegatedFrameHostGetLayer()->SetShowSolidColorContent();
   if (local_surface_id_.is_valid()) {
-    surface_factory_->EvictSurface();
+    support_->EvictFrame();
     local_surface_id_ = cc::LocalSurfaceId();
   }
   delegated_frame_evictor_->DiscardedFrame();
   UpdateGutters();
 }
 
 // static
 void DelegatedFrameHost::ReturnSubscriberTexture(
     base::WeakPtr<DelegatedFrameHost> dfh,
     scoped_refptr<OwnedMailbox> subscriber_texture,
@@ skipping 213 matching lines @@
   yuv_readback_pipeline_.reset();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, private:
 
 DelegatedFrameHost::~DelegatedFrameHost() {
   DCHECK(!compositor_);
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   factory->GetContextFactory()->RemoveObserver(this);
-  surface_factory_->EvictSurface();
-  factory->GetContextFactoryPrivate()
-      ->GetSurfaceManager()
-      ->UnregisterSurfaceFactoryClient(frame_sink_id_);
+
+  begin_frame_source_.reset();
+  ResetCompositorFrameSinkSupport();
+
   factory->GetContextFactoryPrivate()
       ->GetSurfaceManager()
       ->InvalidateFrameSinkId(frame_sink_id_);
 
   DCHECK(!vsync_manager_.get());
 }
 
 void DelegatedFrameHost::SetCompositor(ui::Compositor* compositor) {
   DCHECK(!compositor_);
   if (!compositor)
@@ skipping 38 matching lines @@
     client_->DelegatedFrameHostGetLayer()->RequestCopyOfOutput(
         std::move(request));
   }
 }
 
 void DelegatedFrameHost::UnlockResources() {
   DCHECK(local_surface_id_.is_valid());
   delegated_frame_evictor_->UnlockFrame();
 }
 
+void DelegatedFrameHost::OnNeedsBeginFrames(bool needs_begin_frames) {
+  needs_begin_frame_ = needs_begin_frames;
+  support_->SetNeedsBeginFrame(needs_begin_frames);
+}
+
+void DelegatedFrameHost::OnDidFinishFrame(const cc::BeginFrameAck& ack) {}
+
+void DelegatedFrameHost::CreateCompositorFrameSinkSupport() {
+  DCHECK(!support_);
+  ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
+  support_ = base::MakeUnique<cc::CompositorFrameSinkSupport>(
+      this, factory->GetContextFactoryPrivate()->GetSurfaceManager(),
+      frame_sink_id_, false /* is_root */,
+      false /* handles_frame_sink_id_invalidation */,
+      true /* needs_sync_points */);
+  if (compositor_)
+    compositor_->AddFrameSink(frame_sink_id_);
+  if (needs_begin_frame_)
+    support_->SetNeedsBeginFrame(true);
+}
+
+void DelegatedFrameHost::ResetCompositorFrameSinkSupport() {
+  if (!support_)
+    return;
+  if (compositor_)
+    compositor_->RemoveFrameSink(frame_sink_id_);
+  support_.reset();
+}
+
 }  // namespace content