sync compositor: Software draw

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 "base/numerics/safe_math.h"
 #include "content/common/android/sync_compositor_messages.h"
 #include "content/common/cc_messages.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sender.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkImageInfo.h"
+#include "third_party/skia/include/core/SkRegion.h"
 #include "ui/events/latency_info.h"
+#include "ui/gfx/skia_util.h"
 
 namespace content {
 
 SynchronousCompositorProxy::SynchronousCompositorProxy(
     int routing_id,
     IPC::Sender* sender,
     SynchronousCompositorOutputSurface* output_surface,
     SynchronousCompositorExternalBeginFrameSource* begin_frame_source,
     ui::SynchronousInputHandlerProxy* input_handler_proxy,
     InputHandlerManagerClient::Handler* handler)
@@ skipping 117 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_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(
     const SyncCompositorCommonBrowserParams& common_params,
@@ skipping 29 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);
 }
 
+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;
+
+  base::CheckedNumeric<size_t> stride = 4;

[dcheng, 2015/11/25 00:55:17]

I didn't realize this is in the renderer, so the CheckedNumeric here is
pointless. Sorry! Let's just revert this to the original.

[boliu, 2015/11/25 01:13:41]

Done.

+  stride *= params.size.width();
+  if (!stride.IsValid())
+    return;
+  base::CheckedNumeric<size_t> bytes(stride);
+  bytes *= params.size.height();
+  if (!bytes.IsValid())
+    return;
+
+  base::SharedMemory shm(params.shm_handle, false);
+  if (!shm.Map(bytes.ValueOrDie()))
+    return;
+  DCHECK(shm.memory());
+
+  SkImageInfo info =
+      SkImageInfo::MakeN32Premul(params.size.width(), params.size.height());

[dcheng, 2015/11/25 00:56:18]

Similarly, if you calculate this first, you can use the Skia helpers instead of
replication the calculations.

[boliu, 2015/11/25 01:13:41]

Done.

+  SkBitmap bitmap;
+  if (!bitmap.installPixels(info, shm.memory(), stride.ValueOrDie()))
+    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);
+    DeliverMessages();
+  }
+  PopulateCommonParams(common_renderer_params);
+}
+
 void SynchronousCompositorProxy::OnComputeScroll(
     const SyncCompositorCommonBrowserParams& common_params,
     base::TimeTicks animation_time,
     SyncCompositorCommonRendererParams* common_renderer_params) {
   ProcessCommonParams(common_params);
   if (need_animate_scroll_) {
     need_animate_scroll_ = false;
     input_handler_proxy_->SynchronouslyAnimate(animation_time);
   }
   PopulateCommonParams(common_renderer_params);
@@ skipping 17 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