Fork cc::OutputSurface into cc::CompositorFrameSink.

cc/trees/layer_tree_host.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 508 matching lines @@
 
 void LayerTreeHost::CommitComplete() {
   source_frame_number_++;
   client_->DidCommit();
   if (did_complete_scale_animation_) {
     client_->DidCompletePageScaleAnimation();
     did_complete_scale_animation_ = false;
   }
 }
 
-void LayerTreeHost::SetOutputSurface(std::unique_ptr<OutputSurface> surface) {
-  TRACE_EVENT0("cc", "LayerTreeHost::SetOutputSurface");
+void LayerTreeHost::SetCompositorFrameSink(
+    std::unique_ptr<CompositorFrameSink> surface) {
+  TRACE_EVENT0("cc", "LayerTreeHost::SetCompositorFrameSink");
   DCHECK(surface);
 
-  DCHECK(!new_output_surface_);
-  new_output_surface_ = std::move(surface);
-  proxy_->SetOutputSurface(new_output_surface_.get());
+  DCHECK(!new_compositor_frame_sink_);
+  new_compositor_frame_sink_ = std::move(surface);
+  proxy_->SetCompositorFrameSink(new_compositor_frame_sink_.get());
 }
 
-std::unique_ptr<OutputSurface> LayerTreeHost::ReleaseOutputSurface() {
+std::unique_ptr<CompositorFrameSink>
+LayerTreeHost::ReleaseCompositorFrameSink() {
   DCHECK(!visible_);
 
-  DidLoseOutputSurface();
-  proxy_->ReleaseOutputSurface();
-  return std::move(current_output_surface_);
+  DidLoseCompositorFrameSink();
+  proxy_->ReleaseCompositorFrameSink();
+  return std::move(current_compositor_frame_sink_);
 }
 
-void LayerTreeHost::RequestNewOutputSurface() {
-  client_->RequestNewOutputSurface();
+void LayerTreeHost::RequestNewCompositorFrameSink() {
+  client_->RequestNewCompositorFrameSink();
 }
 
-void LayerTreeHost::DidInitializeOutputSurface() {
-  DCHECK(new_output_surface_);
-  current_output_surface_ = std::move(new_output_surface_);
-  client_->DidInitializeOutputSurface();
+void LayerTreeHost::DidInitializeCompositorFrameSink() {
+  DCHECK(new_compositor_frame_sink_);
+  current_compositor_frame_sink_ = std::move(new_compositor_frame_sink_);
+  client_->DidInitializeCompositorFrameSink();
 }
 
-void LayerTreeHost::DidFailToInitializeOutputSurface() {
-  DCHECK(new_output_surface_);
+void LayerTreeHost::DidFailToInitializeCompositorFrameSink() {
+  DCHECK(new_compositor_frame_sink_);
   // Note: It is safe to drop all output surface references here as
   // LayerTreeHostImpl will not keep a pointer to either the old or
-  // new output surface after failing to initialize the new one.
-  current_output_surface_ = nullptr;
-  new_output_surface_ = nullptr;
-  client_->DidFailToInitializeOutputSurface();
+  // new CompositorFrameSink after failing to initialize the new one.
+  current_compositor_frame_sink_ = nullptr;
+  new_compositor_frame_sink_ = nullptr;
+  client_->DidFailToInitializeCompositorFrameSink();
 }
 
 std::unique_ptr<LayerTreeHostImpl> LayerTreeHost::CreateLayerTreeHostImpl(
     LayerTreeHostImplClient* client) {
   DCHECK(!IsRemoteServer());
   DCHECK(task_runner_provider_->IsImplThread());
 
   const bool supports_impl_scrolling = task_runner_provider_->HasImplThread();
   std::unique_ptr<AnimationHost> animation_host_impl =
       layer_tree_->animation_host()->CreateImplInstance(
           supports_impl_scrolling);
 
   std::unique_ptr<LayerTreeHostImpl> host_impl = LayerTreeHostImpl::Create(
       settings_, client, task_runner_provider_.get(),
       rendering_stats_instrumentation_.get(), shared_bitmap_manager_,
       gpu_memory_buffer_manager_, task_graph_runner_,
       std::move(animation_host_impl), id_);
   host_impl->SetHasGpuRasterizationTrigger(has_gpu_rasterization_trigger_);
   host_impl->SetContentIsSuitableForGpuRasterization(
       content_is_suitable_for_gpu_rasterization_);
   shared_bitmap_manager_ = NULL;
   gpu_memory_buffer_manager_ = NULL;
   task_graph_runner_ = NULL;
   input_handler_weak_ptr_ = host_impl->AsWeakPtr();
   return host_impl;
 }
 
-void LayerTreeHost::DidLoseOutputSurface() {
-  TRACE_EVENT0("cc", "LayerTreeHost::DidLoseOutputSurface");
+void LayerTreeHost::DidLoseCompositorFrameSink() {
+  TRACE_EVENT0("cc", "LayerTreeHost::DidLoseCompositorFrameSink");
   DCHECK(task_runner_provider_->IsMainThread());
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetDeferCommits(bool defer_commits) {
   proxy_->SetDeferCommits(defer_commits);
 }
 
 DISABLE_CFI_PERF
 void LayerTreeHost::SetNeedsAnimate() {
@@ skipping 444 matching lines @@
 
   debug_state_.FromProtobuf(proto.debug_state());
   has_gpu_rasterization_trigger_ = proto.has_gpu_rasterization_trigger();
   content_is_suitable_for_gpu_rasterization_ =
       proto.content_is_suitable_for_gpu_rasterization();
   id_ = proto.id();
   next_commit_forces_redraw_ = proto.next_commit_forces_redraw();
 }
 
 }  // namespace cc