Fork cc::OutputSurface into cc::CompositorFrameSink.

blimp/client/core/compositor/blimp_compositor.cc

 // Copyright 2015 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 "blimp/client/core/compositor/blimp_compositor.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "blimp/client/core/compositor/blimp_compositor_dependencies.h"
-#include "blimp/client/core/compositor/delegated_output_surface.h"
+#include "blimp/client/core/compositor/blimp_compositor_frame_sink.h"
 #include "blimp/client/public/compositor/compositor_dependencies.h"
 #include "blimp/net/blimp_stats.h"
 #include "cc/animation/animation_host.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/surface_layer.h"
-#include "cc/output/output_surface.h"
+#include "cc/output/compositor_frame_sink.h"
 #include "cc/proto/compositor_message.pb.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_host.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "net/base/net_errors.h"
 #include "ui/gl/gl_surface.h"
 
@@ skipping 22 matching lines @@
 
 }  // namespace
 
 BlimpCompositor::BlimpCompositor(
     int render_widget_id,
     BlimpCompositorDependencies* compositor_dependencies,
     BlimpCompositorClient* client)
     : render_widget_id_(render_widget_id),
       client_(client),
       compositor_dependencies_(compositor_dependencies),
-      output_surface_(nullptr),
-      output_surface_request_pending_(false),
+      proxy_client_(nullptr),
+      compositor_frame_sink_request_pending_(false),
       layer_(cc::Layer::Create()),
       remote_proto_channel_receiver_(nullptr),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   surface_id_allocator_ = base::MakeUnique<cc::SurfaceIdAllocator>(
       GetEmbedderDeps()->AllocateSurfaceClientId());
   GetEmbedderDeps()->GetSurfaceManager()->RegisterSurfaceClientId(
       surface_id_allocator_->client_id());
   CreateLayerTreeHost();
@@ skipping 10 matching lines @@
 void BlimpCompositor::SetVisible(bool visible) {
   host_->SetVisible(visible);
 }
 
 bool BlimpCompositor::OnTouchEvent(const ui::MotionEvent& motion_event) {
   if (input_manager_)
     return input_manager_->OnTouchEvent(motion_event);
   return false;
 }
 
-void BlimpCompositor::RequestNewOutputSurface() {
+void BlimpCompositor::RequestNewCompositorFrameSink() {
   DCHECK(!surface_factory_);
-  DCHECK(!output_surface_request_pending_);
+  DCHECK(!compositor_frame_sink_request_pending_);
 
-  output_surface_request_pending_ = true;
+  compositor_frame_sink_request_pending_ = true;
   GetEmbedderDeps()->GetContextProviders(
       base::Bind(&BlimpCompositor::OnContextProvidersCreated,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void BlimpCompositor::DidInitializeOutputSurface() {
-  output_surface_request_pending_ = false;
+void BlimpCompositor::DidInitializeCompositorFrameSink() {
+  compositor_frame_sink_request_pending_ = false;
 }
 
 void BlimpCompositor::DidCommitAndDrawFrame() {
   BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
 }
 
 void BlimpCompositor::SetProtoReceiver(ProtoReceiver* receiver) {
   remote_proto_channel_receiver_ = receiver;
 }
 
@@ skipping 19 matching lines @@
       // We should have a receiver if we're getting compositor messages that
       // are not INITIALIZE_IMPL or CLOSE_IMPL.
       DCHECK(remote_proto_channel_receiver_);
       remote_proto_channel_receiver_->OnProtoReceived(std::move(message));
   }
 }
 
 void BlimpCompositor::OnContextProvidersCreated(
     const scoped_refptr<cc::ContextProvider>& compositor_context_provider,
     const scoped_refptr<cc::ContextProvider>& worker_context_provider) {
-  DCHECK(!surface_factory_)
-      << "Any connection to the old output surface should have been destroyed";
+  DCHECK(!surface_factory_) << "Any connection to the old CompositorFrameSink "
+                               "should have been destroyed";
 
   // Make sure we still have a host and we're still expecting an output surface.
   // This can happen if the host dies while the request is outstanding and we
   // build a new one that hasn't asked for a surface yet.
-  if (!output_surface_request_pending_)
+  if (!compositor_frame_sink_request_pending_)
     return;
 
   // Try again if the context creation failed.
   if (!compositor_context_provider) {
     GetEmbedderDeps()->GetContextProviders(
         base::Bind(&BlimpCompositor::OnContextProvidersCreated,
                    weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
-  std::unique_ptr<DelegatedOutputSurface> delegated_output_surface =
-      base::MakeUnique<DelegatedOutputSurface>(
-          std::move(compositor_context_provider),
-          std::move(worker_context_provider),
-          base::ThreadTaskRunnerHandle::Get(), weak_ptr_factory_.GetWeakPtr());
+  auto compositor_frame_sink = base::MakeUnique<BlimpCompositorFrameSink>(
+      std::move(compositor_context_provider),
+      std::move(worker_context_provider), base::ThreadTaskRunnerHandle::Get(),
+      weak_ptr_factory_.GetWeakPtr());
 
-  host_->SetOutputSurface(std::move(delegated_output_surface));
+  host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
 }
 
 void BlimpCompositor::SendWebGestureEvent(
     const blink::WebGestureEvent& gesture_event) {
   client_->SendWebGestureEvent(render_widget_id_, gesture_event);
 }
 
-void BlimpCompositor::BindToOutputSurface(
-    base::WeakPtr<BlimpOutputSurface> output_surface) {
+void BlimpCompositor::BindToProxyClient(
+    base::WeakPtr<BlimpCompositorFrameSinkProxyClient> proxy_client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!surface_factory_);
 
-  output_surface_ = output_surface;
+  proxy_client_ = proxy_client;
   surface_factory_ = base::MakeUnique<cc::SurfaceFactory>(
       GetEmbedderDeps()->GetSurfaceManager(), this);
 }
 
 void BlimpCompositor::SwapCompositorFrame(cc::CompositorFrame frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(surface_factory_);
 
   cc::RenderPass* root_pass =
       frame.delegated_frame_data->render_pass_list.back().get();
@@ skipping 18 matching lines @@
     content_layer->SetIsDrawable(true);
     content_layer->SetContentsOpaque(true);
 
     layer_->AddChild(content_layer);
   }
 
   surface_factory_->SubmitCompositorFrame(surface_id_, std::move(frame),
                                           base::Closure());
 }
 
-void BlimpCompositor::UnbindOutputSurface() {
+void BlimpCompositor::UnbindProxyClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(surface_factory_);
 
   DestroyDelegatedContent();
   surface_factory_.reset();
-  output_surface_ = nullptr;
+  proxy_client_ = nullptr;
 }
 
 void BlimpCompositor::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
   DCHECK(surface_factory_);
   compositor_dependencies_->GetCompositorTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&BlimpOutputSurface::ReclaimCompositorResources,
-                            output_surface_, resources));
+      FROM_HERE,
+      base::Bind(
+          &BlimpCompositorFrameSinkProxyClient::ReclaimCompositorResources,
+          proxy_client_, resources));
 }
 
 CompositorDependencies* BlimpCompositor::GetEmbedderDeps() {
   return compositor_dependencies_->GetEmbedderDependencies();
 }
 
 void BlimpCompositor::DestroyDelegatedContent() {
   if (surface_id_.is_null())
     return;
 
@@ skipping 14 matching lines @@
   params.gpu_memory_buffer_manager =
       GetEmbedderDeps()->GetGpuMemoryBufferManager();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.image_serialization_processor =
       compositor_dependencies_->GetImageSerializationProcessor();
 
   cc::LayerTreeSettings* settings =
       compositor_dependencies_->GetLayerTreeSettings();
   // TODO(khushalsagar): This is a hack. Remove when we move the split point
   // out. For details on why this is needed, see crbug.com/586210.
-  settings->abort_commit_before_output_surface_creation = false;
+  settings->abort_commit_before_compositor_frame_sink_creation = false;
   params.settings = settings;
 
   params.animation_host = cc::AnimationHost::CreateMainInstance();
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner =
       compositor_dependencies_->GetCompositorTaskRunner();
 
   host_ = cc::LayerTreeHost::CreateRemoteClient(
       this /* remote_proto_channel */, compositor_task_runner, &params);
 
@@ skipping 14 matching lines @@
 
   // Destroy the old LayerTreeHost state.
   host_.reset();
 
   // Destroy the old input manager state.
   // It is important to destroy the LayerTreeHost before destroying the input
   // manager as it has a reference to the cc::InputHandlerClient owned by the
   // BlimpInputManager.
   input_manager_.reset();
 
-  // Cancel any outstanding OutputSurface requests.  That way if we get an async
+  // Cancel any outstanding CompositorFrameSink requests.  That way if we get an
+  // async
   // callback related to the old request we know to drop it.
-  output_surface_request_pending_ = false;
+  compositor_frame_sink_request_pending_ = false;
 
   // Make sure we don't have a receiver at this point.
   DCHECK(!remote_proto_channel_receiver_);
 }
 
 }  // namespace client
 }  // namespace blimp