Fork cc::OutputSurface into cc::CompositorFrameSink.

content/browser/frame_host/render_widget_host_view_child_frame.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/frame_host/render_widget_host_view_child_frame.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 25 matching lines @@
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/size_f.h"
 
 namespace content {
 
 RenderWidgetHostViewChildFrame::RenderWidgetHostViewChildFrame(
     RenderWidgetHost* widget_host)
     : host_(RenderWidgetHostImpl::From(widget_host)),
       next_surface_sequence_(1u),
-      last_output_surface_id_(0),
+      last_compositor_frame_sink_id_(0),
       current_surface_scale_factor_(1.f),
       ack_pending_count_(0),
       frame_connector_(nullptr),
       begin_frame_source_(nullptr),
       parent_surface_client_id_(0),
       weak_factory_(this) {
   id_allocator_.reset(new cc::SurfaceIdAllocator(AllocateSurfaceClientId()));
   GetSurfaceManager()->RegisterSurfaceClientId(id_allocator_->client_id());
   RegisterSurfaceNamespaceId();
 
@@ skipping 276 matching lines @@
   // always forwarded and handled according to current scroll state in the
   // RenderWidgetHostInputEventRouter.
   if (!frame_connector_)
     return;
   if ((event.type == blink::WebInputEvent::GestureScrollUpdate &&
        not_consumed) ||
       event.type == blink::WebInputEvent::GestureScrollEnd)
     frame_connector_->BubbleScrollEvent(event);
 }
 
-void RenderWidgetHostViewChildFrame::SurfaceDrawn(uint32_t output_surface_id) {
+void RenderWidgetHostViewChildFrame::SurfaceDrawn(
+    uint32_t compositor_frame_sink_id) {
   DCHECK_GT(ack_pending_count_, 0U);
   if (host_) {
     host_->Send(new ViewMsg_ReclaimCompositorResources(
-        host_->GetRoutingID(), output_surface_id, true /* is_swap_ack */,
+        host_->GetRoutingID(), compositor_frame_sink_id, true /* is_swap_ack */,
         surface_returned_resources_));
     surface_returned_resources_.clear();
   }
   ack_pending_count_--;
 }
 
 void RenderWidgetHostViewChildFrame::OnSwapCompositorFrame(
-    uint32_t output_surface_id,
+    uint32_t compositor_frame_sink_id,
     cc::CompositorFrame frame) {
   TRACE_EVENT0("content",
                "RenderWidgetHostViewChildFrame::OnSwapCompositorFrame");
 
   last_scroll_offset_ = frame.metadata.root_scroll_offset;
 
   if (!frame_connector_)
     return;
 
   cc::RenderPass* root_pass =
       frame.delegated_frame_data->render_pass_list.back().get();
 
   gfx::Size frame_size = root_pass->output_rect.size();
   float scale_factor = frame.metadata.device_scale_factor;
 
   // Check whether we need to recreate the cc::Surface, which means the child
   // frame renderer has changed its output surface, or size, or scale factor.
-  if (output_surface_id != last_output_surface_id_ && surface_factory_) {
+  if (compositor_frame_sink_id != last_compositor_frame_sink_id_ &&
+      surface_factory_) {
     surface_factory_->Destroy(surface_id_);
     surface_factory_.reset();
   }
-  if (output_surface_id != last_output_surface_id_ ||
+  if (compositor_frame_sink_id != last_compositor_frame_sink_id_ ||
       frame_size != current_surface_size_ ||
       scale_factor != current_surface_scale_factor_) {
     ClearCompositorSurfaceIfNecessary();
-    last_output_surface_id_ = output_surface_id;
+    last_compositor_frame_sink_id_ = compositor_frame_sink_id;
     current_surface_size_ = frame_size;
     current_surface_scale_factor_ = scale_factor;
   }
 
   if (!surface_factory_) {
     cc::SurfaceManager* manager = GetSurfaceManager();
     surface_factory_ = base::MakeUnique<cc::SurfaceFactory>(manager, this);
   }
 
   if (surface_id_.is_null()) {
     surface_id_ = id_allocator_->GenerateId();
     surface_factory_->Create(surface_id_);
 
     cc::SurfaceSequence sequence = cc::SurfaceSequence(
         id_allocator_->client_id(), next_surface_sequence_++);
     // The renderer process will satisfy this dependency when it creates a
     // SurfaceLayer.
     cc::SurfaceManager* manager = GetSurfaceManager();
     manager->GetSurfaceForId(surface_id_)->AddDestructionDependency(sequence);
     frame_connector_->SetChildFrameSurface(surface_id_, frame_size,
                                            scale_factor, sequence);
   }
 
   cc::SurfaceFactory::DrawCallback ack_callback =
       base::Bind(&RenderWidgetHostViewChildFrame::SurfaceDrawn, AsWeakPtr(),
-                 output_surface_id);
+                 compositor_frame_sink_id);
   ack_pending_count_++;
   // If this value grows very large, something is going wrong.
   DCHECK_LT(ack_pending_count_, 1000U);
   surface_factory_->SubmitCompositorFrame(surface_id_, std::move(frame),
                                           ack_callback);
 
   ProcessFrameSwappedCallbacks();
 }
 
 void RenderWidgetHostViewChildFrame::ProcessFrameSwappedCallbacks() {
@@ skipping 198 matching lines @@
 }
 
 // cc::SurfaceFactoryClient implementation.
 void RenderWidgetHostViewChildFrame::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
   if (resources.empty())
     return;
 
   if (!ack_pending_count_ && host_) {
     host_->Send(new ViewMsg_ReclaimCompositorResources(
-        host_->GetRoutingID(), last_output_surface_id_, false /* is_swap_ack */,
-        resources));
+        host_->GetRoutingID(), last_compositor_frame_sink_id_,
+        false /* is_swap_ack */, resources));
     return;
   }
 
   std::copy(resources.begin(), resources.end(),
             std::back_inserter(surface_returned_resources_));
 }
 
 void RenderWidgetHostViewChildFrame::SetBeginFrameSource(
     cc::BeginFrameSource* source) {
   bool needs_begin_frames = host_->needs_begin_frames();
@@ skipping 71 matching lines @@
 
 bool RenderWidgetHostViewChildFrame::IsChildFrameForTesting() const {
   return true;
 }
 
 cc::SurfaceId RenderWidgetHostViewChildFrame::SurfaceIdForTesting() const {
   return surface_id_;
 };
 
 }  // namespace content