Generate thumbnails in the browser process.

chrome/browser/tab_contents/thumbnail_generator.h

 // Copyright (c) 2010 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.
 
 #ifndef CHROME_BROWSER_TAB_CONTENTS_THUMBNAIL_GENERATOR_H_
 #define CHROME_BROWSER_TAB_CONTENTS_THUMBNAIL_GENERATOR_H_
 #pragma once
 
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/linked_ptr.h"
 #include "base/lock.h"
 #include "base/timer.h"
 #include "chrome/browser/renderer_host/backing_store.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 
 class RenderWidgetHost;
 class SkBitmap;
 class TabContents;
 
 class ThumbnailGenerator : NotificationObserver {
  public:
   typedef Callback1<const SkBitmap&>::Type ThumbnailReadyCallback;
+  // The result of clipping. This can be used to determine if the
+  // generated thumbnail is good or not.
+  enum ClipResult {
+    // The source image is smaller.
+    kSourceIsSmaller,
+    // Wider than tall, clip horizontally.
+    kWiderThanTall,
+    // Taller than wide, clip vertically.
+    kTallerThanWide,
+    // The source and destination aspect ratios are identical.
+    kNotClipped,
+  };
+
+  // Bitmasks of options for generating a thumbnail.
+  enum ThumbnailOptions {
+    // No options.
+    kNone = 0,

[brettw, 2011/01/21 00:09:17]

Can you rename this to kNoOptions (or something similar) so it's more unique?

[satorux1, 2011/01/21 04:53:43]

Done.

+    // Request a clipped thumbnail with the aspect ratio preserved.
+    kClippedThumbnail = 1 << 0,
+  };
+
   // This class will do nothing until you call StartThumbnailing.
   ThumbnailGenerator();
   ~ThumbnailGenerator();
 
   // Ensures that we're properly hooked in to generated thumbnails. This can
   // be called repeatedly and with wild abandon to no ill effect.
   void StartThumbnailing();
 
   // This registers a callback that can receive the resulting SkBitmap
   // from the renderer when it is done rendering it.  This differs
@@ skipping 15 matching lines @@
   void AskForSnapshot(RenderWidgetHost* renderer,
                       bool prefer_backing_store,
                       ThumbnailReadyCallback* callback,
                       gfx::Size page_size,
                       gfx::Size desired_size);
 
   // This returns a thumbnail of a fixed, small size for the given
   // renderer.
   SkBitmap GetThumbnailForRenderer(RenderWidgetHost* renderer) const;
 
+  // This returns a thumbnail of a fixed, small size for the given
+  // renderer. |options| is a bitmask of ThumbnailOptions. If
+  // |clip_result| is non-NULL, the result of clipping will be written.
+  SkBitmap GetThumbnailForRendererWithOptions(RenderWidgetHost* renderer,
+                                              int options,
+                                              ClipResult* clip_result) const;
+
   // Start or stop monitoring notifications for |renderer| based on the value
   // of |monitor|.
   void MonitorRenderer(RenderWidgetHost* renderer, bool monitor);
 
 #ifdef UNIT_TEST
   // When true, the class will not use a timeout to do the expiration. This
   // will cause expiration to happen on the next run of the message loop.
   // Unit tests case use this to test expiration by choosing when the message
   // loop runs.
   void set_no_timeout(bool no_timeout) { no_timeout_ = no_timeout; }
 #endif
 
+  // Calculates how "boring" a thumbnail is. The boring score is the
+  // 0,1 ranged percentage of pixels that are the most common
+  // luma. Higher boring scores indicate that a higher percentage of a
+  // bitmap are all the same brightness.
+  static double CalculateBoringScore(SkBitmap* bitmap);

[brettw, 2011/01/21 00:09:17]

Moving the thumbnail computation, you can remove this from the public section of
the header and put it as a static method in the .cc file (some people prefer a
const private function on this class, which is also OK if you like that better).

+
+  // Gets the clipped bitmap from |bitmap| per the aspect ratio of the
+  // desired width and the desired height. For instance, if the input
+  // bitmap is vertically long (ex. 400x900) and the desired size is
+  // square (ex. 100x100), the clipped bitmap will be the top half of the
+  // input bitmap (400x400).
+  static SkBitmap GetClippedBitmap(const SkBitmap& bitmap,
+                                   int desired_width,
+                                   int desired_height,
+                                   ClipResult* clip_result);
  private:
   // RenderWidgetHostPaintingObserver implementation.
   virtual void WidgetWillDestroyBackingStore(RenderWidgetHost* widget,
                                              BackingStore* backing_store);
   virtual void WidgetDidUpdateBackingStore(RenderWidgetHost* widget);
 
   virtual void WidgetDidReceivePaintAtSizeAck(
       RenderWidgetHost* widget,
       int tag,
       const gfx::Size& size);
@@ skipping 36 matching lines @@
   // Map of callback objects by sequence number.
   struct AsyncRequestInfo;
   typedef std::map<int,
                    linked_ptr<AsyncRequestInfo> > ThumbnailCallbackMap;
   ThumbnailCallbackMap callback_map_;
 
   DISALLOW_COPY_AND_ASSIGN(ThumbnailGenerator);
 };
 
 #endif  // CHROME_BROWSER_TAB_CONTENTS_THUMBNAIL_GENERATOR_H_