Fork cc::OutputSurface into cc::CompositorFrameSink.

ui/compositor/compositor.cc

 // Copyright (c) 2012 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 "ui/compositor/compositor.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <deque>
@@ skipping 61 matching lines @@
 
 Compositor::Compositor(ui::ContextFactory* context_factory,
                        scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : context_factory_(context_factory),
       root_layer_(NULL),
       widget_(gfx::kNullAcceleratedWidget),
 #if defined(USE_AURA)
       window_(nullptr),
 #endif
       widget_valid_(false),
-      output_surface_requested_(false),
+      compositor_frame_sink_requested_(false),
       surface_id_allocator_(new cc::SurfaceIdAllocator(
           context_factory->AllocateSurfaceClientId())),
       task_runner_(task_runner),
       vsync_manager_(new CompositorVSyncManager()),
       device_scale_factor_(0.0f),
       locks_will_time_out_(true),
       compositor_lock_(NULL),
       layer_animator_collection_(this),
       weak_ptr_factory_(this) {
   context_factory->GetSurfaceManager()->RegisterSurfaceClientId(
@@ skipping 84 matching lines @@
       settings.renderer_settings.buffer_to_texture_target_map.insert(
           cc::BufferToTextureTargetMap::value_type(
               cc::BufferToTextureTargetKey(usage, format), target));
     }
   }
 
   // Note: Only enable image decode tasks if we have more than one worker
   // thread.
   settings.image_decode_tasks_enabled = false;
 
-  settings.use_output_surface_begin_frame_source = true;
+  settings.use_compositor_frame_sink_begin_frame_source = true;
 
   settings.gpu_memory_policy.bytes_limit_when_visible = 512 * 1024 * 1024;
   settings.gpu_memory_policy.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 
   base::TimeTicks before_create = base::TimeTicks::Now();
 
   cc::LayerTreeHost::InitParams params;
   params.client = this;
   params.shared_bitmap_manager = context_factory_->GetSharedBitmapManager();
@@ skipping 58 matching lines @@
 
 void Compositor::RemoveSurfaceClient(uint32_t client_id) {
   auto it = surface_clients_.find(client_id);
   DCHECK(it != surface_clients_.end());
   DCHECK(it->second);
   context_factory_->GetSurfaceManager()->UnregisterSurfaceNamespaceHierarchy(
       it->second, it->first);
   surface_clients_.erase(it);
 }
 
-void Compositor::SetOutputSurface(
-    std::unique_ptr<cc::OutputSurface> output_surface) {
-  output_surface_requested_ = false;
-  host_->SetOutputSurface(std::move(output_surface));
+void Compositor::SetCompositorFrameSink(
+    std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink) {
+  compositor_frame_sink_requested_ = false;
+  host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
   // Visibility is reset when the output surface is lost, so update it to match
   // the Compositor's.
   context_factory_->SetDisplayVisible(this, host_->IsVisible());
 }
 
 void Compositor::ScheduleDraw() {
   host_->SetNeedsCommit();
 }
 
 void Compositor::SetRootLayer(Layer* root_layer) {
@@ skipping 97 matching lines @@
                                            base::TimeDelta interval) {
   context_factory_->SetDisplayVSyncParameters(this, timebase, interval);
   vsync_manager_->UpdateVSyncParameters(timebase, interval);
 }
 
 void Compositor::SetAcceleratedWidget(gfx::AcceleratedWidget widget) {
   // This function should only get called once.
   DCHECK(!widget_valid_);
   widget_ = widget;
   widget_valid_ = true;
-  if (output_surface_requested_)
-    context_factory_->CreateOutputSurface(weak_ptr_factory_.GetWeakPtr());
+  if (compositor_frame_sink_requested_)
+    context_factory_->CreateCompositorFrameSink(weak_ptr_factory_.GetWeakPtr());
 }
 
 gfx::AcceleratedWidget Compositor::ReleaseAcceleratedWidget() {
   DCHECK(!IsVisible());
-  host_->ReleaseOutputSurface();
+  host_->ReleaseCompositorFrameSink();
   context_factory_->RemoveCompositor(this);
   widget_valid_ = false;
   gfx::AcceleratedWidget widget = widget_;
   widget_ = gfx::kNullAcceleratedWidget;
   return widget;
 }
 
 gfx::AcceleratedWidget Compositor::widget() const {
   DCHECK(widget_valid_);
   return widget_;
@@ skipping 57 matching lines @@
   for (auto* child : layer->children())
     SendDamagedRectsRecursive(child);
 }
 
 void Compositor::UpdateLayerTreeHost() {
   if (!root_layer())
     return;
   SendDamagedRectsRecursive(root_layer());
 }
 
-void Compositor::RequestNewOutputSurface() {
-  DCHECK(!output_surface_requested_);
-  output_surface_requested_ = true;
+void Compositor::RequestNewCompositorFrameSink() {
+  DCHECK(!compositor_frame_sink_requested_);
+  compositor_frame_sink_requested_ = true;
   if (widget_valid_)
-    context_factory_->CreateOutputSurface(weak_ptr_factory_.GetWeakPtr());
+    context_factory_->CreateCompositorFrameSink(weak_ptr_factory_.GetWeakPtr());
 }
 
-void Compositor::DidInitializeOutputSurface() {
-}
+void Compositor::DidInitializeCompositorFrameSink() {}
 
-void Compositor::DidFailToInitializeOutputSurface() {
-  // The OutputSurface should already be bound/initialized before being given to
+void Compositor::DidFailToInitializeCompositorFrameSink() {
+  // The CompositorFrameSink should already be bound/initialized before being
+  // given to
   // the Compositor.
   NOTREACHED();
 }
 
 void Compositor::DidCommit() {
   DCHECK(!IsLocked());
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingDidCommit(this));
 }
@@ skipping 54 matching lines @@
                     observer_list_,
                     OnCompositingLockStateChanged(this));
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui