Mac tabpose: Add thumbnails

chrome/browser/cocoa/tabpose_window.mm

 // 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.
 
 #import "chrome/browser/cocoa/tabpose_window.h"
 
 #import <QuartzCore/QuartzCore.h>
 
 #include "app/resource_bundle.h"
 #include "base/mac_util.h"
+#include "base/scoped_callback_factory.h"
 #include "base/sys_string_conversions.h"
+#include "chrome/browser/browser_process.h"
 #import "chrome/browser/cocoa/browser_window_controller.h"
 #import "chrome/browser/cocoa/tab_strip_controller.h"
+#include "chrome/browser/renderer_host/backing_store_mac.h"
+#include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
+#include "chrome/browser/tab_contents/thumbnail_generator.h"
 #include "grit/app_resources.h"
 #include "skia/ext/skia_utils_mac.h"
+#include "third_party/skia/include/utils/mac/SkCGUtils.h"
 
 const int kTopGradientHeight  = 15;
 
 NSString* const kAnimationIdKey = @"AnimationId";
 NSString* const kAnimationIdFadeIn = @"FadeIn";
 NSString* const kAnimationIdFadeOut = @"FadeOut";
 
 const CGFloat kDefaultAnimationDuration = 0.25;  // In seconds.
 const CGFloat kSlomoFactor = 4;
 
 // CAGradientLayer is 10.6-only -- roll our own.
 @interface DarkGradientLayer : CALayer
 - (void)drawInContext:(CGContextRef)context;
 @end
 
 @implementation DarkGradientLayer
 - (void)drawInContext:(CGContextRef)context {
   scoped_cftyperef<CGColorSpaceRef> grayColorSpace(
       CGColorSpaceCreateWithName(kCGColorSpaceGenericGray));
   CGFloat grays[] = { 0.277, 1.0, 0.39, 1.0 };
   CGFloat locations[] = { 0, 1 };
   scoped_cftyperef<CGGradientRef> gradient(CGGradientCreateWithColorComponents(
       grayColorSpace.get(), grays, locations, arraysize(locations)));
   CGPoint topLeft = CGPointMake(0.0, kTopGradientHeight);
   CGContextDrawLinearGradient(context, gradient.get(), topLeft, CGPointZero, 0);
 }
 @end
 
+// FIXME: this needs to be cleaned up a lot
+
+// FIXME: look at URLFetcher's inner class for thread switching
+
+// FIMXE comment is wrong
+// A helper class used to interface with chrome's c++ code. Used to dispatch
+// stuff to threads; to listen for things; etc.
+class TabposeHelper : public base::RefCountedThreadSafe<TabposeHelper> {
+ public:
+  TabposeHelper(/*TabposeWindow* window*/NSSize fullS)
+      : nsFullSize(fullS) /*window_(window)*//*, factory_(this)*/ , layer_(nil), factory_(this) {}
+
+  void LoadThumbnail(RenderWidgetHost* rwh, CALayer* layer2, const gfx::Size& s);
+ private:
+  friend class base::RefCountedThreadSafe<TabposeHelper>;
+  ~TabposeHelper() {}
+
+  void DidReceiveBitmap(const SkBitmap& bitmap) {
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+NSLog(@"receiving bitmap %d %d", bitmap.width(), bitmap.height());
+    // FIXME: too many conversions (SkCreateCGImageRef() actually shares memory,
+    // so it's not too bad)
+    cgimage.reset(SkCreateCGImageRef(bitmap));
+    layer_.contents = (id)cgimage.get();
+  }
+
+scoped_cftyperef<CGImageRef> cgimage;
+NSSize nsFullSize;
+  CALayer* layer_;
+  base::ScopedCallbackFactory<TabposeHelper> factory_;
+};
+
+void TabposeHelper::LoadThumbnail(RenderWidgetHost* rwh, CALayer* layer2, const 
+gfx::Size& s) {
+  gfx::Size fullSize(NSSizeToCGSize(nsFullSize));
+
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+
+  // Don't need to go on IO thread, as this just sends an IPC anyway
+  // (and ScopedCallbackFactory isn't threadsafe :-P)
+  ThumbnailGenerator* generator = g_browser_process->GetThumbnailGenerator();
+
+  // FIXME: Internally, this allocs memory for both transport dib and then
+  // an SkBitmap (which _then_ needs to be converted to a CGImageRef).
+  // Reduce the amount of copying; possibly by sidestepping
+  // ThumbnailGenerator.
+  CHECK(!layer_);
+  layer_ = layer2;
+
+  // |fullSize| is slightly larger (view bounds doesn't include scroll bars?)
+  gfx::Size page_size(fullSize);  // Logical size the renderer renders at
+
+  // This is a bit tricky: We really only need a bitmap at size |s|, but when
+  // the user clicks a thumbnail and it zooms large, this single thumbnail
+  // should have a pixel size close to the view bounds, so that the image doesnt
+  // get blurry. One possible idea would be to get all thumbs at size |s| and
+  // request the one currently below the mouse at full size, but then it might
+  // not be ready when the click happens. For now, KISS, and request everything
+  // at the full resolution.
+  // FIXME: even better plan: call model->selectTab before starting the bg animation.
+  // that makes sure the target tab has a backing store. then call setNeedsDisplay on the
+  // layer, and it'll be redrawn from the backing store -- and all bg thumbs can stay small.
+  // yay! (is this true?) => no :-/, it takes too long for the backing store to load.
+  //gfx::Size desired_size(s);  // physical pixel size the image is rendered at
+  gfx::Size desired_size(fullSize);  // physical pixel size the image is rendered at
+NSLog(@"scheduling snapshot request");
+
+  // FIXME: check that observer is currently NULL
+  // FIXME: set observer back to NULL at some point
+  rwh->set_painting_observer(generator);
+  generator->AskForSnapshot(rwh, /*prefer_backing_store=*/false,
+                            factory_.NewCallback(&TabposeHelper::DidReceiveBitmap),
+                            page_size, desired_size);
+}
+
+
+
+// A CALayer that draws a CGLayerRef (or a CGBitmap).
+@interface BackingStoreLayer : CALayer {
+  TabContents* contents_;  // should really have a tabpose::Tile*?
+  NSSize smallSize;
+  NSSize fullSize;
+  scoped_refptr<TabposeHelper> helper_;
+  BOOL didSendLoad_;
+}
+- (id)initWithTabContents:(TabContents*)contents smallSize:(NSSize)s fullSize:(NSSize)s2;
+- (void)drawInContext:(CGContextRef)context;
+@end
+
+@implementation BackingStoreLayer
+- (id)initWithTabContents:(TabContents*)contents smallSize:(NSSize)s fullSize:(NSSize)s2 {
+  CHECK(contents);
+  if ((self = [super init])) {
+    contents_ = contents;
+    smallSize = s;
+    fullSize = s2;
+  }
+  return self;
+}
+
+- (void)drawInContext:(CGContextRef)context {
+  RenderWidgetHost* rwh = contents_->render_view_host();
+  BackingStoreMac* backing_store_ = (BackingStoreMac*)rwh->GetBackingStore(false);
+  if (!backing_store_) {
+    // Either the tab was never visible, or its backing store got evicted.
+
+NSLog(@"drawing layer without backingstore %d %@", didSendLoad_, self.contents);
+    // do this only if we haven't already sent a thumbnail request before
+    // else this is done on hide and way too much in general
+    if (!didSendLoad_) {
+      helper_ = new TabposeHelper(NSSizeFromCGSize(NSSizeToCGSize(fullSize)));
+      helper_->LoadThumbnail(rwh, self, gfx::Size(NSSizeToCGSize(smallSize)));
+      didSendLoad_ = YES;
+
+      // Overwrites |contents|, so do this only once, to fill with bg color.
+      [super drawInContext:context];
+    }
+
+    if ([self contents]) {
+      CGContextDrawImage(context, [self bounds], (CGImageRef)[self contents]);
+    }
+
+    return;
+  }
+
+  // TODO(thakis): re-send PaintAt ipc when tabstripmodelobserver informs us
+  // that a tab has changed (reload favicon & title, too)
+
+  // TODO(thakis): backing store might have wrong size (?)
+
+  // TODO(thakis): composited tabs might not be rendered correctly by this
+  // (once this is in BWC, let it add a sublayer for all IOSurfaces)
+
+  // TODO(thakis): Draw only into rect not occupied by info bars, detached
+  // bookmarks bar, devtool
+  if (backing_store_->cg_layer()) {
+    CGContextDrawLayerInRect(context, [self bounds],
+                             backing_store_->cg_layer());
+  } else {
+NSLog(@"no layer!");
+    scoped_cftyperef<CGImageRef> image(
+        CGBitmapContextCreateImage(backing_store_->cg_bitmap()));
+    CGContextDrawImage(context, [self bounds], image);
+  }
+}
+@end
+
+
+
 namespace {
 
 class ScopedCAActionDisabler {
  public:
   ScopedCAActionDisabler() {
     [CATransaction begin];
     [CATransaction setValue:[NSNumber numberWithBool:YES]
                      forKey:kCATransactionDisableActions];
   }
 
@@ skipping 71 matching lines @@
   // 2. loads that font
   // 3. calls |set_font_metrics()| which updates the title rect
   // 4. receives the title rect and puts the title on it with the font from 2.
   void set_font_metrics(CGFloat ascender, CGFloat descender);
   CGFloat title_font_size() const { return title_font_size_; }
 
   NSRect title_rect() const { return title_rect_; }
 
   // Returns an unelided title. The view logic is responsible for eliding.
   const string16& title() const { return contents_->GetTitle(); }
+
+  TabContents* tab_contents() const { return contents_; }
  private:
   friend class TileSet;
 
   // The thumb rect includes infobars, detached thumbnail bar, web contents,
   // and devtools.
   NSRect thumb_rect_;
   NSRect start_thumb_rect_;
 
   NSRect favicon_rect_;
 
@@ skipping 30 matching lines @@
     // Move favicon down.
     favicon_rect_.origin.y = title_rect_.origin.y + descender;
   } else {
     // Move title down.
     title_rect_.origin.y = favicon_rect_.origin.y - descender;
   }
 }
 
 // A tileset is responsible for owning and laying out all |Tile|s shown in a
 // tabpose window.
-class TileSet {
+class TileSet : public TabStripModelObserver {
  public:
+  virtual ~TileSet() { source_model_->RemoveObserver(this); }  // FIXME: crashes if Build() wasn't called.
   // Fills in |tiles_|.
   void Build(TabStripModel* source_model);
 
   // Computes coordinates for |tiles_|.
   void Layout(NSRect containing_rect);
 
   int selected_index() const { return selected_index_; }
   void set_selected_index(int index);
   void ResetSelectedIndex() { selected_index_ = initial_index_; }
 
   const Tile& selected_tile() const { return *tiles_[selected_index()]; }
   Tile& tile_at(int index) { return *tiles_[index]; }
   const Tile& tile_at(int index) const { return *tiles_[index]; }
 
+  // TabStripModelObserver
+  virtual void TabInsertedAt(TabContents* contents,
+                             int index,
+                             bool foreground) { CHECK(false); }
+  virtual void TabClosingAt(TabContents* contents, int index) { CHECK(false); }
+  virtual void TabDetachedAt(TabContents* contents, int index) { CHECK(false); }
+  virtual void TabMoved(TabContents* contents,
+                        int from_index,
+                        int to_index) { CHECK(false); }
+  virtual void TabStripModelDeleted() { CHECK(false); }
+  virtual void TabChangedAt(TabContents* contents, int index,
+                            TabChangeType change_type) {
+    // FIXME: update tile with |contents|, reload title, favicon, thumb
+    // depending on |change_type|.
+  }
+
  private:
   ScopedVector<Tile> tiles_;
 
   int selected_index_;
   int initial_index_;
+
+  TabStripModel* source_model_;
 };
 
 void TileSet::Build(TabStripModel* source_model) {
   selected_index_ = initial_index_ = source_model->selected_index();
   tiles_.resize(source_model->count());
   for (size_t i = 0; i < tiles_.size(); ++i) {
     tiles_[i] = new Tile;
     tiles_[i]->contents_ = source_model->GetTabContentsAt(i);
   }
+
+  source_model->AddObserver(this);
+  source_model_ = source_model;
 }
 
 void TileSet::Layout(NSRect containing_rect) {
   int tile_count = tiles_.size();
 
   // Room around the tiles insde of |containing_rect|.
   const int kSmallPaddingTop = 30;
   const int kSmallPaddingLeft = 30;
   const int kSmallPaddingRight = 30;
   const int kSmallPaddingBottom = 30;
@@ skipping 246 matching lines @@
   const tabpose::Tile& tile = tileSet_->tile_at(newIndex);
   selectionHighlight_.frame =
       NSRectToCGRect(NSInsetRect(tile.thumb_rect(), -5, -5));
 
   tileSet_->set_selected_index(newIndex);
 }
 
 - (void)setUpLayers:(NSRect)bgLayerRect slomo:(BOOL)slomo {
   // Root layer -- covers whole window.
   rootLayer_ = [CALayer layer];
-  [[self contentView] setLayer:rootLayer_];
-  [[self contentView] setWantsLayer:YES];
 
-  // Background layer -- the visible part of the window.
-  gray_.reset(CGColorCreateGenericGray(0.39, 1.0));
-  bgLayer_ = [CALayer layer];
-  bgLayer_.backgroundColor = gray_;
-  bgLayer_.frame = NSRectToCGRect(bgLayerRect);
-  bgLayer_.masksToBounds = YES;
-  [rootLayer_ addSublayer:bgLayer_];
+  // In a block so that the layers don't fade in.
+  {
+    ScopedCAActionDisabler disabler;
+    // Background layer -- the visible part of the window.
+    gray_.reset(CGColorCreateGenericGray(0.39, 1.0));
+    bgLayer_ = [CALayer layer];
+    bgLayer_.backgroundColor = gray_;
+    bgLayer_.frame = NSRectToCGRect(bgLayerRect);
+    bgLayer_.masksToBounds = YES;
+    [rootLayer_ addSublayer:bgLayer_];
 
-  // Selection highlight layer.
-  darkBlue_.reset(CGColorCreateGenericRGB(0.25, 0.34, 0.86, 1.0));
-  selectionHighlight_ = [CALayer layer];
-  selectionHighlight_.backgroundColor = darkBlue_;
-  selectionHighlight_.cornerRadius = 5.0;
-  selectionHighlight_.zPosition = -1;  // Behind other layers.
-  selectionHighlight_.hidden = YES;
-  [bgLayer_ addSublayer:selectionHighlight_];
+    // Selection highlight layer.
+    darkBlue_.reset(CGColorCreateGenericRGB(0.25, 0.34, 0.86, 1.0));
+    selectionHighlight_ = [CALayer layer];
+    selectionHighlight_.backgroundColor = darkBlue_;
+    selectionHighlight_.cornerRadius = 5.0;
+    selectionHighlight_.zPosition = -1;  // Behind other layers.
+    selectionHighlight_.hidden = YES;
+    [bgLayer_ addSublayer:selectionHighlight_];
 
-  // Top gradient.
-  CALayer* gradientLayer = [DarkGradientLayer layer];
-  gradientLayer.frame = CGRectMake(
-      0,
-      NSHeight(bgLayerRect) - kTopGradientHeight,
-      NSWidth(bgLayerRect),
-      kTopGradientHeight);
-  [gradientLayer setNeedsDisplay];  // Draw once.
-  [bgLayer_ addSublayer:gradientLayer];
-
+    // Top gradient.
+    CALayer* gradientLayer = [DarkGradientLayer layer];
+    gradientLayer.frame = CGRectMake(
+        0,
+        NSHeight(bgLayerRect) - kTopGradientHeight,
+        NSWidth(bgLayerRect),
+        kTopGradientHeight);
+    [gradientLayer setNeedsDisplay];  // Draw once.
+    [bgLayer_ addSublayer:gradientLayer];
+  }
   // Layers for the tab thumbnails.
   tileSet_->Build(tabStripModel_);
   tileSet_->Layout(bgLayerRect);
 
   NSImage* defaultFavIcon = ResourceBundle::GetSharedInstance().GetNSImageNamed(
       IDR_DEFAULT_FAVICON);
 
   allThumbnailLayers_.reset(
       [[NSMutableArray alloc] initWithCapacity:tabStripModel_->count()]);
   allFaviconLayers_.reset(
       [[NSMutableArray alloc] initWithCapacity:tabStripModel_->count()]);
   allTitleLayers_.reset(
       [[NSMutableArray alloc] initWithCapacity:tabStripModel_->count()]);
   for (int i = 0; i < tabStripModel_->count(); ++i) {
     const tabpose::Tile& tile = tileSet_->tile_at(i);
-    CALayer* layer = [CALayer layer];
+
+
+// FIXME: BrowserWindowController should create this layer
+    CALayer* layer = [[[BackingStoreLayer alloc] initWithTabContents:tile.tab_contents() smallSize:tile.thumb_rect().size fullSize:tile.GetStartRectRelativeTo(tileSet_->selected_tile()).size] autorelease];
+    [layer setNeedsDisplay];
 
     // Background color as placeholder for now.
     layer.backgroundColor = CGColorGetConstantColor(kCGColorWhite);
 
     AnimateCALayerFrameFromTo(
         layer,
         tile.GetStartRectRelativeTo(tileSet_->selected_tile()),
         tile.thumb_rect(),
         kDefaultAnimationDuration * (slomo ? kSlomoFactor : 1),
         i == tileSet_->selected_index() ? self : nil);
@@ skipping 37 matching lines @@
     titleLayer.string = base::SysUTF16ToNSString(tile.title());
     titleLayer.fontSize = [font pointSize];
     titleLayer.truncationMode = kCATruncationEnd;
     titleLayer.font = font;
     titleLayer.zPosition = 1;  // On top of the thumb shadow.
     titleLayer.hidden = YES;
     [bgLayer_ addSublayer:titleLayer];
     [allTitleLayers_ addObject:titleLayer];
   }
   [self selectTileAtIndex:tileSet_->selected_index()];
+
+  // Needs to happen after all layers have been added to |rootLayer_|, else
+  // there's a one frame flash of grey at the beginning of the animation
+  // (|bgLayer_| showing through with none of its children visible yet).
+  [[self contentView] setLayer:rootLayer_];
+  [[self contentView] setWantsLayer:YES];
 }
 
 - (BOOL)canBecomeKeyWindow {
  return YES;
 }
 
 - (void)keyDown:(NSEvent*)event {
   // Overridden to prevent beeps.
 }
 
@@ skipping 81 matching lines @@
     for (CALayer* layer in allTitleLayers_.get())
       layer.hidden = YES;
 
     // Running animations with shadows is slow, so turn shadows off before
     // running the exit animation.
     for (CALayer* layer in allThumbnailLayers_.get())
       layer.shadowOpacity = 0.0;
   }
 
   // Animate layers out, all in one transaction.
-  CGFloat duration = kDefaultAnimationDuration * (slomo ? kSlomoFactor : 1);
+  CGFloat duration = 2 * kDefaultAnimationDuration * (slomo ? kSlomoFactor : 1);
   ScopedCAActionSetDuration durationSetter(duration);
   for (NSUInteger i = 0; i < [allThumbnailLayers_ count]; ++i) {
     CALayer* layer = [allThumbnailLayers_ objectAtIndex:i];
     // |start_thumb_rect_| was relative to |initial_index_|, now this needs to
     // be relative to |selectedIndex_| (whose start rect was relative to
     // |initial_index_| too)
     CGRect newFrame = NSRectToCGRect(
         tileSet_->tile_at(i).GetStartRectRelativeTo(tileSet_->selected_tile()));
 
     // Add a delegate to one of the implicit animations to get a notification
     // once the animations are done.
     if (static_cast<int>(i) == tileSet_->selected_index()) {
       CAAnimation* animation = [CAAnimation animation];
       animation.delegate = self;
       [animation setValue:kAnimationIdFadeOut forKey:kAnimationIdKey];
       [layer addAnimation:animation forKey:@"frame"];
     }
 
     layer.frame = newFrame;
+
+    if (static_cast<int>(i) == tileSet_->selected_index()) {
+      // FIXME: only do this if the layer has a backing store (?)
+      [layer setNeedsDisplay];  // Redraw layer at big resolution, so that zoom-in isn't blocky.
+    }
   }
 }
 
 - (void)animationDidStop:(CAAnimation*)animation finished:(BOOL)finished {
   NSString* animationId = [animation valueForKey:kAnimationIdKey];
   if ([animationId isEqualToString:kAnimationIdFadeIn]) {
     if (finished) {
       // If the user clicks while the fade in animation is still running,
       // |state_| is already kFadingOut. In that case, don't do anything.
       DCHECK_EQ(tabpose::kFadingIn, state_);
@@ skipping 11 matching lines @@
       for (CALayer* layer in allThumbnailLayers_.get())
         layer.shadowOpacity = 0.5;
     }
   } else if ([animationId isEqualToString:kAnimationIdFadeOut]) {
     DCHECK_EQ(tabpose::kFadingOut, state_);
     [self close];
   }
 }
 
 @end