sync compostor: Return resources async IPC

content/renderer/android/synchronous_compositor_output_surface.cc

 // Copyright 2013 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_output_surface.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/software_output_device.h"
+#include "content/common/android/sync_compositor_messages.h"
 #include "content/renderer/android/synchronous_compositor_external_begin_frame_source.h"
 #include "content/renderer/android/synchronous_compositor_registry.h"
 #include "content/renderer/gpu/frame_swap_message_queue.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
+#include "ipc/ipc_message.h"
+#include "ipc/ipc_message_macros.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
 namespace content {
 
 namespace {
 
 const int64_t kFallbackTickTimeoutInMilliseconds = 100;
@@ skipping 62 matching lines @@
 }
 
 SynchronousCompositorOutputSurface::~SynchronousCompositorOutputSurface() {}
 
 void SynchronousCompositorOutputSurface::SetSyncClient(
     SynchronousCompositorOutputSurfaceClient* compositor) {
   DCHECK(CalledOnValidThread());
   sync_client_ = compositor;
 }
 
+bool SynchronousCompositorOutputSurface::OnMessageReceived(
+    const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorOutputSurface, message)
+    IPC_MESSAGE_HANDLER(SyncCompositorMsg_ReclaimResources, OnReclaimResources)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
 bool SynchronousCompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* surface_client) {
   DCHECK(CalledOnValidThread());
   if (!cc::OutputSurface::BindToClient(surface_client))
     return false;
 
   client_->SetMemoryPolicy(memory_policy_);
   registry_->RegisterOutputSurface(routing_id_, this);
   registered_ = true;
   return true;
@@ skipping 105 matching lines @@
     bool software_draw) {
   gfx::Transform adjusted_transform = transform;
   adjusted_transform.matrix().postTranslate(-viewport.x(), -viewport.y(), 0);
   did_swap_ = false;
   client_->OnDraw(adjusted_transform, viewport, clip, software_draw);
 
   if (did_swap_)
     client_->DidSwapBuffersComplete();
 }
 
-void SynchronousCompositorOutputSurface::ReturnResources(
+void SynchronousCompositorOutputSurface::OnReclaimResources(
     uint32_t output_surface_id,
-    const cc::CompositorFrameAck& frame_ack) {
-  if (output_surface_id_ == output_surface_id)
-    ReclaimResources(&frame_ack);
+    const cc::CompositorFrameAck& ack) {
+  // Ignore message if it's a stale one coming from a different output surface
+  // (e.g. after a lost context).
+  if (output_surface_id != output_surface_id_)
+    return;
+  ReclaimResources(&ack);
 }
 
 void SynchronousCompositorOutputSurface::SetMemoryPolicy(size_t bytes_limit) {
   DCHECK(CalledOnValidThread());
   bool became_zero = memory_policy_.bytes_limit_when_visible && !bytes_limit;
   bool became_non_zero =
       !memory_policy_.bytes_limit_when_visible && bytes_limit;
   memory_policy_.bytes_limit_when_visible = bytes_limit;
   memory_policy_.num_resources_limit = kNumResourcesLimit;
 
@@ skipping 23 matching lines @@
   std::unique_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope =
       frame_swap_message_queue_->AcquireSendMessageScope();
   frame_swap_message_queue_->DrainMessages(messages);
 }
 
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace content