sync compositor: Software draw

content/browser/android/synchronous_compositor_host.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/browser/android/synchronous_compositor_host.h"
 
 #include "base/containers/hash_tables.h"
+#include "base/memory/shared_memory.h"
+#include "base/trace_event/trace_event_argument.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "content/browser/renderer_host/render_widget_host_view_android.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/android/sync_compositor_messages.h"
 #include "content/public/browser/android/synchronous_compositor_client.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_view_host.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/SkRect.h"
+#include "ui/gfx/skia_util.h"
 
 namespace content {
 
 SynchronousCompositorHost::SynchronousCompositorHost(
     RenderWidgetHostViewAndroid* rwhva,
     SynchronousCompositorClient* client)
     : rwhva_(rwhva),
       client_(client),
       ui_task_runner_(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)),
@@ skipping 52 matching lines @@
     UpdateFrameMetaData(frame->metadata);
   return frame;
 }
 
 void SynchronousCompositorHost::UpdateFrameMetaData(
     const cc::CompositorFrameMetadata& frame_metadata) {
   rwhva_->SynchronousFrameMetadata(frame_metadata);
 }
 
 bool SynchronousCompositorHost::DemandDrawSw(SkCanvas* canvas) {
-  // TODO(boliu): Implement.
-  return false;
+  SyncCompositorDemandDrawSwParams params;
+  params.size = gfx::Size(canvas->getBaseLayerSize().width(),
+                          canvas->getBaseLayerSize().height());
+  SkIRect canvas_clip;
+  canvas->getClipDeviceBounds(&canvas_clip);
+  params.clip = gfx::SkIRectToRect(canvas_clip);
+  params.transform.matrix() = canvas->getTotalMatrix();
+
+  SkImageInfo info =
+      SkImageInfo::MakeN32Premul(params.size.width(), params.size.height());
+  DCHECK_EQ(kRGBA_8888_SkColorType, info.colorType());
+
+  size_t buffer_size = params.size.width() * params.size.height() * 4;

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

info.getSafeSize()? Optionally, bail out if buffer_size == 0 (I'm not sure if
you can end up in a situation where that's possible)

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

Done
Broke this into two parts.

If the size is 0, then just return true. In that case there is nothing to draw
anyway.

But if getSafeSize returns 0, that means it's a overflow, in that case  we
should return false. Can't possibly allocate that much memory on android
anyway..

+  base::SharedMemory shm;
+  {
+    TRACE_EVENT1("browser", "AllocateSharedMemory", "buffer_size", buffer_size);
+    if (!shm.CreateAndMapAnonymous(buffer_size))
+      return false;
+  }
+  base::ProcessHandle renderer_process_handle =
+      rwhva_->GetRenderWidgetHost()->GetProcess()->GetHandle();
+  if (!shm.ShareToProcess(renderer_process_handle, &params.shm_handle))
+    return false;
+
+  scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
+  SyncCompositorCommonBrowserParams common_browser_params;
+  PopulateCommonParams(&common_browser_params);
+  SyncCompositorCommonRendererParams common_renderer_params;
+  bool success = false;
+  if (!sender_->Send(new SyncCompositorMsg_DemandDrawSw(
+          routing_id_, common_browser_params, params, &success,
+          &common_renderer_params, frame.get()))) {
+    return false;
+  }
+  if (!success)
+    return false;
+
+  ProcessCommonParams(common_renderer_params);
+  UpdateFrameMetaData(frame->metadata);
+
+  SkBitmap bitmap;
+  if (!bitmap.installPixels(info, shm.memory(), params.size.width() * 4))

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

Similarly, info.minRowBytes() here?

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

Done.

+    return false;
+
+  {
+    TRACE_EVENT0("browser", "DrawBitmap");
+    canvas->save();
+    canvas->resetMatrix();
+    canvas->drawBitmap(bitmap, 0, 0);
+    canvas->restore();
+  }
+
+  return true;
 }
 
 void SynchronousCompositorHost::ReturnResources(
     const cc::CompositorFrameAck& frame_ack) {
   returned_resources_.insert(returned_resources_.end(),
                              frame_ack.resources.begin(),
                              frame_ack.resources.end());
 }
 
 void SynchronousCompositorHost::SetMemoryPolicy(size_t bytes_limit) {
@@ skipping 137 matching lines @@
         params.scrollable_size, params.page_scale_factor,
         params.min_page_scale_factor, params.max_page_scale_factor);
   }
 }
 
 void SynchronousCompositorHost::UpdateNeedsBeginFrames() {
   rwhva_->OnSetNeedsBeginFrames(is_active_ && need_begin_frame_);
 }
 
 }  // namespace content