Fork cc::OutputSurface into cc::CompositorFrameSink.

content/renderer/android/synchronous_compositor_filter.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 "content/renderer/android/synchronous_compositor_filter.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/stl_util.h"
@@ skipping 113 matching lines @@
     DLOG(WARNING) << "Failed to send message";
 }
 
 void SynchronousCompositorFilter::FilterReadyOnCompositorThread() {
   DCHECK(!filter_ready_);
   filter_ready_ = true;
   for (const auto& entry_pair : synchronous_input_handler_proxy_map_) {
     DCHECK(entry_pair.second);
     int routing_id = entry_pair.first;
     CreateSynchronousCompositorProxy(routing_id, entry_pair.second);
-    auto output_surface_entry = output_surface_map_.find(routing_id);
-    if (output_surface_entry != output_surface_map_.end()) {
-      SetProxyOutputSurface(routing_id, output_surface_entry->second);
+    auto compositor_frame_sink_entry =
+        compositor_frame_sink_map_.find(routing_id);
+    if (compositor_frame_sink_entry != compositor_frame_sink_map_.end()) {
+      SetProxyCompositorFrameSink(routing_id,
+                                  compositor_frame_sink_entry->second);
     }
   }
 }
 
-void SynchronousCompositorFilter::RegisterOutputSurface(
+void SynchronousCompositorFilter::RegisterCompositorFrameSink(
     int routing_id,
-    SynchronousCompositorOutputSurface* output_surface) {
+    SynchronousCompositorFrameSink* compositor_frame_sink) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-  DCHECK(output_surface);
+  DCHECK(compositor_frame_sink);
   SynchronousCompositorProxy* proxy = FindProxy(routing_id);
   if (proxy) {
-    proxy->SetOutputSurface(output_surface);
+    proxy->SetCompositorFrameSink(compositor_frame_sink);
   } else {
-    DCHECK(output_surface_map_.find(routing_id) == output_surface_map_.end());
-    output_surface_map_[routing_id] = output_surface;
+    DCHECK(compositor_frame_sink_map_.find(routing_id) ==
+           compositor_frame_sink_map_.end());
+    compositor_frame_sink_map_[routing_id] = compositor_frame_sink;
   }
 }
 
 void SynchronousCompositorFilter::OnSynchronizeRendererState(
     const std::vector<int>& routing_ids,
     std::vector<SyncCompositorCommonRendererParams>* out) {
   for (int routing_id : routing_ids) {
     SynchronousCompositorProxy* proxy = FindProxy(routing_id);
     SyncCompositorCommonRendererParams param;
     if (proxy)
       proxy->PopulateCommonParams(&param);
     out->push_back(param);
   }
 }
 
-void SynchronousCompositorFilter::UnregisterOutputSurface(
+void SynchronousCompositorFilter::UnregisterCompositorFrameSink(
     int routing_id,
-    SynchronousCompositorOutputSurface* output_surface) {
+    SynchronousCompositorFrameSink* compositor_frame_sink) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
-  DCHECK(output_surface);
+  DCHECK(compositor_frame_sink);
   SynchronousCompositorProxy* proxy = FindProxy(routing_id);
   if (proxy) {
-    proxy->SetOutputSurface(nullptr);
+    proxy->SetCompositorFrameSink(nullptr);
   }
-  auto entry = output_surface_map_.find(routing_id);
-  if (entry != output_surface_map_.end())
-    output_surface_map_.erase(entry);
+  auto entry = compositor_frame_sink_map_.find(routing_id);
+  if (entry != compositor_frame_sink_map_.end())
+    compositor_frame_sink_map_.erase(entry);
 }
 
 void SynchronousCompositorFilter::CreateSynchronousCompositorProxy(
     int routing_id,
     ui::SynchronousInputHandlerProxy* synchronous_input_handler_proxy) {
   DCHECK(!sync_compositor_map_.contains(routing_id));
   std::unique_ptr<SynchronousCompositorProxy> proxy(
       new SynchronousCompositorProxy(routing_id, this,
                                      synchronous_input_handler_proxy));
   sync_compositor_map_.add(routing_id, std::move(proxy));
 }
 
-void SynchronousCompositorFilter::SetProxyOutputSurface(
+void SynchronousCompositorFilter::SetProxyCompositorFrameSink(
     int routing_id,
-    SynchronousCompositorOutputSurface* output_surface) {
-  DCHECK(output_surface);
+    SynchronousCompositorFrameSink* compositor_frame_sink) {
+  DCHECK(compositor_frame_sink);
   SynchronousCompositorProxy* proxy = FindProxy(routing_id);
   DCHECK(proxy);
-  proxy->SetOutputSurface(output_surface);
+  proxy->SetCompositorFrameSink(compositor_frame_sink);
 }
 
 void SynchronousCompositorFilter::DidAddSynchronousHandlerProxy(
     int routing_id,
     ui::SynchronousInputHandlerProxy* synchronous_input_handler_proxy) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
   DCHECK(synchronous_input_handler_proxy);
   if (filter_ready_) {
     CreateSynchronousCompositorProxy(routing_id,
                                      synchronous_input_handler_proxy);
-    auto entry = output_surface_map_.find(routing_id);
-    if (entry != output_surface_map_.end())
-      SetProxyOutputSurface(routing_id, entry->second);
+    auto entry = compositor_frame_sink_map_.find(routing_id);
+    if (entry != compositor_frame_sink_map_.end())
+      SetProxyCompositorFrameSink(routing_id, entry->second);
   } else {
     auto*& mapped_synchronous_input_handler_proxy =
         synchronous_input_handler_proxy_map_[routing_id];
     DCHECK(!mapped_synchronous_input_handler_proxy);
     mapped_synchronous_input_handler_proxy = synchronous_input_handler_proxy;
   }
 }
 
 void SynchronousCompositorFilter::DidRemoveSynchronousHandlerProxy(
     int routing_id) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
   if (base::ContainsKey(sync_compositor_map_, routing_id)) {
     DCHECK(compositor_task_runner_->BelongsToCurrentThread());
     DCHECK(sync_compositor_map_.contains(routing_id));
     sync_compositor_map_.erase(routing_id);
   }
   if (base::ContainsKey(synchronous_input_handler_proxy_map_, routing_id))
     synchronous_input_handler_proxy_map_.erase(routing_id);
 }
 
 }  // namespace content