Allow CopyFromBackingStore to fallback to copying from the renderer side if the accelerated surface…

content/renderer/render_widget.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/renderer/render_widget.h"
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "cc/base/switches.h"
@@ skipping 296 matching lines @@
     IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnRepaint)
     IPC_MESSAGE_HANDLER(ViewMsg_SmoothScrollCompleted, OnSmoothScrollCompleted)
     IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
     IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
     IPC_MESSAGE_HANDLER(ViewMsg_ScreenInfoChanged, OnScreenInfoChanged)
     IPC_MESSAGE_HANDLER(ViewMsg_UpdateScreenRects, OnUpdateScreenRects)
 #if defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(ViewMsg_ImeBatchStateChanged, OnImeBatchStateChanged)
     IPC_MESSAGE_HANDLER(ViewMsg_ShowImeIfNeeded, OnShowImeIfNeeded)
 #endif
+    IPC_MESSAGE_HANDLER(ViewMsg_Snapshot, OnSnapshot)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool RenderWidget::Send(IPC::Message* message) {
   // Don't send any messages after the browser has told us to close, and filter
   // most outgoing messages while swapped out.
   if ((is_swapped_out_ &&
        !SwappedOutMessages::CanSendWhileSwappedOut(message)) ||
@@ skipping 1480 matching lines @@
   // Paint the entire thing (using original bounds, not scaled bounds).
   PaintRect(orig_bounds, orig_bounds.origin(), canvas.get());
   canvas->restore();
 
   // Return the widget to its previous size.
   webwidget_->resize(old_size);
 
   Send(new ViewHostMsg_PaintAtSize_ACK(routing_id_, tag, bounds.size()));
 }
 
+namespace {
+void OnSnapshotFailed(scoped_refptr<content::RenderWidget> render_widget,
+                      int routing_id) {
+  render_widget->Send(new ViewHostMsg_Snapshot(routing_id, false, SkBitmap()));
+}
+}  // namespace
+
+void RenderWidget::OnSnapshot(const gfx::Rect& src_subrect) {
+  base::TimeTicks beginning_time = base::TimeTicks::Now();
+
+  base::ScopedClosureRunner scoped_callback_runner(
+      base::Bind(OnSnapshotFailed, make_scoped_refptr(this), routing_id_));

[jamesr, 2013/03/22 00:05:33]

This functional style is highly uncommon in chromium and IMO overly complicated.
 If you want to make sure that some code happens if some of the intermediate
operations fail, move the operations that may fail to a helper function that
returns a bool and then deal with the response in the caller.

[justinlin, 2013/03/22 00:43:39]

Done.

+
+  SkBitmap snapshot;
+  if (!webwidget_ || src_subrect.IsEmpty())
+    return;
+
+  gfx::Rect viewport_size = gfx::IntersectRects(
+      src_subrect, gfx::Rect(physical_backing_size_));
+
+  skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(
+      skia::CreatePlatformCanvas(viewport_size.width(),
+                                 viewport_size.height(),
+                                 true,
+                                 NULL,
+                                 skia::RETURN_NULL_ON_FAILURE));
+  if (!canvas.get())
+    return;
+
+  canvas->save();
+  webwidget_->layout();
+
+  PaintRect(viewport_size, viewport_size.origin(), canvas.get());
+  canvas->restore();
+
+  const SkBitmap& bitmap = skia::GetTopDevice(*canvas)->accessBitmap(false);
+  if (!bitmap.copyTo(&snapshot, SkBitmap::kARGB_8888_Config))
+    return;
+
+  UMA_HISTOGRAM_TIMES("Renderer4.Snapshot",
+                      base::TimeTicks::Now() - beginning_time);
+
+  scoped_callback_runner.Release();
+
+  Send(new ViewHostMsg_Snapshot(routing_id_, true, snapshot));
+}
+
 void RenderWidget::OnRepaint(const gfx::Size& size_to_paint) {
   // During shutdown we can just ignore this message.
   if (!webwidget_)
     return;
 
   set_next_paint_is_repaint_ack();
   if (is_accelerated_compositing_active_) {
     if (compositor_)
       compositor_->setNeedsRedraw();
     scheduleComposite();
@@ skipping 431 matching lines @@
     if (!context->Initialize(
             attributes,
             false /* bind generates resources */,
             CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
       return NULL;
     return context.release();
   }
 }
 
 }  // namespace content