Fork cc::OutputSurface into cc::CompositorFrameSink.

content/browser/renderer_host/render_widget_host_view_android.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 "content/browser/renderer_host/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include <utility>
 
@@ skipping 77 matching lines @@
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/android/view_configuration.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/touch_selection/touch_selection_controller.h"
 
 namespace content {
 
 namespace {
 
-const int kUndefinedOutputSurfaceId = -1;
+const int kUndefinedCompositorFrameSinkId = -1;
 
 static const char kAsyncReadBackString[] = "Compositing.CopyFromSurfaceTime";
 
 class GLHelperHolder {
  public:
   static GLHelperHolder* Create();
 
   display_compositor::GLHelper* gl_helper() { return gl_helper_.get(); }
   bool IsLost() {
     if (!gl_helper_)
@@ skipping 154 matching lines @@
     return rect;
 
   rect.Union(controller.GetStartHandleRect());
   rect.Union(controller.GetEndHandleRect());
   return rect;
 }
 
 }  // anonymous namespace
 
 RenderWidgetHostViewAndroid::LastFrameInfo::LastFrameInfo(
-    uint32_t output_id,
+    uint32_t compositor_frame_sink_id,
     cc::CompositorFrame output_frame)
-    : output_surface_id(output_id), frame(std::move(output_frame)) {}
+    : compositor_frame_sink_id(compositor_frame_sink_id),
+      frame(std::move(output_frame)) {}
 
 RenderWidgetHostViewAndroid::LastFrameInfo::~LastFrameInfo() {}
 
 void RenderWidgetHostViewAndroid::OnContextLost() {
   std::unique_ptr<RenderWidgetHostIterator> widgets(
       RenderWidgetHostImpl::GetAllRenderWidgetHosts());
   while (RenderWidgetHost* widget = widgets->GetNextHost()) {
     if (widget->GetView()) {
       static_cast<RenderWidgetHostViewAndroid*>(widget->GetView())
           ->OnLostResources();
     }
   }
 }
 
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
       outstanding_vsync_requests_(0),
       is_showing_(!widget_host->is_hidden()),
       is_window_visible_(true),
       is_window_activity_started_(true),
       content_view_core_(nullptr),
       ime_adapter_android_(this),
       cached_background_color_(SK_ColorWHITE),
-      last_output_surface_id_(kUndefinedOutputSurfaceId),
+      last_compositor_frame_sink_id_(kUndefinedCompositorFrameSinkId),
       gesture_provider_(ui::GetGestureProviderConfig(
                             ui::GestureProviderConfigType::CURRENT_PLATFORM),
                         this),
       stylus_text_selector_(this),
       using_browser_compositor_(CompositorImpl::IsInitialized()),
       frame_evictor_(new DelegatedFrameEvictor(this)),
       locks_on_frame_count_(0),
       observing_root_window_(false),
       weak_ptr_factory_(this) {
   // Set the layer which will hold the content layer for this view. The content
@@ skipping 197 matching lines @@
     DCHECK_EQ(locks_on_frame_count_, 0u);
     return;
   }
 
   DCHECK_GT(locks_on_frame_count_, 0u);
   locks_on_frame_count_--;
   frame_evictor_->UnlockFrame();
 
   if (locks_on_frame_count_ == 0) {
     if (last_frame_info_) {
-      InternalSwapCompositorFrame(last_frame_info_->output_surface_id,
+      InternalSwapCompositorFrame(last_frame_info_->compositor_frame_sink_id,
                                   std::move(last_frame_info_->frame));
       last_frame_info_.reset();
     }
 
     view_.GetLayer()->SetHideLayerAndSubtree(!is_showing_);
   }
 }
 
 void RenderWidgetHostViewAndroid::OnShowUnhandledTapUIIfNeeded(int x_dip,
                                                                int y_dip) {
@@ skipping 354 matching lines @@
 }
 
 std::unique_ptr<SyntheticGestureTarget>
 RenderWidgetHostViewAndroid::CreateSyntheticGestureTarget() {
   return std::unique_ptr<SyntheticGestureTarget>(
       new SyntheticGestureTargetAndroid(
           host_, content_view_core_->CreateMotionEventSynthesizer()));
 }
 
 void RenderWidgetHostViewAndroid::SendReclaimCompositorResources(
-    uint32_t output_surface_id,
+    uint32_t compositor_frame_sink_id,
     bool is_swap_ack) {
   DCHECK(host_);
   host_->Send(new ViewMsg_ReclaimCompositorResources(
-      host_->GetRoutingID(), output_surface_id, is_swap_ack,
+      host_->GetRoutingID(), compositor_frame_sink_id, is_swap_ack,
       surface_returned_resources_));
   surface_returned_resources_.clear();
 }
 
 void RenderWidgetHostViewAndroid::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
   if (resources.empty())
     return;
   std::copy(resources.begin(), resources.end(),
             std::back_inserter(surface_returned_resources_));
   if (ack_callbacks_.empty())
-    SendReclaimCompositorResources(last_output_surface_id_,
+    SendReclaimCompositorResources(last_compositor_frame_sink_id_,
                                    false /* is_swap_ack */);
 }
 
-void RenderWidgetHostViewAndroid::CheckOutputSurfaceChanged(
-    uint32_t output_surface_id) {
-  if (output_surface_id == last_output_surface_id_)
+void RenderWidgetHostViewAndroid::CheckCompositorFrameSinkChanged(
+    uint32_t compositor_frame_sink_id) {
+  if (compositor_frame_sink_id == last_compositor_frame_sink_id_)
     return;
 
-  delegated_frame_host_->OutputSurfaceChanged();
+  delegated_frame_host_->CompositorFrameSinkChanged();
 
   if (!surface_returned_resources_.empty())
-    SendReclaimCompositorResources(last_output_surface_id_,
+    SendReclaimCompositorResources(last_compositor_frame_sink_id_,
                                    false /* is_swap_ack */);
 
-  last_output_surface_id_ = output_surface_id;
+  last_compositor_frame_sink_id_ = compositor_frame_sink_id;
 }
 
 void RenderWidgetHostViewAndroid::InternalSwapCompositorFrame(
-    uint32_t output_surface_id,
+    uint32_t compositor_frame_sink_id,
     cc::CompositorFrame frame) {
   last_scroll_offset_ = frame.metadata.root_scroll_offset;
   DCHECK(frame.delegated_frame_data);
   DCHECK(delegated_frame_host_);
 
   if (locks_on_frame_count_ > 0) {
     DCHECK(HasValidFrame());
-    RetainFrame(output_surface_id, std::move(frame));
+    RetainFrame(compositor_frame_sink_id, std::move(frame));
     return;
   }
 
   DCHECK(!frame.delegated_frame_data->render_pass_list.empty());
 
   cc::RenderPass* root_pass =
       frame.delegated_frame_data->render_pass_list.back().get();
   current_surface_size_ = root_pass->output_rect.size();
   bool is_transparent = root_pass->has_transparent_background;
 
   cc::CompositorFrameMetadata metadata = frame.metadata.Clone();
 
-  CheckOutputSurfaceChanged(output_surface_id);
+  CheckCompositorFrameSinkChanged(compositor_frame_sink_id);
   bool has_content = !current_surface_size_.IsEmpty();
 
   base::Closure ack_callback =
       base::Bind(&RenderWidgetHostViewAndroid::SendReclaimCompositorResources,
-                 weak_ptr_factory_.GetWeakPtr(), output_surface_id,
+                 weak_ptr_factory_.GetWeakPtr(), compositor_frame_sink_id,
                  true /* is_swap_ack */);
 
   ack_callbacks_.push(ack_callback);
 
   if (!has_content) {
     DestroyDelegatedContent();
   } else {
     cc::SurfaceFactory::DrawCallback ack_callback =
         base::Bind(&RenderWidgetHostViewAndroid::RunAckCallbacks,
                    weak_ptr_factory_.GetWeakPtr());
@@ skipping 20 matching lines @@
     return;
 
   if (!delegated_frame_host_->HasDelegatedContent())
     return;
 
   frame_evictor_->DiscardedFrame();
   delegated_frame_host_->DestroyDelegatedContent();
 }
 
 void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
-    uint32_t output_surface_id,
+    uint32_t compositor_frame_sink_id,
     cc::CompositorFrame frame) {
-  InternalSwapCompositorFrame(output_surface_id, std::move(frame));
+  InternalSwapCompositorFrame(compositor_frame_sink_id, std::move(frame));
 }
 
 void RenderWidgetHostViewAndroid::ClearCompositorFrame() {
   DestroyDelegatedContent();
 }
 
-void RenderWidgetHostViewAndroid::RetainFrame(uint32_t output_surface_id,
+void RenderWidgetHostViewAndroid::RetainFrame(uint32_t compositor_frame_sink_id,
                                               cc::CompositorFrame frame) {
   DCHECK(locks_on_frame_count_);
 
   // Store the incoming frame so that it can be swapped when all the locks have
   // been released. If there is already a stored frame, then replace and skip
   // the previous one but make sure we still eventually send the ACK. Holding
   // the ACK also blocks the renderer when its max_frames_pending is reached.
   if (last_frame_info_) {
-    base::Closure ack_callback =
-        base::Bind(&RenderWidgetHostViewAndroid::SendReclaimCompositorResources,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   last_frame_info_->output_surface_id, true /* is_swap_ack */);
+    base::Closure ack_callback = base::Bind(
+        &RenderWidgetHostViewAndroid::SendReclaimCompositorResources,
+        weak_ptr_factory_.GetWeakPtr(),
+        last_frame_info_->compositor_frame_sink_id, true /* is_swap_ack */);
 
     ack_callbacks_.push(ack_callback);
   }
 
   last_frame_info_.reset(
-      new LastFrameInfo(output_surface_id, std::move(frame)));
+      new LastFrameInfo(compositor_frame_sink_id, std::move(frame)));
 }
 
 void RenderWidgetHostViewAndroid::SynchronousFrameMetadata(
     cc::CompositorFrameMetadata frame_metadata) {
   if (!content_view_core_)
     return;
 
   bool is_mobile_optimized = IsMobileOptimizedFrame(frame_metadata);
 
   if (host_ && host_->input_router()) {
@@ skipping 846 matching lines @@
     case ui::MotionEvent::ACTION_UP:
     case ui::MotionEvent::ACTION_POINTER_UP:
       UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.OS.TOUCH_RELEASED",
                                   delta.InMicroseconds(), 1, 1000000, 50);
     default:
       return;
   }
 }
 
 }  // namespace content