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

content/browser/renderer_host/render_widget_host_impl.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/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 373 matching lines @@
     IPC_MESSAGE_HANDLER(ViewHostMsg_LockMouse, OnLockMouse)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UnlockMouse, OnUnlockMouse)
     IPC_MESSAGE_HANDLER(ViewHostMsg_ShowDisambiguationPopup,
                         OnShowDisambiguationPopup)
 #if defined(OS_WIN)
     IPC_MESSAGE_HANDLER(ViewHostMsg_WindowlessPluginDummyWindowCreated,
                         OnWindowlessPluginDummyWindowCreated)
     IPC_MESSAGE_HANDLER(ViewHostMsg_WindowlessPluginDummyWindowDestroyed,
                         OnWindowlessPluginDummyWindowDestroyed)
 #endif
+    IPC_MESSAGE_HANDLER(ViewHostMsg_Snapshot, OnSnapshot)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
   if (!handled && view_ && view_->OnMessageReceived(msg))
     return true;
 
   if (!msg_is_ok) {
     // The message de-serialization failed. Kill the renderer process.
     RecordAction(UserMetricsAction("BadMessageTerminate_RWH"));
     GetProcess()->ReceivedBadMessage();
@@ skipping 159 matching lines @@
   is_loading_ = is_loading;
   if (!view_)
     return;
   view_->SetIsLoading(is_loading);
 }
 
 void RenderWidgetHostImpl::CopyFromBackingStore(
     const gfx::Rect& src_subrect,
     const gfx::Size& accelerated_dst_size,
     const base::Callback<void(bool, const SkBitmap&)>& callback) {
+  gfx::Rect accelerated_copy_rect = src_subrect.IsEmpty() ?
+      gfx::Rect(view_->GetViewBounds().size()) : src_subrect;
+
   if (view_ && is_accelerated_compositing_active_) {
     TRACE_EVENT0("browser",
         "RenderWidgetHostImpl::CopyFromBackingStore::FromCompositingSurface");
-    gfx::Rect copy_rect = src_subrect.IsEmpty() ?
-        gfx::Rect(view_->GetViewBounds().size()) : src_subrect;
-    view_->CopyFromCompositingSurface(copy_rect,
+
+    view_->CopyFromCompositingSurface(accelerated_copy_rect,
                                       accelerated_dst_size,
                                       callback);
     return;
   }
 
   BackingStore* backing_store = GetBackingStore(false);
   if (!backing_store) {
-    callback.Run(false, SkBitmap());
+    GetSnapshotFromRenderer(accelerated_copy_rect,

[Sam Kerner (Chrome), 2013/03/18 19:30:52]

You are changing the semantics of this method from "Look in the backing store
cache (or GPU surface) for an image.  Return it on a hit" to "Get the image. 
Use the cache if possible, Otherwise, get it from the renderer."


If you do this, you need to look at all the users and update them.  Users will
have some dead code, because they handle cache misses that can not happen after
your change.  Your change does the cleanup for CaptureVisibleTab's
implementation.  The only other user I knew of was thumbnail generation for the
new tab page, but others may have been added over time.  

I would change the name of the method to something like "GetImageAsBitmap()", to
make it clear that you are doing something potentially expensive (IPC to the
renderer).

You can also choose to not change the semantics of the method, and restore the
old code in captureVisibleTab to ask the renderer for a snapshot on a backing
store cache miss.

+                            accelerated_dst_size,
+                            callback);
     return;
   }
 
   TRACE_EVENT0("browser",
       "RenderWidgetHostImpl::CopyFromBackingStore::FromBackingStore");
   gfx::Rect copy_rect = src_subrect.IsEmpty() ?
       gfx::Rect(backing_store->size()) : src_subrect;
   // When the result size is equal to the backing store size, copy from the
   // backing store directly to the output canvas.
   skia::PlatformBitmap output;
   bool result = backing_store->CopyFromBackingStore(copy_rect, &output);
   callback.Run(result, output.GetBitmap());
 }
 
+void RenderWidgetHostImpl::GetSnapshotFromRenderer(
+    const gfx::Rect& src_subrect,
+    const gfx::Size& dst_size,
+    const base::Callback<void(bool, const SkBitmap&)>& callback) {
+  TRACE_EVENT0("browser", "RenderWidgetHostImpl::GetSnapshotFromRenderer");
+  pending_snapshots_.push(std::make_pair(dst_size, callback));
+  Send(new ViewMsg_Snapshot(routing_id_, src_subrect));
+}
+
+void RenderWidgetHostImpl::OnSnapshot(bool success,
+                                      const SkBitmap& bitmap) {
+  if (pending_snapshots_.size() == 0) {
+    LOG(ERROR) << "RenderWidgetHostImpl::OnSnapshot: "
+                  "Received a snapshot that was not requested.";
+    return;
+  }
+
+  PendingSnapshotInfo snapshot_info = pending_snapshots_.front();
+  pending_snapshots_.pop();
+
+  const gfx::Size& dst_size = snapshot_info.first;
+  const base::Callback<void(bool, const SkBitmap&)>& callback =
+      snapshot_info.second;
+
+  if (!success) {
+    callback.Run(success, SkBitmap());
+    return;
+  }
+
+  SkBitmap resized = skia::ImageOperations::Resize(
+      bitmap, skia::ImageOperations::RESIZE_GOOD, dst_size.width(),
+      dst_size.height());
+
+  callback.Run(success, resized);
+}
+
 #if defined(TOOLKIT_GTK)
 bool RenderWidgetHostImpl::CopyFromBackingStoreToGtkWindow(
     const gfx::Rect& dest_rect, GdkWindow* target) {
   BackingStore* backing_store = GetBackingStore(false);
   if (!backing_store)
     return false;
   (static_cast<BackingStoreGtk*>(backing_store))->PaintToRect(
       dest_rect, target);
   return true;
 }
@@ skipping 1799 matching lines @@
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
 }  // namespace content