Fork cc::OutputSurface into cc::CompositorFrameSink.

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>
@@ skipping 49 matching lines @@
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost
 
 DelegatedFrameHost::DelegatedFrameHost(DelegatedFrameHostClient* client)
     : client_(client),
       compositor_(nullptr),
       tick_clock_(new base::DefaultTickClock()),
-      last_output_surface_id_(0),
+      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::SurfaceIdAllocator(
       factory->GetContextFactory()->AllocateSurfaceClientId()));
@@ skipping 307 matching lines @@
     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(surface_id_, std::move(request));
   } else {
     request->set_area(gfx::Rect(current_frame_size_in_dip_));
     RequestCopyOfOutput(std::move(request));
   }
 }
 
-void DelegatedFrameHost::SwapDelegatedFrame(uint32_t output_surface_id,
+void DelegatedFrameHost::SwapDelegatedFrame(uint32_t compositor_frame_sink_id,
                                             cc::CompositorFrame frame) {
   DCHECK(frame.delegated_frame_data.get());
 #if defined(OS_CHROMEOS)
   DCHECK(!resize_lock_ || !client_->IsAutoResizeEnabled());
 #endif
   cc::DelegatedFrameData* frame_data = frame.delegated_frame_data.get();
   float frame_device_scale_factor = frame.metadata.device_scale_factor;
 
   DCHECK(!frame_data->render_pass_list.empty());
 
@@ skipping 11 matching lines @@
   if (ShouldSkipFrame(frame_size_in_dip)) {
     cc::ReturnedResourceArray resources;
     cc::TransferableResource::ReturnResources(frame_data->resource_list,
                                               &resources);
 
     skipped_latency_info_list_.insert(skipped_latency_info_list_.end(),
                                       frame.metadata.latency_info.begin(),
                                       frame.metadata.latency_info.end());
 
     client_->DelegatedFrameHostSendReclaimCompositorResources(
-        output_surface_id, true /* is_swap_ack*/, resources);
+        compositor_frame_sink_id, true /* is_swap_ack*/, resources);
     skipped_frames_ = true;
     return;
   }
 
   if (skipped_frames_) {
     skipped_frames_ = false;
     damage_rect = gfx::Rect(frame_size);
     damage_rect_in_dip = gfx::Rect(frame_size_in_dip);
 
     // Give the same damage rect to the compositor.
     cc::RenderPass* root_pass = frame_data->render_pass_list.back().get();
     root_pass->damage_rect = damage_rect;
   }
 
-  if (output_surface_id != last_output_surface_id_) {
+  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();
     if (!surface_returned_resources_.empty()) {
-      SendReclaimCompositorResources(last_output_surface_id_,
+      SendReclaimCompositorResources(last_compositor_frame_sink_id_,
                                      false /* is_swap_ack */);
     }
-    last_output_surface_id_ = output_surface_id;
+    last_compositor_frame_sink_id_ = compositor_frame_sink_id;
   }
   bool skip_frame = false;
   pending_delegated_ack_count_++;
 
   background_color_ = frame.metadata.root_background_color;
 
   if (frame_size.IsEmpty()) {
     DCHECK(frame_data->resource_list.empty());
     EvictDelegatedFrame();
   } else {
@@ skipping 27 matching lines @@
     } 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();
     }
 
     cc::SurfaceFactory::DrawCallback ack_callback;
     if (compositor_ && !skip_frame) {
       ack_callback = base::Bind(&DelegatedFrameHost::SurfaceDrawn, AsWeakPtr(),
-                                output_surface_id);
+                                compositor_frame_sink_id);
     }
     surface_factory_->SubmitCompositorFrame(surface_id_, std::move(frame),
                                             ack_callback);
   }
   released_front_lock_ = NULL;
   current_frame_size_in_dip_ = frame_size_in_dip;
   CheckResizeLock();
 
   UpdateGutters();
 
   if (!damage_rect_in_dip.IsEmpty()) {
     client_->DelegatedFrameHostGetLayer()->OnDelegatedFrameDamage(
         damage_rect_in_dip);
   }
 
   // Note that |compositor_| may be reset by SetShowSurface or
   // SetShowDelegatedContent above.
   if (!compositor_ || skip_frame) {
-    SendReclaimCompositorResources(output_surface_id, true /* is_swap_ack */);
+    SendReclaimCompositorResources(compositor_frame_sink_id,
+                                   true /* is_swap_ack */);
   } else {
     can_lock_compositor_ = NO_PENDING_COMMIT;
   }
   if (!surface_id_.is_null()) {
     delegated_frame_evictor_->SwappedFrame(
         client_->DelegatedFrameHostIsVisible());
   }
   // Note: the frame may have been evicted immediately.
 }
 
 void DelegatedFrameHost::ClearDelegatedFrame() {
   if (!surface_id_.is_null())
     EvictDelegatedFrame();
 }
 
 void DelegatedFrameHost::SendReclaimCompositorResources(
-    uint32_t output_surface_id,
+    uint32_t compositor_frame_sink_id,
     bool is_swap_ack) {
   client_->DelegatedFrameHostSendReclaimCompositorResources(
-      output_surface_id, is_swap_ack, surface_returned_resources_);
+      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_--;
   }
 }
 
-void DelegatedFrameHost::SurfaceDrawn(uint32_t output_surface_id) {
-  SendReclaimCompositorResources(output_surface_id, true /* is_swap_ack */);
+void DelegatedFrameHost::SurfaceDrawn(uint32_t compositor_frame_sink_id) {
+  SendReclaimCompositorResources(compositor_frame_sink_id,
+                                 true /* is_swap_ack */);
 }
 
 void DelegatedFrameHost::ReturnResources(
     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_output_surface_id_,
+    SendReclaimCompositorResources(last_compositor_frame_sink_id_,
                                    false /* is_swap_ack */);
   }
 }
 
 void DelegatedFrameHost::WillDrawSurface(const cc::SurfaceId& 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.
@@ skipping 323 matching lines @@
     cc::SurfaceManager* manager = factory->GetSurfaceManager();
     new_layer->SetShowSurface(
         surface_id_, base::Bind(&SatisfyCallback, base::Unretained(manager)),
         base::Bind(&RequireCallback, base::Unretained(manager)),
         current_surface_size_, current_scale_factor_,
         current_frame_size_in_dip_);
   }
 }
 
 }  // namespace content