This adds in the ability for Chrome to generate windows with snapshots of all...

chrome/browser/tab_contents/thumbnail_generator.cc

 // Copyright (c) 2009 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 "chrome/browser/tab_contents/thumbnail_generator.h"
 
 #include <algorithm>
+#include <map>
 
 #include "base/histogram.h"
 #include "base/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/renderer_host/backing_store.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
+#include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/property_bag.h"
 #include "gfx/rect.h"
 #include "gfx/skbitmap_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 // Overview
 // --------
 // This class provides current thumbnails for tabs. The simplest operation is
@@ skipping 74 matching lines @@
 
   // Get the bitmap as a Skia object so we can resample it. This is a large
   // allocation and we can tolerate failure here, so give up if the allocation
   // fails.
   skia::PlatformCanvas temp_canvas;
   if (!backing_store->CopyFromBackingStore(gfx::Rect(gfx::Point(0, 0),
                                                      backing_store->size()),
                                            &temp_canvas))
     return result;
   const SkBitmap& bmp = temp_canvas.getTopPlatformDevice().accessBitmap(false);
-  result = SkBitmapOperations::DownsampleByTwoUntilSize(bmp, kThumbnailWidth,
+
+#if defined(OS_CHROMEOS)
+  // On ChromeOS, the thumbnail is always half the dimensions of the
+  // original.
+  result = SkBitmapOperations::DownsampleByTwo(bmp);
+#else
+  result = SkBitmapOperations::DownsampleByTwoUntilSize(bmp,
+                                                        kThumbnailWidth,
                                                         kThumbnailHeight);
 
-  // This is a bit subtle. SkBitmaps are refcounted, but the magic ones in
-  // PlatformCanvas can't be ssigned to SkBitmap with proper
-  // refcounting.  If the bitmap doesn't change, then the downsampler will
-  // return the input bitmap, which will be the reference to the weird
-  // PlatformCanvas one insetad of a regular one. To get a regular refcounted
-  // bitmap, we need to copy it.
-  if (bmp.width() == result.width() && bmp.height() == result.height())
+  // This is a bit subtle. SkBitmaps are refcounted, but the magic
+  // ones in PlatformCanvas can't be assigned to SkBitmap with proper
+  // refcounting.  If the bitmap doesn't change, then the downsampler
+  // will return the input bitmap, which will be the reference to the
+  // weird PlatformCanvas one insetad of a regular one. To get a
+  // regular refcounted bitmap, we need to copy it.
+  if (bmp.width() == result.width() &&
+      bmp.height() == result.height())
     bmp.copyTo(&result, SkBitmap::kARGB_8888_Config);
+#endif
 
   HISTOGRAM_TIMES(kThumbnailHistogramName,
                   base::TimeTicks::Now() - begin_compute_thumbnail);
   return result;
 }
 
 }  // namespace
 
+struct ThumbnailGenerator::AsyncRequestInfo {
+  scoped_ptr<ThumbnailReadyCallback> callback;
+  scoped_ptr<TransportDIB> thumbnail_dib;
+  RenderWidgetHost* renderer;  // Not owned.
+};
+
 ThumbnailGenerator::ThumbnailGenerator()
     : no_timeout_(false) {
   // The BrowserProcessImpl creates this non-lazily. If you add nontrivial
   // stuff here, be sure to convert it to being lazily created.
   //
   // We don't register for notifications here since BrowserProcessImpl creates
   // us before the NotificationService is.
 }
 
 ThumbnailGenerator::~ThumbnailGenerator() {
 }
 
 void ThumbnailGenerator::StartThumbnailing() {
   if (registrar_.IsEmpty()) {
     // Even though we deal in RenderWidgetHosts, we only care about its
     // subclass, RenderViewHost when it is in a tab. We don't make thumbnails
     // for RenderViewHosts that aren't in tabs, or RenderWidgetHosts that
     // aren't views like select popups.
     registrar_.Add(this, NotificationType::RENDER_VIEW_HOST_CREATED_FOR_TAB,
                    NotificationService::AllSources());
-
     registrar_.Add(this, NotificationType::RENDER_WIDGET_VISIBILITY_CHANGED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::RENDER_WIDGET_HOST_DESTROYED,
                    NotificationService::AllSources());
+    registrar_.Add(this, NotificationType::TAB_CONTENTS_DISCONNECTED,
+                   NotificationService::AllSources());
   }
 }
 
+void ThumbnailGenerator::AskForThumbnail(RenderWidgetHost* renderer,
+                                         ThumbnailReadyCallback* callback,
+                                         gfx::Size size) {
+  SkBitmap first_try = GetThumbnailForRenderer(renderer);
+  if (!first_try.isNull()) {
+    // We were able to find a non-null thumbnail for this renderer, so
+    // we'll go with it.
+    callback->Run(first_try);
+    delete callback;
+    return;
+  }
+
+  // We are going to render the thumbnail asynchronously now, so keep
+  // this callback for later lookup when the rendering is done.
+  static int sequence_num = 0;
+  TransportDIB* thumbnail_dib = TransportDIB::Create(
+      size.width() * size.height() * 4, sequence_num++);
+  linked_ptr<AsyncRequestInfo> request_info(new AsyncRequestInfo);
+  request_info->callback.reset(callback);
+  request_info->thumbnail_dib.reset(thumbnail_dib);
+  request_info->renderer = renderer;
+  ThumbnailCallbackMap::value_type new_value(thumbnail_dib->handle(),
+                                             request_info);
+  std::pair<ThumbnailCallbackMap::iterator, bool> result =
+      callback_map_.insert(new_value);
+  if (!result.second) {
+    NOTREACHED() << "Callback already registered?";
+    return;
+  }
+
+  renderer->PaintAtSize(thumbnail_dib->handle(), size);
+}
+
 SkBitmap ThumbnailGenerator::GetThumbnailForRenderer(
     RenderWidgetHost* renderer) const {
   WidgetThumbnail* wt = GetDataForHost(renderer);
 
   BackingStore* backing_store = renderer->GetBackingStore(false);
   if (!backing_store) {
     // When we have no backing store, there's no choice in what to use. We
     // have to return either the existing thumbnail or the empty one if there
     // isn't a saved one.
     return wt->thumbnail;
@@ skipping 49 matching lines @@
       base::TimeTicks::Now() -
       base::TimeDelta::FromMilliseconds(kVisibilitySlopMS) < wt->last_shown)
     return;  // TODO(brettw) schedule thumbnail generation for this renderer in
              // case we don't get a paint for it after the time slop, but it's
              // still visible.
 
   // Clear the thumbnail, since it's now out of date.
   wt->thumbnail = SkBitmap();
 }
 
+void ThumbnailGenerator::WidgetDidReceivePaintAtSizeAck(
+    RenderWidgetHost* widget,
+    const TransportDIB::Handle& dib_handle,
+    const gfx::Size& size) {
+  // Lookup the callback, run it, and erase it.
+  ThumbnailCallbackMap::iterator item = callback_map_.find(dib_handle);
+  if (item != callback_map_.end()) {
+    TransportDIB* dib = item->second->thumbnail_dib.get();
+    DCHECK(dib);
+    if (!dib) {
+      return;
+    }
+
+    // Create an SkBitmap from the DIB.
+    SkBitmap non_owned_bitmap;
+    SkBitmap result;
+
+    // Fill out the non_owned_bitmap with the right config.  Note that
+    // this code assumes that the transport dib is a 32-bit ARGB
+    // image.
+    non_owned_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
+                               size.width(), size.height());
+    non_owned_bitmap.setPixels(dib->memory());
+
+    // Now alloc/copy the memory so we own it and can pass it around,
+    // and the memory won't go away when the DIB goes away.
+    // TODO: Figure out a way to avoid this copy?
+    non_owned_bitmap.copyTo(&result, SkBitmap::kARGB_8888_Config);
+
+    item->second->callback->Run(result);
+
+    // We're done with the callback, and with the DIB, so delete both.
+    callback_map_.erase(item);
+  }
+}
+
 void ThumbnailGenerator::Observe(NotificationType type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::RENDER_VIEW_HOST_CREATED_FOR_TAB: {
       // Install our observer for all new RVHs.
       RenderViewHost* renderer = Details<RenderViewHost>(details).ptr();
       renderer->set_painting_observer(this);
       break;
     }
 
     case NotificationType::RENDER_WIDGET_VISIBILITY_CHANGED:
       if (*Details<bool>(details).ptr())
         WidgetShown(Source<RenderWidgetHost>(source).ptr());
       else
         WidgetHidden(Source<RenderWidgetHost>(source).ptr());
       break;
 
     case NotificationType::RENDER_WIDGET_HOST_DESTROYED:
       WidgetDestroyed(Source<RenderWidgetHost>(source).ptr());
       break;
 
+    case NotificationType::TAB_CONTENTS_DISCONNECTED:
+      TabContentsDisconnected(Source<TabContents>(source).ptr());
+      break;
+
     default:
       NOTREACHED();
   }
 }
 
 void ThumbnailGenerator::WidgetShown(RenderWidgetHost* widget) {
   WidgetThumbnail* wt = GetDataForHost(widget);
   wt->last_shown = base::TimeTicks::Now();
 
   // If there is no thumbnail (like we're displaying a background tab for the
@@ skipping 31 matching lines @@
   // make a new one.
   if (!wt->thumbnail.isNull())
     return;
   wt->thumbnail = GetThumbnailForRenderer(widget);
 }
 
 void ThumbnailGenerator::WidgetDestroyed(RenderWidgetHost* widget) {
   EraseHostFromShownList(widget);
 }
 
+void ThumbnailGenerator::TabContentsDisconnected(TabContents* contents) {
+  // Go through the existing callbacks, and find any that have the
+  // same renderer as this TabContents and remove them so they don't
+  // hang around.
+  ThumbnailCallbackMap::iterator iterator = callback_map_.begin();
+  RenderWidgetHost* renderer = contents->render_view_host();
+  while (iterator != callback_map_.end()) {
+    if (iterator->second->renderer == renderer) {
+      callback_map_.erase(iterator);
+    }
+    ++iterator;
+  }
+}
+
 void ThumbnailGenerator::ShownDelayHandler() {
   base::TimeTicks threshold = base::TimeTicks::Now() -
       base::TimeDelta::FromMilliseconds(kVisibilitySlopMS);
 
   // Check the list of all pending RWHs (normally only one) to see if any of
   // their times have expired.
   for (size_t i = 0; i < shown_hosts_.size(); i++) {
     WidgetThumbnail* wt = GetDataForHost(shown_hosts_[i]);
     if (no_timeout_ || wt->last_shown <= threshold) {
       // This thumbnail has expired, delete it.
@@ skipping 12 matching lines @@
                  &ThumbnailGenerator::ShownDelayHandler);
   }
 }
 
 void ThumbnailGenerator::EraseHostFromShownList(RenderWidgetHost* widget) {
   std::vector<RenderWidgetHost*>::iterator found =
       std::find(shown_hosts_.begin(), shown_hosts_.end(), widget);
   if (found != shown_hosts_.end())
     shown_hosts_.erase(found);
 }