cc: Dedup IPCs to return resources to client

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>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/surface_layer.h"
 #include "cc/output/compositor_frame.h"
-#include "cc/output/compositor_frame_ack.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/latency_info_swap_promise.h"
 #include "cc/resources/single_release_callback.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 "components/display_compositor/gl_helper.h"
@@ skipping 888 matching lines @@
   content_view_core_->ShowDisambiguationPopup(rect_pixels, zoomed_bitmap);
 }
 
 std::unique_ptr<SyntheticGestureTarget>
 RenderWidgetHostViewAndroid::CreateSyntheticGestureTarget() {
   return std::unique_ptr<SyntheticGestureTarget>(
       new SyntheticGestureTargetAndroid(
           host_, content_view_core_->CreateMotionEventSynthesizer()));
 }
 
-void RenderWidgetHostViewAndroid::SendDelegatedFrameAck(
-    uint32_t output_surface_id) {
+void RenderWidgetHostViewAndroid::SendReclaimCompositorResources(
+    uint32_t output_surface_id,
+    bool is_swap_ack) {
   DCHECK(host_);
-  cc::CompositorFrameAck ack;
-  if (!surface_returned_resources_.empty())
-    ack.resources.swap(surface_returned_resources_);
-  host_->Send(new ViewMsg_SwapCompositorFrameAck(host_->GetRoutingID(),
-                                                 output_surface_id, ack));
-}
-
-void RenderWidgetHostViewAndroid::SendReturnedDelegatedResources(
-    uint32_t output_surface_id) {
-  DCHECK(host_);
-  cc::CompositorFrameAck ack;
-  DCHECK(!surface_returned_resources_.empty());
-  ack.resources.swap(surface_returned_resources_);
-
-  host_->Send(new ViewMsg_ReclaimCompositorResources(host_->GetRoutingID(),
-                                                     output_surface_id, ack));
+  host_->Send(new ViewMsg_ReclaimCompositorResources(
+      host_->GetRoutingID(), output_surface_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())
-    SendReturnedDelegatedResources(last_output_surface_id_);
+    SendReclaimCompositorResources(last_output_surface_id_,
+                                   false /* is_swap_ack */);
 }
 
 void RenderWidgetHostViewAndroid::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
   // TODO(tansell): Hook this up.
 }
 
 void RenderWidgetHostViewAndroid::DestroyDelegatedContent() {
   RemoveLayers();
   if (!surface_id_.is_null()) {
     DCHECK(surface_factory_.get());
     surface_factory_->Destroy(surface_id_);
     surface_id_ = cc::SurfaceId();
   }
   view_.SetLayer(nullptr);
 }
 
 void RenderWidgetHostViewAndroid::CheckOutputSurfaceChanged(
     uint32_t output_surface_id) {
   if (output_surface_id == last_output_surface_id_)
     return;
   DestroyDelegatedContent();
   surface_factory_.reset();
   if (!surface_returned_resources_.empty())
-    SendReturnedDelegatedResources(last_output_surface_id_);
+    SendReclaimCompositorResources(last_output_surface_id_,
+                                   false /* is_swap_ack */);
 
   last_output_surface_id_ = output_surface_id;
 }
 
 void RenderWidgetHostViewAndroid::SubmitCompositorFrame(
     cc::CompositorFrame frame) {
   cc::SurfaceManager* manager = CompositorImpl::GetSurfaceManager();
   if (!surface_factory_) {
     surface_factory_ = base::WrapUnique(new cc::SurfaceFactory(manager, this));
   }
@@ skipping 43 matching lines @@
   cc::RenderPass* root_pass =
       frame.delegated_frame_data->render_pass_list.back().get();
   texture_size_in_layer_ = root_pass->output_rect.size();
 
   cc::CompositorFrameMetadata metadata = frame.metadata.Clone();
 
   CheckOutputSurfaceChanged(output_surface_id);
   bool has_content = !texture_size_in_layer_.IsEmpty();
 
   base::Closure ack_callback =
-      base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 output_surface_id);
+      base::Bind(&RenderWidgetHostViewAndroid::SendReclaimCompositorResources,
+                 weak_ptr_factory_.GetWeakPtr(), output_surface_id,
+                 true /* is_swap_ack */);
 
   ack_callbacks_.push(ack_callback);
 
   if (!has_content) {
     DestroyDelegatedContent();
   } else {
     SubmitCompositorFrame(std::move(frame));
     view_.GetLayer()->SetIsDrawable(true);
     view_.GetLayer()->SetContentsOpaque(true);
     view_.GetLayer()->SetBounds(texture_size_in_layer_);
@@ skipping 21 matching lines @@
 void RenderWidgetHostViewAndroid::RetainFrame(uint32_t output_surface_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::SendDelegatedFrameAck,
+        base::Bind(&RenderWidgetHostViewAndroid::SendReclaimCompositorResources,
                    weak_ptr_factory_.GetWeakPtr(),
-                   last_frame_info_->output_surface_id);
+                   last_frame_info_->output_surface_id, true /* is_swap_ack */);
 
     ack_callbacks_.push(ack_callback);
   }
 
   last_frame_info_.reset(
       new LastFrameInfo(output_surface_id, std::move(frame)));
 }
 
 void RenderWidgetHostViewAndroid::SynchronousFrameMetadata(
     cc::CompositorFrameMetadata frame_metadata) {
@@ skipping 882 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