Make thumbnails closable in tabpose

chrome/browser/ui/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/ui/cocoa/tabpose_window.h"
 
 #import <QuartzCore/QuartzCore.h>
 
+#include <algorithm>
+
 #include "app/resource_bundle.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/scoped_callback_factory.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_process.h"
 #import "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/backing_store_mac.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_widget_host_view_mac.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/thumbnail_generator.h"
 #import "chrome/browser/ui/cocoa/bookmarks/bookmark_bar_constants.h"
 #import "chrome/browser/ui/cocoa/browser_window_controller.h"
 #import "chrome/browser/ui/cocoa/tab_strip_controller.h"
 #import "chrome/browser/ui/cocoa/tab_strip_model_observer_bridge.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/pref_names.h"
 #include "gfx/scoped_cg_context_state_mac.h"
 #include "grit/app_resources.h"
+#include "grit/theme_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;
-const CGFloat kObserverChangeAnimationDuration = 0.75;  // In seconds.
+const CGFloat kObserverChangeAnimationDuration = 0.25;  // In seconds.
+const CGFloat kSelectionInset = 5;
 
 // CAGradientLayer is 10.6-only -- roll our own.
 @interface DarkGradientLayer : CALayer
 - (void)drawInContext:(CGContextRef)context;
 @end
 
 @implementation DarkGradientLayer
 - (void)drawInContext:(CGContextRef)context {
   base::mac::ScopedCFTypeRef<CGColorSpaceRef> grayColorSpace(
       CGColorSpaceCreateWithName(kCGColorSpaceGenericGray));
@@ skipping 642 matching lines @@
           kTitleHeight);
 
       // Compute the big, pre-zoom thumbnail rect.
       tiles_[i]->start_thumb_rect_.size = containing_rect.size;
 
       int big_x = col * (NSWidth(containing_rect) + big_padding_x);
       int big_y = row * (NSHeight(containing_rect) + big_padding_y);
       tiles_[i]->start_thumb_rect_.origin = NSMakePoint(big_x, -big_y);
     }
   }
-
-  // Go through last row and center it:
-  // X X X X
-  // X X X X
-  //   X X
-  int last_row_empty_tiles_x = count_x() - last_row_count_x();
-  CGFloat small_last_row_shift_x =
-      last_row_empty_tiles_x * (small_width + kSmallPaddingX) / 2;
-  CGFloat big_last_row_shift_x =
-      last_row_empty_tiles_x * (NSWidth(containing_rect) + big_padding_x) / 2;
-  for (int i = tile_count - last_row_count_x(); i < tile_count; ++i) {
-    tiles_[i]->thumb_rect_.origin.x += small_last_row_shift_x;
-    tiles_[i]->start_thumb_rect_.origin.x += big_last_row_shift_x;
-    tiles_[i]->favicon_rect_.origin.x += small_last_row_shift_x;
-    tiles_[i]->title_rect_.origin.x += small_last_row_shift_x;
-  }
 }
 
 void TileSet::set_selected_index(int index) {
   CHECK_GE(index, 0);
   CHECK_LT(index, static_cast<int>(tiles_.size()));
   selected_index_ = index;
 }
 
 // Given a |value| in [0, from_scale), map it into [0, to_scale) such that:
 // * [0, from_scale) ends up in the middle of [0, to_scale) if the latter is
@@ skipping 176 matching lines @@
   layer.opacity = to;
   // Add the animation, overriding the implicit animation.
   [layer addAnimation:animation forKey:@"opacity"];
 }
 
 @interface TabposeWindow (Private)
 - (id)initForWindow:(NSWindow*)parent
                rect:(NSRect)rect
               slomo:(BOOL)slomo
       tabStripModel:(TabStripModel*)tabStripModel;
+
+// Creates and initializes the CALayer in the background and all the CALayers
+// for the thumbnails, favicons, and titles.
 - (void)setUpLayersInSlomo:(BOOL)slomo;
-- (void)fadeAway:(BOOL)slomo;
-- (void)selectTileAtIndex:(int)newIndex;
+
+// Tells the browser to make the tab corresponding to currently selected
+// thumbnail the current tab and starts the tabpose exit animmation.
+- (void)fadeAwayInSlomo:(BOOL)slomo;
+
+// Returns the CALayer for the close button belonging to the thumbnail at
+// index |index|.
+- (CALayer*)closebuttonLayerAtIndex:(NSUInteger)index;
+
+// Updates the visibility of all closebutton layers.
+- (void)updateClosebuttonLayersVisibility;
 @end
 
 @implementation TabposeWindow
 
 + (id)openTabposeFor:(NSWindow*)parent
                 rect:(NSRect)rect
                slomo:(BOOL)slomo
        tabStripModel:(TabStripModel*)tabStripModel {
   // Releases itself when closed.
   return [[TabposeWindow alloc]
       initForWindow:parent rect:rect slomo:slomo tabStripModel:tabStripModel];
 }
 
 - (id)initForWindow:(NSWindow*)parent
                rect:(NSRect)rect
               slomo:(BOOL)slomo
       tabStripModel:(TabStripModel*)tabStripModel {
   NSRect frame = [parent frame];
   if ((self = [super initWithContentRect:frame
                                styleMask:NSBorderlessWindowMask
                                  backing:NSBackingStoreBuffered
                                    defer:NO])) {
     containingRect_ = rect;
     tabStripModel_ = tabStripModel;
     state_ = tabpose::kFadingIn;
     tileSet_.reset(new tabpose::TileSet);
     tabStripModelObserverBridge_.reset(
         new TabStripModelObserverBridge(tabStripModel_, self));
+    NSImage* nsCloseIcon =
+        ResourceBundle::GetSharedInstance().GetNativeImageNamed(
+            IDR_TABPOSE_CLOSE);
+    closeIcon_.reset(base::mac::CopyNSImageToCGImage(nsCloseIcon));
     [self setReleasedWhenClosed:YES];
     [self setOpaque:NO];
     [self setBackgroundColor:[NSColor clearColor]];
     [self setUpLayersInSlomo:slomo];
     [self setAcceptsMouseMovedEvents:YES];
     [parent addChildWindow:self ordered:NSWindowAbove];
     [self makeKeyAndOrderFront:self];
   }
   return self;
 }
 
 - (CALayer*)selectedLayer {
   return [allThumbnailLayers_ objectAtIndex:tileSet_->selected_index()];
 }
 
-- (void)selectTileAtIndex:(int)newIndex {
-  const tabpose::Tile& tile = tileSet_->tile_at(newIndex);
-  selectionHighlight_.frame =
-      NSRectToCGRect(NSInsetRect(tile.thumb_rect(), -5, -5));
-  tileSet_->set_selected_index(newIndex);
-}
-
 - (void)selectTileAtIndexWithoutAnimation:(int)newIndex {
   ScopedCAActionDisabler disabler;
-  [self selectTileAtIndex:newIndex];
+  const tabpose::Tile& tile = tileSet_->tile_at(newIndex);
+  selectionHighlight_.frame =
+      NSRectToCGRect(NSInsetRect(tile.thumb_rect(),
+                     -kSelectionInset, -kSelectionInset));
+  tileSet_->set_selected_index(newIndex);
+
+  [self updateClosebuttonLayersVisibility];
 }
 
 - (void)addLayersForTile:(tabpose::Tile&)tile
                 showZoom:(BOOL)showZoom
                    slomo:(BOOL)slomo
        animationDelegate:(id)animationDelegate {
   scoped_nsobject<CALayer> layer([[ThumbnailLayer alloc]
       initWithTabContents:tile.tab_contents()
                  fullSize:tile.GetStartRectRelativeTo(
                      tileSet_->selected_tile()).size]);
@@ skipping 13 matching lines @@
         animationDelegate);
   } else {
     layer.get().frame = NSRectToCGRect(tile.thumb_rect());
   }
 
   layer.get().shadowRadius = 10;
   layer.get().shadowOffset = CGSizeMake(0, -10);
   if (state_ == tabpose::kFadedIn)
     layer.get().shadowOpacity = 0.5;
 
+  // Add a close button to the thumb layer.
+  CALayer* closeLayer = [CALayer layer];
+  closeLayer.contents = reinterpret_cast<id>(closeIcon_.get());
+  CGRect closeBounds = {};
+  closeBounds.size.width = CGImageGetWidth(closeIcon_);
+  closeBounds.size.height = CGImageGetHeight(closeIcon_);
+  closeLayer.bounds = closeBounds;
+  closeLayer.hidden = YES;
+
+  [closeLayer addConstraint:
+      [CAConstraint constraintWithAttribute:kCAConstraintMidX
+                                 relativeTo:@"superlayer"
+                                  attribute:kCAConstraintMinX]];
+  [closeLayer addConstraint:
+      [CAConstraint constraintWithAttribute:kCAConstraintMidY
+                                 relativeTo:@"superlayer"
+                                  attribute:kCAConstraintMaxY]];
+
+  layer.get().layoutManager = [CAConstraintLayoutManager layoutManager];
+  [layer.get() addSublayer:closeLayer];
+
   [bgLayer_ addSublayer:layer];
   [allThumbnailLayers_ addObject:layer];
 
   // Favicon and title.
   NSFont* font = [NSFont systemFontOfSize:tile.title_font_size()];
   tile.set_font_metrics([font ascender], -[font descender]);
 
   NSImage* nsFavicon = gfx::SkBitmapToNSImage(tile.favicon());
   // Either we don't have a valid favicon or there was some issue converting
   // it from an SkBitmap. Either way, just show the default.
@@ skipping 176 matching lines @@
   NSString* characters = [event characters];
   if ([characters length] < 1)
     return;
 
   unichar character = [characters characterAtIndex:0];
   switch (character) {
     case NSEnterCharacter:
     case NSNewlineCharacter:
     case NSCarriageReturnCharacter:
     case ' ':
-      [self fadeAway:([event modifierFlags] & NSShiftKeyMask) != 0];
+      [self fadeAwayInSlomo:([event modifierFlags] & NSShiftKeyMask) != 0];
       break;
     case '\e':  // Escape
       tileSet_->set_selected_index(tabStripModel_->selected_index());
-      [self fadeAway:([event modifierFlags] & NSShiftKeyMask) != 0];
+      [self fadeAwayInSlomo:([event modifierFlags] & NSShiftKeyMask) != 0];
       break;
   }
 }
 
 // Handle keyboard events that contain cmd or ctrl.
 - (BOOL)performKeyEquivalent:(NSEvent*)event {
   if (state_ == tabpose::kFadingOut)
     return NO;
   NSString* characters = [event characters];
   if ([characters length] < 1)
     return NO;
   unichar character = [characters characterAtIndex:0];
   if ([event modifierFlags] & NSCommandKeyMask) {
     if (character >= '1' && character <= '9') {
       int index =
           character == '9' ? tabStripModel_->count() - 1 : character - '1';
       if (index < tabStripModel_->count()) {
         tileSet_->set_selected_index(index);
-        [self fadeAway:([event modifierFlags] & NSShiftKeyMask) != 0];
+        [self fadeAwayInSlomo:([event modifierFlags] & NSShiftKeyMask) != 0];
         return YES;
       }
     }
   }
   return NO;
 }
 
--(void)selectTileFromMouseEvent:(NSEvent*)event {
+- (void)flagsChanged:(NSEvent*)event {
+  showAllCloseLayers_ = ([event modifierFlags] & NSAlternateKeyMask) != 0;
+  [self updateClosebuttonLayersVisibility];
+}
+
+- (void)selectTileFromMouseEvent:(NSEvent*)event {
   int newIndex = -1;
   CGPoint p = NSPointToCGPoint([event locationInWindow]);
   for (NSUInteger i = 0; i < [allThumbnailLayers_ count]; ++i) {
     CALayer* layer = [allThumbnailLayers_ objectAtIndex:i];
     CGPoint lp = [layer convertPoint:p fromLayer:rootLayer_];
     if ([static_cast<CALayer*>([layer presentationLayer]) containsPoint:lp])
       newIndex = i;
   }
   if (newIndex >= 0)
     [self selectTileAtIndexWithoutAnimation:newIndex];
 }
 
 - (void)mouseMoved:(NSEvent*)event {
   [self selectTileFromMouseEvent:event];
 }
 
+- (CALayer*)closebuttonLayerAtIndex:(NSUInteger)index {
+  CALayer* layer = [allThumbnailLayers_ objectAtIndex:index];
+  return [[layer sublayers] objectAtIndex:0];
+}
+
+- (void)updateClosebuttonLayersVisibility {
+  for (NSUInteger i = 0; i < [allThumbnailLayers_ count]; ++i) {
+    CALayer* layer = [self closebuttonLayerAtIndex:i];
+    BOOL isSelectedTile = static_cast<int>(i) == tileSet_->selected_index();
+    BOOL isVisible = state_ == tabpose::kFadedIn &&
+                     (isSelectedTile || showAllCloseLayers_);
+    layer.hidden = !isVisible;
+  }
+}
+
 - (void)mouseDown:(NSEvent*)event {
   // Just in case the user clicked without ever moving the mouse.
   [self selectTileFromMouseEvent:event];
 
-  [self fadeAway:([event modifierFlags] & NSShiftKeyMask) != 0];
+  // If the click occurred in a close box, close that tab and don't do anything
+  // else.
+  CGPoint p = NSPointToCGPoint([event locationInWindow]);
+  for (NSUInteger i = 0; i < [allThumbnailLayers_ count]; ++i) {
+    CALayer* layer = [self closebuttonLayerAtIndex:i];
+    CGPoint lp = [layer convertPoint:p fromLayer:rootLayer_];
+    if ([static_cast<CALayer*>([layer presentationLayer]) containsPoint:lp] &&
+        !layer.hidden) {
+      tabStripModel_->CloseTabContentsAt(i,
+          TabStripModel::CLOSE_USER_GESTURE |
+          TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
+      return;
+    }
+  }
+
+  [self fadeAwayInSlomo:([event modifierFlags] & NSShiftKeyMask) != 0];
 }
 
 - (void)swipeWithEvent:(NSEvent*)event {
   if (abs([event deltaY]) > 0.5)  // Swipe up or down.
-    [self fadeAway:([event modifierFlags] & NSShiftKeyMask) != 0];
+    [self fadeAwayInSlomo:([event modifierFlags] & NSShiftKeyMask) != 0];
 }
 
 - (void)close {
   // Prevent parent window from disappearing.
   [[self parentWindow] removeChildWindow:self];
 
   // We're dealloc'd in an autorelease pool – by then the observer registry
   // might be dead, so explicitly reset the observer now.
   tabStripModelObserverBridge_.reset();
 
   [super close];
 }
 
 - (void)commandDispatch:(id)sender {
   if ([sender tag] == IDC_TABPOSE)
-    [self fadeAway:NO];
+    [self fadeAwayInSlomo:NO];
 }
 
 - (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item {
   // Disable all browser-related menu items except the tab overview toggle.
   SEL action = [item action];
   NSInteger tag = [item tag];
   return action == @selector(commandDispatch:) && tag == IDC_TABPOSE;
 }
 
 - (void)fadeAwayTileAtIndex:(int)index {
@@ skipping 35 matching lines @@
   titleToRect.origin.x +=
       NSWidth(titleRect) * scale * titleLayer.anchorPoint.x;
   titleToRect.origin.y +=
       NSHeight(titleRect) * scale * titleLayer.anchorPoint.y;
   titleLayer.position = NSPointToCGPoint(titleToRect.origin);
   [titleLayer setValue:[NSNumber numberWithDouble:scale]
             forKeyPath:@"transform.scale"];
   titleLayer.opacity = 0;
 }
 
-- (void)fadeAway:(BOOL)slomo {
+- (void)fadeAwayInSlomo:(BOOL)slomo {
   if (state_ == tabpose::kFadingOut)
     return;
 
   state_ = tabpose::kFadingOut;
   [self setAcceptsMouseMovedEvents:NO];
 
   // Select chosen tab.
   if (tileSet_->selected_index() < tabStripModel_->count()) {
     tabStripModel_->SelectTabContentsAt(tileSet_->selected_index(),
                                         /*user_gesture=*/true);
   } else {
     DCHECK_EQ(tileSet_->selected_index(), 0);
   }
 
   {
     ScopedCAActionDisabler disableCAActions;
 
     // Move the selected layer on top of all other layers.
     [self selectedLayer].zPosition = 1;
 
     selectionHighlight_.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;
+
+    [self updateClosebuttonLayersVisibility];
   }
 
   // Animate layers out, all in one transaction.
   CGFloat duration =
       1.3 * kDefaultAnimationDuration * (slomo ? kSlomoFactor : 1);
   ScopedCAActionSetDuration durationSetter(duration);
   for (int i = 0; i < tabStripModel_->count(); ++i)
     [self fadeAwayTileAtIndex:i];
 }
 
 - (void)animationDidStop:(CAAnimation*)animation finished:(BOOL)finished {
   NSString* animationId = [animation valueForKey:kAnimationIdKey];
   if ([animationId isEqualToString:kAnimationIdFadeIn]) {
     if (finished && state_ == tabpose::kFadingIn) {
       // If the user clicks while the fade in animation is still running,
       // |state_| is already kFadingOut. In that case, don't do anything.
       state_ = tabpose::kFadedIn;
 
       selectionHighlight_.hidden = NO;
 
       // Running animations with shadows is slow, so turn shadows on only after
       // the animation is done.
       ScopedCAActionDisabler disableCAActions;
       for (CALayer* layer in allThumbnailLayers_.get())
         layer.shadowOpacity = 0.5;
+
+      [self updateClosebuttonLayersVisibility];
     }
   } else if ([animationId isEqualToString:kAnimationIdFadeOut]) {
     DCHECK_EQ(tabpose::kFadingOut, state_);
     [self close];
   }
 }
 
 - (NSUInteger)thumbnailLayerCount {
   return [allThumbnailLayers_ count];
 }
 
 - (int)selectedIndex {
   return tileSet_->selected_index();
 }
 
 #pragma mark TabStripModelBridge
 
 - (void)refreshLayerFramesAtIndex:(int)i {
   const tabpose::Tile& tile = tileSet_->tile_at(i);
 
+  CALayer* thumbLayer = [allThumbnailLayers_ objectAtIndex:i];
+
+  if (i == tileSet_->selected_index()) {
+    AnimateCALayerFrameFromTo(
+        selectionHighlight_,
+        NSInsetRect(NSRectFromCGRect(thumbLayer.frame),
+                    -kSelectionInset, -kSelectionInset),
+        NSInsetRect(tile.thumb_rect(),
+                    -kSelectionInset, -kSelectionInset),
+        kObserverChangeAnimationDuration,
+        nil);
+  }
+
+  // Repaint layer if necessary.
+  if (!NSEqualSizes(NSRectFromCGRect(thumbLayer.frame).size,
+                    tile.thumb_rect().size)) {
+    [thumbLayer setNeedsDisplay];
+  }
+
+  // Use AnimateCALayerFrameFromTo() instead of just setting |frame| to let
+  // the animation match the selection animation --
+  // |kCAMediaTimingFunctionDefault| is 10.6-only.
+  AnimateCALayerFrameFromTo(
+      thumbLayer,
+      NSRectFromCGRect(thumbLayer.frame),
+      tile.thumb_rect(),
+      kObserverChangeAnimationDuration,
+      nil);
+
   CALayer* faviconLayer = [allFaviconLayers_ objectAtIndex:i];
-  faviconLayer.frame = NSRectToCGRect(tile.favicon_rect());
+  AnimateCALayerFrameFromTo(
+      faviconLayer,
+      NSRectFromCGRect(faviconLayer.frame),
+      tile.favicon_rect(),
+      kObserverChangeAnimationDuration,
+      nil);
+
   CALayer* titleLayer = [allTitleLayers_ objectAtIndex:i];
-  titleLayer.frame = NSRectToCGRect(tile.title_rect());
-  CALayer* thumbLayer = [allThumbnailLayers_ objectAtIndex:i];
-  thumbLayer.frame = NSRectToCGRect(tile.thumb_rect());
+  AnimateCALayerFrameFromTo(
+      titleLayer,
+      NSRectFromCGRect(titleLayer.frame),
+      tile.title_rect(),
+      kObserverChangeAnimationDuration,
+      nil);
 }
 
 - (void)insertTabWithContents:(TabContentsWrapper*)contents
                       atIndex:(NSInteger)index
                  inForeground:(bool)inForeground {
   // This happens if you cmd-click a link and then immediately open tabpose
   // on a slowish machine.
   ScopedCAActionSetDuration durationSetter(kObserverChangeAnimationDuration);
 
   // Insert new layer and relayout.
   tileSet_->InsertTileAt(index, contents->tab_contents());
   tileSet_->Layout(containingRect_);
   [self  addLayersForTile:tileSet_->tile_at(index)
                  showZoom:NO
                     slomo:NO
         animationDelegate:nil];
 
   // Update old layers.
   DCHECK_EQ(tabStripModel_->count(),
             static_cast<int>([allThumbnailLayers_ count]));
   DCHECK_EQ(tabStripModel_->count(),
             static_cast<int>([allTitleLayers_ count]));
   DCHECK_EQ(tabStripModel_->count(),
             static_cast<int>([allFaviconLayers_ count]));
 
+  // Update selection.
+  int selectedIndex = tileSet_->selected_index();
+  if (selectedIndex >= index)
+    selectedIndex++;
+  [self selectTileAtIndexWithoutAnimation:selectedIndex];
+
+  // Animate everything into its new place.
   for (int i = 0; i < tabStripModel_->count(); ++i) {
     if (i == index)  // The new layer.
       continue;
     [self refreshLayerFramesAtIndex:i];
   }
-
-  // Update selection.
-  int selectedIndex = tileSet_->selected_index();
-  if (selectedIndex >= index)
-    selectedIndex++;
-  [self selectTileAtIndex:selectedIndex];
 }
 
 - (void)tabClosingWithContents:(TabContentsWrapper*)contents
                        atIndex:(NSInteger)index {
   // We will also get a -tabDetachedWithContents:atIndex: notification for
   // closing tabs, so do nothing here.
 }
 
 - (void)tabDetachedWithContents:(TabContentsWrapper*)contents
                         atIndex:(NSInteger)index {
   ScopedCAActionSetDuration durationSetter(kObserverChangeAnimationDuration);
 
   // Remove layer and relayout.
   tileSet_->RemoveTileAt(index);
   tileSet_->Layout(containingRect_);
 
-  [[allThumbnailLayers_ objectAtIndex:index] removeFromSuperlayer];
-  [allThumbnailLayers_ removeObjectAtIndex:index];
-  [[allTitleLayers_ objectAtIndex:index] removeFromSuperlayer];
-  [allTitleLayers_ removeObjectAtIndex:index];
-  [[allFaviconLayers_ objectAtIndex:index] removeFromSuperlayer];
-  [allFaviconLayers_ removeObjectAtIndex:index];
+  {
+    ScopedCAActionDisabler disabler;
+    [[allThumbnailLayers_ objectAtIndex:index] removeFromSuperlayer];
+    [allThumbnailLayers_ removeObjectAtIndex:index];
+    [[allTitleLayers_ objectAtIndex:index] removeFromSuperlayer];
+    [allTitleLayers_ removeObjectAtIndex:index];
+    [[allFaviconLayers_ objectAtIndex:index] removeFromSuperlayer];
+    [allFaviconLayers_ removeObjectAtIndex:index];
+  }
 
   // Update old layers.
   DCHECK_EQ(tabStripModel_->count(),
             static_cast<int>([allThumbnailLayers_ count]));
   DCHECK_EQ(tabStripModel_->count(),
             static_cast<int>([allTitleLayers_ count]));
   DCHECK_EQ(tabStripModel_->count(),
             static_cast<int>([allFaviconLayers_ count]));
 
   if (tabStripModel_->count() == 0)
     [self close];
 
+  // Update selection.
+  int selectedIndex = tileSet_->selected_index();
+  if (selectedIndex > index || selectedIndex >= tabStripModel_->count())
+    selectedIndex--;
+  if (selectedIndex >= 0)
+    [self selectTileAtIndexWithoutAnimation:selectedIndex];
+
+  // Animate everything into its new place.
   for (int i = 0; i < tabStripModel_->count(); ++i)
     [self refreshLayerFramesAtIndex:i];
-
-  // Update selection.
-  int selectedIndex = tileSet_->selected_index();
-  if (selectedIndex >= index)
-    selectedIndex--;
-  if (selectedIndex >= 0)
-    [self selectTileAtIndex:selectedIndex];
 }
 
 - (void)tabMovedWithContents:(TabContentsWrapper*)contents
                     fromIndex:(NSInteger)from
                       toIndex:(NSInteger)to {
   ScopedCAActionSetDuration durationSetter(kObserverChangeAnimationDuration);
 
   // Move tile from |from| to |to|.
   tileSet_->MoveTileFromTo(from, to);
 
   // Move corresponding layers from |from| to |to|.
   scoped_nsobject<CALayer> thumbLayer(
       [[allThumbnailLayers_ objectAtIndex:from] retain]);
   [allThumbnailLayers_ removeObjectAtIndex:from];
   [allThumbnailLayers_ insertObject:thumbLayer.get() atIndex:to];
   scoped_nsobject<CALayer> faviconLayer(
       [[allFaviconLayers_ objectAtIndex:from] retain]);
   [allFaviconLayers_ removeObjectAtIndex:from];
   [allFaviconLayers_ insertObject:faviconLayer.get() atIndex:to];
   scoped_nsobject<CALayer> titleLayer(
       [[allTitleLayers_ objectAtIndex:from] retain]);
   [allTitleLayers_ removeObjectAtIndex:from];
   [allTitleLayers_ insertObject:titleLayer.get() atIndex:to];
 
-  // Update frames of the layers.
-  for (int i = std::min(from, to); i <= std::max(from, to); ++i)
-    [self refreshLayerFramesAtIndex:i];
-
   // Update selection.
   int selectedIndex = tileSet_->selected_index();
   if (from == selectedIndex)
     selectedIndex = to;
   else if (from < selectedIndex && selectedIndex <= to)
     selectedIndex--;
   else if (to <= selectedIndex && selectedIndex < from)
     selectedIndex++;
-  [self selectTileAtIndex:selectedIndex];
+  [self selectTileAtIndexWithoutAnimation:selectedIndex];
+
+  // Update frames of the layers.
+  for (int i = std::min(from, to); i <= std::max(from, to); ++i)
+    [self refreshLayerFramesAtIndex:i];
 }
 
 - (void)tabChangedWithContents:(TabContentsWrapper*)contents
                        atIndex:(NSInteger)index
                     changeType:(TabStripModelObserver::TabChangeType)change {
   // Tell the window to update text, title, and thumb layers at |index| to get
   // their data from |contents|. |contents| can be different from the old
   // contents at that index!
   // While a tab is loading, this is unfortunately called quite often for
   // both the "loading" and the "all" change types, so we don't really want to
@@ skipping 11 matching lines @@
   tile.set_tab_contents(contents->tab_contents());
   ThumbnailLayer* thumbLayer = [allThumbnailLayers_ objectAtIndex:index];
   [thumbLayer setTabContents:contents->tab_contents()];
 }
 
 - (void)tabStripModelDeleted {
   [self close];
 }
 
 @end