Support in-browser thumbnailing on Windows XP.

chrome/browser/tab_contents/thumbnail_generator.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 "chrome/browser/tab_contents/thumbnail_generator.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 14 matching lines @@
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "googleurl/src/gurl.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/skbitmap_operations.h"
 
+#if defined(OS_WIN)
+#include "base/win/windows_version.h"
+#endif
+
 // Overview
 // --------
 // This class provides current thumbnails for tabs. The simplest operation is
 // when a request for a thumbnail comes in, to grab the backing store and make
 // a smaller version of that. Clients of the class can send such a request by
 // AskForSnapshot().
 //
 // The class also provides a service for updating thumbnails to be used in
 // "Most visited" section of the new tab page. The service can be started
 // by StartThumbnailing(). The current algorithm of the service is as
@@ skipping 387 matching lines @@
     }
   }
 
   SkBitmap clipped_bitmap;
   bitmap.extractSubset(&clipped_bitmap, src_rect);
   return clipped_bitmap;
 }
 
 void ThumbnailGenerator::UpdateThumbnailIfNecessary(
     WebContents* web_contents) {
-  content::RenderWidgetHostView* view = web_contents->GetRenderWidgetHostView();
-  if (!view)
-    return;
-  bool surface_available = view->IsSurfaceAvailableForCopy();
-  // Skip if we can't update the thumbnail.
-  if (!surface_available)
-    return;
   // Skip if a pending entry exists. WidgetHidden can be called while navigaing
   // pages and this is not a timing when thumbnails should be generated.
   if (web_contents->GetController().GetPendingEntry())
     return;
   const GURL& url = web_contents->GetURL();
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   history::TopSites* top_sites = profile->GetTopSites();
   // Skip if we don't need to update the thumbnail.
   if (!ShouldUpdateThumbnail(profile, top_sites, url))
@@ skipping 29 matching lines @@
   VLOG(1) << "Thumbnail taken for " << url << ": " << score.ToString();
 }
 
 void ThumbnailGenerator::AsyncUpdateThumbnail(
     WebContents* web_contents) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   RenderWidgetHost* render_widget_host = web_contents->GetRenderViewHost();
   content::RenderWidgetHostView* view = render_widget_host->GetView();
   if (!view)
     return;
+  const bool surface_available = view->IsSurfaceAvailableForCopy();

[brettw, 2012/07/12 19:20:26]

I don't usually use "const" for local vars like this. Except in special cases, I
feel like it's extra clutter and doesn't really add anything. Same with "size"
below.

[mazda, 2012/07/12 21:23:25]

Done for |size|.
I deleted |surface_available| instead as this does not seem to improve
readability.

+  if (!surface_available) {
+#if defined(OS_WIN)
+    // On Windows XP, neither the backing store nor the compositing surface is
+    // available in the browser when accelerated compositing is active, so ask
+    // the renderer to send a snapshot for creating the thumbnail.
+    if (base::win::GetVersion() < base::win::VERSION_VISTA) {
+      web_contents_weak_factory_.reset(

[brettw, 2012/07/12 19:20:26]

This pattern is a bit unusual. If possible, I think it would be clearer to have
the weak factory be a regular member and just call InvalidateWeakPtrs() when you
want to cancel the out-standing requests.

[mazda, 2012/07/12 21:23:25]

I changed the code to initialize |web_contents_weak_factory_| in
StartThumbnailing not to reset it every time AsyncUpdateThumbnail is called.
the weak factory is invalidated when the web contents is disconnected.
This subtly changes the behavior of the thumbnailer in that it will allow
multiple requests to be made before the precedented request completes, but there
should be no problem.

+          new base::WeakPtrFactory<WebContents>(web_contents));
+      const gfx::Size view_size =
+          render_widget_host->GetView()->GetViewBounds().size();
+      AskForSnapshot(render_widget_host,
+                     base::Bind(&ThumbnailGenerator::UpdateThumbnailWithBitmap,
+                                weak_factory_.GetWeakPtr(),
+                                web_contents_weak_factory_->GetWeakPtr()),
+                     view_size,
+                     view_size);
+    }
+#endif
+    return;
+  }
 
   const gfx::Size copy_size =
       GetCopySizeForThumbnail(view->GetViewBounds().size(),
                               gfx::Size(kThumbnailWidth, kThumbnailHeight));
   skia::PlatformCanvas* temp_canvas = new skia::PlatformCanvas;
   web_contents_weak_factory_.reset(
       new base::WeakPtrFactory<WebContents>(web_contents));
   render_widget_host->CopyFromBackingStore(
       gfx::Rect(), copy_size, temp_canvas,
-      base::Bind(&ThumbnailGenerator::AsyncUpdateThumbnailFinish,
+      base::Bind(&ThumbnailGenerator::UpdateThumbnailWithCanvas,
                  weak_factory_.GetWeakPtr(),
                  web_contents_weak_factory_->GetWeakPtr(),
                  base::Owned(temp_canvas)));
 }
 
-void ThumbnailGenerator::AsyncUpdateThumbnailFinish(
+void ThumbnailGenerator::UpdateThumbnailWithBitmap(
+    base::WeakPtr<WebContents> web_contents,
+    const SkBitmap& bitmap) {
+  if (!web_contents.get())
+    return;
+
+  if (bitmap.isNull() || bitmap.empty())
+    return;
+
+  ClipResult clip_result;
+  SkBitmap thumbnail = CreateThumbnail(bitmap,
+                                       kThumbnailWidth,
+                                       kThumbnailHeight,
+                                       ThumbnailGenerator::kClippedThumbnail,
+                                       &clip_result);
+  UpdateThumbnail(web_contents.get(), thumbnail, clip_result);
+}
+
+void ThumbnailGenerator::UpdateThumbnailWithCanvas(
     base::WeakPtr<WebContents> web_contents,
     skia::PlatformCanvas* temp_canvas,
     bool succeeded) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   // The weak pointer can be invalidated by the subsequent AsyncUpdateThumbnail.
   if (!web_contents.get())
     return;
 
   if (!succeeded)
     return;
 
   SkBitmap bmp_with_scrollbars =
       skia::GetTopDevice(*temp_canvas)->accessBitmap(false);
-  ClipResult clip_result;
-  SkBitmap thumbnail = CreateThumbnail(bmp_with_scrollbars,
-                                       kThumbnailWidth,
-                                       kThumbnailHeight,
-                                       ThumbnailGenerator::kClippedThumbnail,
-                                       &clip_result);
-  UpdateThumbnail(web_contents.get(), thumbnail, clip_result);
+  UpdateThumbnailWithBitmap(web_contents, bmp_with_scrollbars);
 }
 
 bool ThumbnailGenerator::ShouldUpdateThumbnail(Profile* profile,
                                                history::TopSites* top_sites,
                                                const GURL& url) {
   if (!profile || !top_sites)
     return false;
   // Skip if it's in the incognito mode.
   if (profile->IsOffTheRecord())
     return false;
@@ skipping 20 matching lines @@
 
 void ThumbnailGenerator::DidStartLoading() {
   load_interrupted_ = false;
 }
 
 void ThumbnailGenerator::StopNavigation() {
   // This function gets called when the page loading is interrupted by the
   // stop button.
   load_interrupted_ = true;
 }