IPC-based sync compositor software draw optimization

content/renderer/android/synchronous_compositor_proxy.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_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/memory/shared_memory.h"
 #include "content/common/android/sync_compositor_messages.h"
 #include "content/common/cc_messages.h"
@@ skipping 134 matching lines @@
 
 void SynchronousCompositorProxy::OnMessageReceived(
     const IPC::Message& message) {
   DCHECK(!inside_receive_);
   base::AutoReset<bool> scoped_inside_receive(&inside_receive_, true);
   IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorProxy, message)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_HandleInputEvent, HandleInputEvent)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_BeginFrame, BeginFrame)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_ComputeScroll, OnComputeScroll)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_DemandDrawHw, DemandDrawHw)
+    IPC_MESSAGE_HANDLER(SyncCompositorMsg_SetSharedMemory, SetSharedMemory)
+    IPC_MESSAGE_HANDLER(SyncCompositorMsg_ZeroSharedMemory, ZeroSharedMemory)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_DemandDrawSw, DemandDrawSw)
     IPC_MESSAGE_HANDLER(SyncCompositorMsg_UpdateState, ProcessCommonParams)
   IPC_END_MESSAGE_MAP()
 }
 
 bool SynchronousCompositorProxy::Send(IPC::Message* message) {
   return sender_->Send(message);
 }
 
 void SynchronousCompositorProxy::HandleInputEvent(
@@ skipping 30 matching lines @@
       params.surface_size, params.transform, params.viewport, params.clip,
       params.viewport_rect_for_tile_priority,
       params.transform_for_tile_priority);
   if (frame_ptr) {
     frame_ptr->AssignTo(frame);
     DeliverMessages();
   }
   PopulateCommonParams(common_renderer_params);
 }
 
+struct SynchronousCompositorProxy::SharedMemoryWithSize {
+  base::SharedMemory shm;
+  const size_t buffer_size;
+  bool zeroed;
+
+  SharedMemoryWithSize(base::SharedMemoryHandle shm_handle, size_t buffer_size)
+      : shm(shm_handle, false), buffer_size(buffer_size), zeroed(true) {}
+};
+
+void SynchronousCompositorProxy::SetSharedMemory(
+    const SyncCompositorCommonBrowserParams& common_params,
+    const SyncCompositorSetSharedMemoryParams& params,
+    bool* success,
+    SyncCompositorCommonRendererParams* common_renderer_params) {
+  *success = false;
+  ProcessCommonParams(common_params);
+  if (!base::SharedMemory::IsHandleValid(params.shm_handle))
+    return;
+
+  software_draw_shm_.reset(
+      new SharedMemoryWithSize(params.shm_handle, params.buffer_size));
+  if (!software_draw_shm_->shm.Map(params.buffer_size))
+    return;
+  DCHECK(software_draw_shm_->shm.memory());
+  PopulateCommonParams(common_renderer_params);
+  *success = true;
+}
+
+void SynchronousCompositorProxy::ZeroSharedMemory() {
+  DCHECK(!software_draw_shm_->zeroed);
+  memset(software_draw_shm_->shm.memory(), 0, software_draw_shm_->buffer_size);
+  software_draw_shm_->zeroed = true;
+}
+
 void SynchronousCompositorProxy::DemandDrawSw(
     const SyncCompositorCommonBrowserParams& common_params,
     const SyncCompositorDemandDrawSwParams& params,
     bool* result,
     SyncCompositorCommonRendererParams* common_renderer_params,
     cc::CompositorFrame* frame) {
   DCHECK(frame);
   ProcessCommonParams(common_params);
   *result = false;  // Early out ok.
-  if (!base::SharedMemory::IsHandleValid(params.shm_handle))
-    return;
+
+  DCHECK(software_draw_shm_->zeroed);
+  software_draw_shm_->zeroed = false;
 
   SkImageInfo info =
       SkImageInfo::MakeN32Premul(params.size.width(), params.size.height());
   size_t stride = info.minRowBytes();
   size_t buffer_size = info.getSafeSize(stride);
-  DCHECK(buffer_size);
-
-  base::SharedMemory shm(params.shm_handle, false);
-  if (!shm.Map(buffer_size))
-    return;
-  DCHECK(shm.memory());
+  DCHECK_EQ(software_draw_shm_->buffer_size, buffer_size);
 
   SkBitmap bitmap;
-  if (!bitmap.installPixels(info, shm.memory(), stride))
+  if (!bitmap.installPixels(info, software_draw_shm_->shm.memory(), stride))
     return;
   SkCanvas canvas(bitmap);
   canvas.setMatrix(params.transform.matrix());
   canvas.setClipRegion(SkRegion(gfx::RectToSkIRect(params.clip)));
 
   scoped_ptr<cc::CompositorFrame> frame_ptr =
       output_surface_->DemandDrawSw(&canvas);
   if (frame_ptr) {
     *result = true;
     frame_ptr->AssignTo(frame);
@@ skipping 33 matching lines @@
     total_scroll_offset_ = common_params.root_scroll_offset;
     input_handler_proxy_->SynchronouslySetRootScrollOffset(
         total_scroll_offset_);
   }
   if (!common_params.ack.resources.empty()) {
     output_surface_->ReturnResources(common_params.ack);
   }
 }
 
 }  // namespace content