Upstream Chrome on iOS source code [8/11].

ios/chrome/browser/ui/stack_view/stack_view_controller.mm

+// Copyright 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.
+
+#import "ios/chrome/browser/ui/stack_view/stack_view_controller.h"
+
+#import <QuartzCore/QuartzCore.h>
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+#include "base/format_macros.h"
+#import "base/ios/block_types.h"
+#import "base/ios/weak_nsobject.h"
+#include "base/logging.h"
+#import "base/mac/bundle_locations.h"
+#import "base/mac/foundation_util.h"
+#import "base/mac/objc_property_releaser.h"
+#include "base/mac/scoped_block.h"
+#import "base/mac/scoped_nsobject.h"
+#include "base/metrics/histogram.h"
+#include "base/metrics/user_metrics.h"
+#include "base/metrics/user_metrics_action.h"
+#include "base/strings/sys_string_conversions.h"
+#include "ios/chrome/browser/chrome_url_constants.h"
+#include "ios/chrome/browser/experimental_flags.h"
+#import "ios/chrome/browser/tabs/tab.h"
+#import "ios/chrome/browser/tabs/tab_model.h"
+#import "ios/chrome/browser/tabs/tab_model_observer.h"
+#import "ios/chrome/browser/ui/animation_util.h"
+#import "ios/chrome/browser/ui/background_generator.h"
+#import "ios/chrome/browser/ui/commands/UIKit+ChromeExecuteCommand.h"
+#import "ios/chrome/browser/ui/commands/generic_chrome_command.h"
+#include "ios/chrome/browser/ui/commands/ios_command_ids.h"
+#import "ios/chrome/browser/ui/keyboard/UIKeyCommand+Chrome.h"
+#import "ios/chrome/browser/ui/ntp/new_tab_page_toolbar_controller.h"
+#import "ios/chrome/browser/ui/reversed_animation.h"
+#import "ios/chrome/browser/ui/rtl_geometry.h"
+#import "ios/chrome/browser/ui/stack_view/card_stack_layout_manager.h"
+#import "ios/chrome/browser/ui/stack_view/card_stack_pinch_gesture_recognizer.h"
+#import "ios/chrome/browser/ui/stack_view/card_view.h"
+#import "ios/chrome/browser/ui/stack_view/close_button.h"
+#import "ios/chrome/browser/ui/stack_view/page_animation_util.h"
+#import "ios/chrome/browser/ui/stack_view/stack_card.h"
+#import "ios/chrome/browser/ui/stack_view/stack_view_controller_private.h"
+#import "ios/chrome/browser/ui/stack_view/stack_view_toolbar_controller.h"
+#import "ios/chrome/browser/ui/stack_view/title_label.h"
+#import "ios/chrome/browser/ui/toolbar/new_tab_button.h"
+#import "ios/chrome/browser/ui/toolbar/toolbar_owner.h"
+#import "ios/chrome/browser/ui/tools_menu/tools_menu_context.h"
+#import "ios/chrome/browser/ui/tools_menu/tools_menu_view_item.h"
+#import "ios/chrome/browser/ui/ui_util.h"
+#import "ios/chrome/browser/ui/uikit_ui_util.h"
+#import "ios/chrome/common/material_timing.h"
+#include "ios/chrome/grit/ios_strings.h"
+#include "ios/web/public/referrer.h"
+#import "net/base/mac/url_conversions.h"
+#include "ui/base/l10n/l10n_util.h"
+
+using base::UserMetricsAction;
+
+// To obtain scroll behavior, places the card stacks' display views within a
+// UIScrollView container. The container is used only as a driver of scroll
+// events. To avoid the finite size of the container from impacting scrolling,
+// (1) the container is made large enough that it cannot be scrolled to a
+// boundary point without the user having first fully scrolled the card stack
+// in that direction, and (2) after scroll events, the container's scroll
+// offset is recentered if necessary.
+
+namespace {
+// The fraction of the display to use for the active deck if both decks are
+// being displayed.
+const CGFloat kActiveDeckDisplayFraction = 0.85;
+// Animation durations.
+const NSTimeInterval kCascadingCardCloseDelay = 0.1;
+const NSTimeInterval kDefaultAnimationDuration = 0.25;
+// The length of the animation that eliminates overextension after a
+// scroll/pinch.
+const NSTimeInterval kOverextensionEliminationAnimationDuration = .4;
+// Fraction of the screen that must be swiped for a stack to switch or a card
+// to dismiss.
+const CGFloat kSwipeCardScreenFraction = 0.35;
+// The velocity (in points / millisecond) below which a scroll's deceleration
+// will be killed once the stack is overscrolled. Determined by experimentation
+// to see what resulted in a good feel.
+const CGFloat kMinFlingVelocityInOverscroll = 0.3;
+// The velocity (in points / millisecond) at/above which a scroll will be
+// treated as a fling even if it is not for the purposes of determining
+// overscroll behavior. Used to handle the corner case where the user flings
+// the cards toward the start stack, but at the moment that the scrolled card
+// would become overscrolled, the finger is still registered as tracking. Has
+// the tradeoff that if user is legimately scrolling above this velocity near
+// the start stack, the card will not track the user's finger. Value determined
+// by experimentation to see what resulted in a good handling of this tradeoff.
+const CGFloat kThresholdVelocityForTreatingScrollAsFling = 1.0;
+// The factor by which scroll velocity is decayed once a fling becomes
+// overscrolled.
+const CGFloat kDecayFactorInBounce = .75;
+// The duration (in seconds) that the user must press on a card before
+// beginning an ambiguous swipe (i.e., a swipe that could result in either
+// dismissing the card or changing decks) for that swipe to trigger card
+// dismissal instead of changing decks.
+const CGFloat kPressDurationForAmbiguousSwipeToTriggerDismissal = .2;
+// The vertical overlap between the scroll view and the toolbar (chosen to match
+// aspect ratio of snapshotted webview).
+const CGFloat kVerticalToolbarOverlap = 0.0;
+// The delay into the dismissal transition animation at which to update the
+// status bar.  The value was provided by UX, and corresponds to approximately
+// when the selected card's frame image crosses the status bar in the animation.
+const NSTimeInterval kDismissalStatusBarUpdateDelay = 0.15;
+// When choosing the size of the cards, ensure that the bottom of the card
+// is at most |kCardBottomPadding| from the bottom of the scroll view.
+const CGFloat kCardBottomPadding = 29.0;
+// Animation key used for the dummy toolbar background view animation.
+NSString* const kDummyToolbarBackgroundViewAnimationKey =
+    @"DummyToolbarBackgroundViewAnimationKey";
+}  // anonymous namespace
+
+// Container for the state associated with gesture-related events.
+@interface GestureStateTracker : NSObject
+
+@property(nonatomic, assign) NSUInteger scrollCardIndex;
+@property(nonatomic, assign) CGFloat previousScrollOffset;
+@property(nonatomic, assign) base::TimeTicks previousScrollTime;
+// The current scroll velocity, in points / millisecond.
+@property(nonatomic, readonly) CGFloat scrollVelocity;
+@property(nonatomic, assign) BOOL resetScrollCardOnNextDrag;
+@property(nonatomic, assign) NSUInteger firstPinchCardIndex;
+@property(nonatomic, assign) NSUInteger secondPinchCardIndex;
+@property(nonatomic, assign) CGFloat previousFirstPinchOffset;
+@property(nonatomic, assign) CGFloat previousSecondPinchOffset;
+// YES when a pinch gesture is currently being recognized.
+@property(nonatomic, assign) BOOL pinching;
+// YES when a 1-fingered pinch gesture is being interpreted by
+// StackViewController's |handlePinchFrom:| as a scroll.
+@property(nonatomic, assign) BOOL scrollingInPinch;
+// Swipe gesture starting position. In portrait, this is the x position of the
+// beginning touch. In landscape this is the y position.
+@property(nonatomic, assign) CGFloat swipeStartingPosition;
+// If YES, a swipe gesture is interpreted as being a swipe to change decks.
+// Otherwise, a swipe gesture is interpreted as being a swipe to close a card.
+@property(nonatomic, assign) BOOL swipeChangesDecks;
+// The index of the card being swiped. Undefined if |swipeChangesDecks| is YES.
+@property(nonatomic, assign) NSUInteger swipedCardIndex;
+@property(nonatomic, assign) BOOL resetSwipedCardOnNextSwipe;
+@property(nonatomic, assign) BOOL swipeIsBeginning;
+// Whether a swipe whose intent is ambiguous should change decks (as opposed to
+// dismiss a card). Relevant only when multiple stacks are present.
+@property(nonatomic, assign) BOOL ambiguousSwipeChangesDecks;
+
+// Given |distance|, which should be the distance scrolled since
+// |previousScrollTime|, updates |scrollVelocity|.
+- (void)updateScrollVelocityWithScrollDistance:(CGFloat)distance;
+
+@end
+
+@implementation GestureStateTracker
+
+@synthesize ambiguousSwipeChangesDecks = _ambiguousSwipeChangesDecks;
+@synthesize firstPinchCardIndex = _firstPinchCardIndex;
+@synthesize pinching = _pinching;
+@synthesize previousFirstPinchOffset = _previousFirstPinchOffset;
+@synthesize previousScrollOffset = _previousScrollOffset;
+@synthesize previousScrollTime = _previousScrollTime;
+@synthesize previousSecondPinchOffset = _previousSecondPinchOffset;
+@synthesize resetScrollCardOnNextDrag = _resetScrollCardOnNextDrag;
+@synthesize resetSwipedCardOnNextSwipe = _resetSwipedCardOnNextSwipe;
+@synthesize scrollCardIndex = _scrollCardIndex;
+@synthesize scrollingInPinch = _scrollingInPinch;
+@synthesize scrollVelocity = _scrollVelocity;
+@synthesize secondPinchCardIndex = _secondPinchCardIndex;
+@synthesize swipeChangesDecks = _swipeChangesDecks;
+@synthesize swipedCardIndex = _swipedCardIndex;
+@synthesize swipeIsBeginning = _swipeIsBeginning;
+@synthesize swipeStartingPosition = _swipeStartingPosition;
+
+- (instancetype)init {
+  if ((self = [super init])) {
+    _resetScrollCardOnNextDrag = YES;
+  }
+  return self;
+}
+
+- (void)updateScrollVelocityWithScrollDistance:(CGFloat)distance {
+  base::TimeDelta elapsedTime = base::TimeTicks::Now() - _previousScrollTime;
+  if (elapsedTime == base::TimeDelta::FromMicroseconds(0))
+    return;
+  _scrollVelocity =
+      fabs(distance / CGFloat(elapsedTime.InMillisecondsRoundedUp()));
+}
+
+@end
+
+@interface StackViewController (Private)
+
+// Clears the internal state of the object. Should only be called when the
+// object is not being shown. After this method is called, a call to
+// |restoreInternalState| must be made before the object is reshown.
+- (void)clearInternalState;
+// Updates the layout parameters of the scroll view and the display views based
+// on the viewport size. Should be called any time that the viewport size is
+// changed.
+- (void)viewportSizeWasChanged;
+// Configures the scroll view to be large enough so that the user could not
+// scroll to one of its boundaries without also having reached the
+// corresponding boundary of the stack being scrolled.
+- (void)updateScrollViewContentSize;
+// Deregisters for the notifications |registerForNotifications| specifies.
+- (void)deregisterForNotifications;
+// Eliminates the ability for the user to perform any further interactions
+// with the stack view. Should be called when the stack view starts being
+// dismissed.
+- (void)prepareForDismissal;
+
+// Asynchronously adds the remaining cards to the display view to pre-load them.
+// This is safe to call multiple times.
+- (void)preloadCardViewsAsynchronously;
+// Adds the next not-yet-loaded card to the display view.
+- (void)preloadNextCardView;
+// Animates the removal of |cardView| from the superview, with the start of the
+// animation being delayed by |delay|. Performs |completion| on animation
+// finish (may be NULL). Card will dismiss clockwise when |clockwise| is YES and
+// counter-clockwise when |clockwise| is NO.
+- (void)animateOutCardView:(CardView*)cardView
+                     delay:(NSTimeInterval)delay
+                 clockwise:(BOOL)clockwise
+                completion:(ProceduralBlock)completion;
+// Removes all cards in |cardSet| from the underlying model and their superview.
+- (void)removeAllCardsFromSet:(CardSet*)cardSet;
+// Disable all the gesture handlers. Must be called before removing cards from
+// the active set.
+- (void)disableGestureHandlers;
+// Enable all the gesture handlers.
+- (void)enableGestureHandlers;
+// Should be called whenever the number of cards in the active set changes
+// (including the active set itself changing).
+- (void)activeCardCountChanged;
+// Computes and stores the initial card size information that will decide how
+// layout is done for the remainder of the stack view's lifetime, and configures
+// the card sets accordingly.
+- (void)setInitialCardSizing;
+// Updates the card sizing and layout for the current device orientation.
+// If |animates| is true, the size change will be animated, otherwise it will be
+// done synchronously.
+- (void)updateDeckOrientationWithAnimation:(BOOL)animates;
+// Updates the card sizing for the current deck states and device orientation.
+// If |animates| is true, the size change will be animated, otherwise it will be
+// done synchronously.
+- (void)updateCardSizesWithAnimation:(BOOL)animates;
+// Animates setting the opacity of the card tabs of the current deck to
+// |opacity|.
+- (void)animateActiveSetCardTabsToOpacity:(CGFloat)opacity
+                             withDuration:(CGFloat)duration
+                               completion:(ProceduralBlock)completion;
+// Updates the positions of the decks in the non-layout direction. Should be
+// called if the layout direction, card size, or active set changes.
+- (void)updateDeckAxisPositions;
+// Updates the positions of the decks in the non-layout direction and then
+// shifts them from the standard positions by |amount|.
+- (void)updateDeckAxisPositionsWithShiftAmount:(CGFloat)amount;
+// Updates the position of |cardSet| in the non-layout direction and then
+// shifts it from its standard position by |amount|.
+- (void)updateDeckAxisPositionForCardSet:(CardSet*)cardSet
+                         withShiftAmount:(CGFloat)shiftAmount;
+// The amount by which |cardSet| should be shifted from its default layout axis
+// position to be positioned offscreen.
+- (CGFloat)shiftOffscreenAmountForCardSet:(CardSet*)cardSet;
+// Refreshes the card display, using the current orientation. Should be called
+// any time the orientation has changed or the display views have been rebuilt.
+- (void)refreshCardDisplayWithAnimation:(BOOL)animates;
+// Updates the UI to reflect the current card set. Called automatically by
+// setActiveCardSet:, but also called during setup.
+- (void)displayActiveCardSet;
+// Switches to showing only the main card set, with no room for showing the
+// incognito set. Should be called when the last incognito card is closed.
+- (void)displayMainCardSetOnly;
+// Updates the appearance of the toolbar for the current state of the card
+// stack.
+- (void)updateToolbarAppearanceWithAnimation:(BOOL)animate;
+
+// Returns the size of a single card (at normal zoom).
+- (CGSize)cardSize;
+// Returns the size that should be used for cards being displayed in a viewport
+// with breadth |breadth|, taking margins into account and preserving the
+// content area aspect ratio.
+- (CGSize)cardSizeForBreadth:(CGFloat)breadth;
+// Returns the amount that |point| is offset on the current scroll axis.
+- (CGFloat)scrollOffsetAmountForPoint:(CGPoint)point;
+// Returns the amount that |position| is offset on the current scroll axis.
+- (CGFloat)scrollOffsetAmountForPosition:(LayoutRectPosition)position;
+// Returns the CGPoint offset |offset| in the current scroll direction, with
+// 0 as the other component of the point.
+- (CGPoint)scrollOffsetPointWithAmount:(CGFloat)offset;
+// Returns the length of |size| in the current scroll direction.
+- (CGFloat)scrollLength:(CGSize)size;
+// Returns the length of |size| in the non-scroll direction.
+- (CGFloat)scrollBreadth:(CGSize)size;
+// Returns a size for the current scroll direction with the given scroll length
+// and breadth.
+- (CGSize)sizeForScrollLength:(CGFloat)length breadth:(CGFloat)breadth;
+// Returns the index of the card that |point| is contained within, or
+// |NSNotFound| if |point| is not contained in any card. This is not an
+// efficient lookup, so this should *not* be called frequently.
+- (NSUInteger)indexOfCardAtPoint:(CGPoint)point;
+// Will reverse the current transition animations if the tab switcher button is
+// pressed before the animation can finish.
+- (void)cancelTransitionAnimation;
+// Called within the completion block for the transition animations.
+- (void)finishTransitionAnimation;
+// Called within the completion block for the transition animations.  Notifies
+// the delegates that the current transition has finished.
+- (void)notifyDelegatesTransitionFinished;
+// Sets up the view hierarchy for transitioning and calls the stack view and
+// toolbar animation selectors below, wrapping the animations in a single
+// CATransaction.  Use |transitionStyle| = StackTransitionStylePresenting for
+// presentation and |transitionStyle| = StackTransitionStyleDismissing for
+// dismissal.
+- (void)animateTransitionWithStyle:(StackTransitionStyle)transitionStyle;
+// Updates the view heirarchy for the transition based on the current transition
+// style.  If the style is STACK_TRANSITION_STYLE_PRESENTING or
+// STACK_TRANSITION_STYLE_DISMISSING, the display views are added to the root
+// view and the toolbar is inserted between them.  If the style is
+// STACK_TRANSITION_STYLE_NONE, the display views are reparented into the scroll
+// view and aligned to the view port.
+- (void)reorderSubviewsForTransition;
+// Animates the cards in |cardSet| from |beginLayouts| to |endLayouts| with the
+// transition style specified by |self.transitionStyle|.
+- (void)animateCardSet:(CardSet*)cardSet
+      fromBeginLayouts:(std::vector<LayoutRect>)beginLayouts
+          toEndLayouts:(std::vector<LayoutRect>)endLayouts;
+// Reverses the cancelled transition animations added to the card set.
+- (void)reverseTransitionAnimationsForCardSet:(CardSet*)cardSet;
+// Adds transition animations to the active card set.  If |self.transitionStyle|
+// = StackTransitionStylePresenting, this will fan out the cards in the active
+// set from the frames returned by |-cardTransitionFrames| to the fanned out
+// frames. If |transitionStyle| = StackTransitionStyleDismissing, the cards will
+// animate from their current frames to |-cardTransitionFrames|.
+- (void)animateActiveSetTransition;
+// Adds transition animations to the inactive set.  The inactive card set will
+// be laid out in the fanned frames and will animate in from offscreen if
+// |self.transitionStyle| = StackTransitionStylePresenting, and will animate off
+// the screen if |transitionStyle| = StackTransitionStyleDismissing.
+- (void)animateInactiveSetTransition;
+// Adds the dummy toolbar background to the active card set's current card and
+// animates alongside the toolbar, creating a cross-fade effect from the
+// toolbar's frame at the top of the screen to the tab portion of |cardFrame|
+// and vise versa.
+- (void)animateDummyToolbarForCardFrame:(CGRect)cardFrame
+                        transitionStyle:(StackTransitionStyle)transitionStyle;
+// Reverses the dummy toolbar background animations for cancelled transitions.
+- (void)reverseDummyToolbarBackgroundViewAnimation;
+// Adds the toolbar view owned by |transitionToolbarController| to the stack's
+// view hierarchy and animates the frame alongside the active card set's current
+// card (i.e. from its position at the top of the screen to the tab portion of
+// the provided |cardFrame| or vise versa).  The transition completion delegate
+// callbacks will reparent the toolbar view back into the BVC's view hiearchy.
+- (void)animateTransitionToolbarWithCardFrame:(CGRect)cardFrame
+                              transitionStyle:
+                                  (StackTransitionStyle)transitionStyle;
+// Returns an vector of LayoutRects corresponding to the active card set's
+// frames at the moment of switching to or from the stack view.  The cards below
+// the current card in the z axis will have top-aligned unscaled frames, the
+// current card will have a top-aligned frame scaled such that the web view
+// snapshot takes the entire screen below the toolbar, and cards above the the
+// current card will have the scaled frame translated offscreen.
+- (std::vector<LayoutRect>)cardTransitionLayouts;
+// Returns the index of what should be the first visible card in the initial
+// fanout of |cardSet|.
+- (NSUInteger)startIndexOfInitialFanoutForCardSet:(CardSet*)cardSet;
+// Perform the animation for switching out of the stack view while
+// simultaneously opening a tab with |url|, at |position| with the given
+// |transition|. The tab where |url| is opened is returned.
+- (Tab*)dismissWithNewTabAnimation:(const GURL&)url
+                           atIndex:(NSUInteger)position
+                        transition:(ui::PageTransition)transition;
+- (void)closeTab:(id)sender;
+- (void)handleLongPressFrom:(UIPinchGestureRecognizer*)recognizer;
+- (void)handlePinchFrom:(UIPinchGestureRecognizer*)recognizer;
+- (void)handleTapFrom:(UITapGestureRecognizer*)recognizer;
+// Returns the card corresponding to |view|. This is not an efficient lookup,
+// so this should *not* be called frequently.
+- (StackCard*)cardForView:(CardView*)view;
+// Shows the tools menu popup.
+- (void)showToolsMenuPopup;
+// All local tab state is cleared, and |currentlyClosingAllTabs_| is set to
+// |NO|.
+- (void)allModelTabsHaveClosed:(NSNotification*)notify;
+
+// Updates the display views so that they are aligned to the scroll view's
+// viewport. Should be called any time the scroll view's content offset
+// changes.
+- (void)alignDisplayViewsToViewport;
+
+// Handles swipe gestures between card sets and swipes to remove cards.
+- (void)handlePanFrom:(UIPanGestureRecognizer*)gesture;
+// Determines whether the current swipe should be treated as a swipe to dismiss
+// a card or a swipe to change decks.
+- (void)determineSwipeType:(UIPanGestureRecognizer*)gesture;
+// Returns the distance that a swipe needs to travel in order to trigger an
+// action (close card/change deck).
+- (CGFloat)distanceForSwipeToTriggerAction;
+// Returns |YES| if the current swipe should trigger an action (close
+// card/change deck) based on the swipe's ending position and its starting
+// position.
+- (BOOL)swipeShouldTriggerAction:(CGFloat)endingPosition;
+// Moves between card sets, potentially changing the active card set at the end
+// of the gesture.
+- (void)swipeDeck:(UIPanGestureRecognizer*)gesture;
+// Moves the card being swiped, potentially dismissing the card at the end of
+// the gesture.
+- (void)swipeCard:(UIPanGestureRecognizer*)gesture;
+
+// Returns whether the current scroll should be ended.
+- (BOOL)shouldEndScroll;
+// Performs any necessary cleanup actions after a scroll is completed.
+- (void)scrollEnded;
+// Performs any necessary cleanup actions after a pinch is completed.
+- (void)pinchEnded;
+// Animates overextension elimination from the active card set. Performs
+// |completion| on animation finish (may be |NULL|).
+- (void)animateOverextensionEliminationWithCompletion:
+    (ProceduralBlock)completion;
+// Cancels a scroll that is in its deceleration phase.
+// NOTE: Will not have the desired behavior if invoked on a scroll that is not
+// in the deceleration phase, i.e., the user is still dragging on the screen.
+- (void)killScrollDeceleration;
+// Adjusts the amount that the stack is allowed to overextend depending on
+// whether the current scroll is a fling.
+- (void)adjustMaximumOverextensionAmount:(BOOL)isFling;
+
+// Responds to voice over focusing on TitleLabel or CloseButton. If the element
+// label is covered, scroll it toward the start stack, or the next card toward
+// the end stack as appropriate. If the element is in the middle of a stack, fan
+// outcards from its card's index.
+- (void)accessibilityFocusedOnElement:(id)element;
+
+// Determine the center of |sender| if it's a view or a toolbar item and store.
+- (void)setLastTapPoint:(id)sender;
+
+@end
+
+@implementation StackViewController {
+  base::scoped_nsobject<UIScrollView> _scrollView;
+  // The view containing the stack view's background.
+  base::scoped_nsobject<UIView> _backgroundView;
+  // The main card set.
+  base::scoped_nsobject<CardSet> _mainCardSet;
+  // The off-the-record card set.
+  base::scoped_nsobject<CardSet> _otrCardSet;
+  // The currently active card set; one of _mainCardSet or _otrCardSet.
+  CardSet* _activeCardSet;                            // weak
+  id<TabSwitcherDelegate> _delegate;                  // weak
+  id<StackViewControllerTestDelegate> _testDelegate;  // weak
+  // Controller for the stack view toolbar.
+  base::scoped_nsobject<StackViewToolbarController> _toolbarController;
+  // The size of a card at the time the stack was first shown.
+  CGSize _initialCardSize;
+  // The previous orientation of the interface.
+  UIInterfaceOrientation _lastInterfaceOrientation;
+  // Gesture recognizer to catch taps on the inactive stack.
+  base::scoped_nsobject<UITapGestureRecognizer> _modeSwitchRecognizer;
+  // Gesture recognizer to catch pinches in the active scroll view.
+  base::scoped_nsobject<UIGestureRecognizer> _pinchRecognizer;
+  // Gesture recognizer to catch swipes to switch decks/dismiss cards.
+  base::scoped_nsobject<UIGestureRecognizer> _swipeGestureRecognizer;
+  // Gesture recognizer that determines whether an ambiguous swipe action
+  // (i.e., a swipe on an active card in the direction that would cause a deck
+  // change) should trigger a change of decks or a card dismissal.
+  base::scoped_nsobject<UILongPressGestureRecognizer>
+      _swipeDismissesCardRecognizer;
+  // Tracks the parameters of gesture-related events.
+  base::scoped_nsobject<GestureStateTracker> _gestureStateTracker;
+  // If |YES|, callbacks to |scrollViewDidScroll:| do not trigger scrolling.
+  // Default is |NO|.
+  BOOL _ignoreScrollCallbacks;
+  // The scroll view's pan gesture recognizer.
+  UIPanGestureRecognizer* _scrollGestureRecognizer;  // weak
+  // Because the removal of the StackCard during a swipe happens in a callback,
+  // track which direction the animation should dismiss with.
+  // |_reverseDismissCard| is only set when the dismissal happens in reverse.
+  base::scoped_nsobject<StackCard> _reverseDismissCard;
+  // |YES| if the stack view is in the process of being dismissed.
+  BOOL _isBeingDismissed;
+  // |YES| if the stack view is currently active.
+  BOOL _isActive;
+  // Records whether a memory warning occurred in the current session.
+  BOOL _receivedMemoryWarningInSession;
+  // |YES| if there is card set animation being processed. For testing only.
+  // Save last touch point used by new tab animation.
+  CGPoint _lastTapPoint;
+
+  base::mac::ObjCPropertyReleaser _propertyReleaserStackViewController;
+}
+
+@synthesize activeCardSet = _activeCardSet;
+@synthesize delegate = _delegate;
+@synthesize dummyToolbarBackgroundView = _dummyToolbarBackgroundView;
+@synthesize inActiveDeckChangeAnimation = _inActiveDeckChangeAnimation;
+@synthesize testDelegate = _testDelegate;
+@synthesize transitionStyle = _transitionStyle;
+@synthesize transitionTappedCard = _transitionTappedCard;
+@synthesize transitionToolbarController = _transitionToolbarController;
+@synthesize transitionToolbarFrame = _transitionToolbarFrame;
+@synthesize transitionToolbarOwner = _transitionToolbarOwner;
+@synthesize transitionWasCancelled = _transitionWasCancelled;
+
+- (instancetype)initWithMainCardSet:(CardSet*)mainCardSet
+                         otrCardSet:(CardSet*)otrCardSet
+                      activeCardSet:(CardSet*)activeCardSet {
+  DCHECK(mainCardSet);
+  DCHECK(otrCardSet);
+  DCHECK(activeCardSet == otrCardSet || activeCardSet == mainCardSet);
+  self = [super initWithNibName:nil bundle:nil];
+  if (self) {
+    _propertyReleaserStackViewController.Init(self,
+                                              [StackViewController class]);
+    [self setUpWithMainCardSet:mainCardSet
+                    otrCardSet:otrCardSet
+                 activeCardSet:activeCardSet];
+    _swipeDismissesCardRecognizer.reset([[UILongPressGestureRecognizer alloc]
+        initWithTarget:self
+                action:@selector(handleLongPressFrom:)]);
+    [_swipeDismissesCardRecognizer
+        setMinimumPressDuration:
+            kPressDurationForAmbiguousSwipeToTriggerDismissal];
+    [_swipeDismissesCardRecognizer setDelegate:self];
+    _pinchRecognizer.reset([[CardStackPinchGestureRecognizer alloc]
+        initWithTarget:self
+                action:@selector(handlePinchFrom:)]);
+    [_pinchRecognizer setDelegate:self];
+    _modeSwitchRecognizer.reset([[UITapGestureRecognizer alloc]
+        initWithTarget:self
+                action:@selector(handleTapFrom:)]);
+    [_modeSwitchRecognizer setDelegate:self];
+  }
+  return self;
+}
+
+- (instancetype)initWithMainTabModel:(TabModel*)mainModel
+                         otrTabModel:(TabModel*)otrModel
+                      activeTabModel:(TabModel*)activeModel {
+  DCHECK(mainModel);
+  DCHECK(otrModel);
+  DCHECK(activeModel == otrModel || activeModel == mainModel);
+  base::scoped_nsobject<CardSet> mainCardSet(
+      [[CardSet alloc] initWithModel:mainModel]);
+  base::scoped_nsobject<CardSet> otrCardSet(
+      [[CardSet alloc] initWithModel:otrModel]);
+  CardSet* activeCardSet =
+      (activeModel == mainModel) ? mainCardSet.get() : otrCardSet.get();
+  return [self initWithMainCardSet:mainCardSet
+                        otrCardSet:otrCardSet
+                     activeCardSet:activeCardSet];
+}
+
+- (instancetype)initWithNibName:(NSString*)nibNameOrNil
+                         bundle:(NSBundle*)nibBundleOrNil {
+  NOTREACHED();
+  return nil;
+}
+
+- (instancetype)initWithCoder:(NSCoder*)aDecoder {
+  NOTREACHED();
+  return nil;
+}
+
+- (void)setUpWithMainCardSet:(CardSet*)mainCardSet
+                  otrCardSet:(CardSet*)otrCardSet
+               activeCardSet:(CardSet*)activeCardSet {
+  _mainCardSet.reset([mainCardSet retain]);
+  _otrCardSet.reset([otrCardSet retain]);
+  if (experimental_flags::IsLRUSnapshotCacheEnabled()) {
+    [_mainCardSet setKeepOnlyVisibleCardViewsAlive:YES];
+    [_otrCardSet setKeepOnlyVisibleCardViewsAlive:YES];
+  }
+  _activeCardSet = (activeCardSet == mainCardSet) ? mainCardSet : otrCardSet;
+  _gestureStateTracker.reset([[GestureStateTracker alloc] init]);
+  _pinchRecognizer.reset([[CardStackPinchGestureRecognizer alloc]
+      initWithTarget:self
+              action:@selector(handlePinchFrom:)]);
+  [_pinchRecognizer setDelegate:self];
+  _modeSwitchRecognizer.reset([[UITapGestureRecognizer alloc]
+      initWithTarget:self
+              action:@selector(handleTapFrom:)]);
+  [_modeSwitchRecognizer setDelegate:self];
+}
+
+- (void)restoreInternalStateWithMainTabModel:(TabModel*)mainModel
+                                 otrTabModel:(TabModel*)otrModel
+                              activeTabModel:(TabModel*)activeModel {
+  DCHECK(mainModel);
+  DCHECK(otrModel);
+  DCHECK(activeModel == otrModel || activeModel == mainModel);
+  DCHECK(!_isActive);
+  base::scoped_nsobject<CardSet> mainCardSet(
+      [[CardSet alloc] initWithModel:mainModel]);
+  base::scoped_nsobject<CardSet> otrCardSet(
+      [[CardSet alloc] initWithModel:otrModel]);
+  CardSet* activeCardSet =
+      (activeModel == mainModel) ? mainCardSet.get() : otrCardSet.get();
+  [self setUpWithMainCardSet:mainCardSet
+                  otrCardSet:otrCardSet
+               activeCardSet:activeCardSet];
+
+  // If the view is not currently loaded, do not adjust its size or add
+  // gesture recognizers.  That work will be done in |viewDidLoad|.
+  if ([self isViewLoaded]) {
+    [self prepareForDisplay];
+    // The delegate is set to nil when the stack view is dismissed.
+    [_scrollView setDelegate:self];
+  }
+}
+
+- (void)setOtrTabModel:(TabModel*)otrModel {
+  DCHECK(_isActive);
+  DCHECK(_mainCardSet == _activeCardSet);
+  DCHECK([otrModel count] == 0);
+  DCHECK([[_otrCardSet tabModel] count] == 0);
+  [_otrCardSet setTabModel:otrModel];
+}
+
+- (void)clearInternalState {
+  DCHECK(!_isActive);
+  [[_mainCardSet displayView] removeFromSuperview];
+  [[_otrCardSet displayView] removeFromSuperview];
+
+  // Only deregister from the specific notifications for which this class
+  // registered. Do not use the blanket |removeObserver|, otherwise the low
+  // memory notification is not received and the view is never unloaded.
+  [self deregisterForNotifications];
+
+  _mainCardSet.reset();
+  _otrCardSet.reset();
+  _activeCardSet = nil;
+
+  // Remove gesture recognizers and notifications.
+  [self prepareForDismissal];
+  _gestureStateTracker.reset();
+  _pinchRecognizer.reset();
+  _modeSwitchRecognizer.reset();
+  _swipeGestureRecognizer.reset();
+
+  // The cards need to recompute their sizes the next time they are shown.
+  _initialCardSize.height = _initialCardSize.width = 0.0f;
+  // The scroll view will need to recenter itself relative to its viewport.
+  [_scrollView setContentOffset:CGPointZero];
+  _isBeingDismissed = NO;
+}
+
+- (void)viewportSizeWasChanged {
+  [self updateScrollViewContentSize];
+  [_mainCardSet displayViewSizeWasChanged];
+  [_otrCardSet displayViewSizeWasChanged];
+}
+
+- (void)updateScrollViewContentSize {
+  // Configure the scroll view to be large enough so that the user could not
+  // scroll to one of its boundaries from the center without also having
+  // reached the corresponding boundary of the stack being scrolled: the
+  // maximum size of the larger of the two stacks plus padding.
+  CGFloat scrollLength = std::max([_mainCardSet maximumStackLength],
+                                  [_otrCardSet maximumStackLength]);
+  scrollLength += [self scrollLength:[self cardSize]];
+  scrollLength *= 2.0;
+  CGFloat scrollBreadth = [self scrollBreadth:[_scrollView bounds].size];
+  // Changing the scroll view's content size will result in a callback to
+  // |scrollViewDidScroll|.
+  _ignoreScrollCallbacks = YES;
+  [_scrollView setContentSize:[self sizeForScrollLength:scrollLength
+                                                breadth:scrollBreadth]];
+  _ignoreScrollCallbacks = NO;
+  [self recenterScrollViewIfNecessary];
+}
+
+- (void)setUpDisplayViews {
+  CGRect displayViewFrame = CGRectMake(0, 0, [_scrollView frame].size.width,
+                                       [_scrollView frame].size.height);
+  base::scoped_nsobject<UIView> mainDisplayView(
+      [[UIView alloc] initWithFrame:displayViewFrame]);
+  [mainDisplayView setAutoresizingMask:UIViewAutoresizingFlexibleWidth |
+                                       UIViewAutoresizingFlexibleHeight];
+  base::scoped_nsobject<UIView> otrDisplayView(
+      [[UIView alloc] initWithFrame:displayViewFrame]);
+  [otrDisplayView setAutoresizingMask:UIViewAutoresizingFlexibleWidth |
+                                      UIViewAutoresizingFlexibleHeight];
+
+  [_scrollView addSubview:mainDisplayView];
+  [_scrollView addSubview:otrDisplayView];
+  [_mainCardSet setDisplayView:mainDisplayView];
+  [_otrCardSet setDisplayView:otrDisplayView];
+}
+
+- (void)prepareForDisplay {
+  [self setUpDisplayViews];
+
+  // Now that the toolbar and the display views are set up, configure the
+  // initial display state.
+  [self displayActiveCardSet];
+
+  _lastInterfaceOrientation = GetInterfaceOrientation();
+  if (_lastInterfaceOrientation == UIInterfaceOrientationUnknown) {
+    CGRect screenBounds = [[UIScreen mainScreen] bounds];
+    _lastInterfaceOrientation =
+        CGRectGetHeight(screenBounds) > CGRectGetWidth(screenBounds)
+            ? UIInterfaceOrientationPortrait
+            : UIInterfaceOrientationLandscapeRight;
+  }
+  [self registerForNotifications];
+
+  // TODO(blundell): Why isn't this recognizer initialized with the
+  // pinch and mode switch recognizers?
+  UIPanGestureRecognizer* panGestureRecognizer =
+      [[UIPanGestureRecognizer alloc] initWithTarget:self
+                                              action:@selector(handlePanFrom:)];
+  [panGestureRecognizer setMaximumNumberOfTouches:1];
+  _swipeGestureRecognizer.reset(panGestureRecognizer);
+  [[self view] addGestureRecognizer:_swipeGestureRecognizer];
+  [_swipeGestureRecognizer setDelegate:self];
+}
+
+- (void)loadView {
+  [super loadView];
+
+  _backgroundView.reset([[UIView alloc] initWithFrame:self.view.bounds]);
+  [_backgroundView setAutoresizingMask:(UIViewAutoresizingFlexibleHeight |
+                                        UIViewAutoresizingFlexibleWidth)];
+  [self.view addSubview:_backgroundView];
+
+  _toolbarController.reset(
+      [[StackViewToolbarController alloc] initWithStackViewToolbar]);
+  CGRect toolbarFrame = [self.view bounds];
+  toolbarFrame.origin.y = CGRectGetMinY([[_toolbarController view] frame]);
+  toolbarFrame.size.height = CGRectGetHeight([[_toolbarController view] frame]);
+  [[_toolbarController view] setFrame:toolbarFrame];
+  [self.view addSubview:[_toolbarController view]];
+  [self updateToolbarAppearanceWithAnimation:NO];
+
+  InstallBackgroundInView(_backgroundView);
+
+  UIEdgeInsets contentInsets = UIEdgeInsetsMake(
+      toolbarFrame.size.height - kVerticalToolbarOverlap, 0.0, 0.0, 0.0);
+  CGRect scrollViewFrame =
+      UIEdgeInsetsInsetRect(self.view.bounds, contentInsets);
+  _scrollView.reset([[UIScrollView alloc] initWithFrame:scrollViewFrame]);
+  [self.view addSubview:_scrollView];
+  [_scrollView setAutoresizingMask:(UIViewAutoresizingFlexibleHeight |
+                                    UIViewAutoresizingFlexibleWidth)];
+  [_scrollView setBounces:NO];
+  [_scrollView setScrollsToTop:NO];
+  [_scrollView setClipsToBounds:NO];
+  [_scrollView setShowsVerticalScrollIndicator:NO];
+  [_scrollView setShowsHorizontalScrollIndicator:NO];
+  [_scrollView setDelegate:self];
+
+  _scrollGestureRecognizer = [_scrollView panGestureRecognizer];
+
+  [self prepareForDisplay];
+}
+
+- (void)viewWillAppear:(BOOL)animated {
+  _isActive = YES;
+  // Sizing steps need to be done here rather than viewDidLoad since they
+  // depend on the view bounds being correct. Setting initial card size should
+  // be done only once, however, and viewWillAppear: can be called more than
+  // once. For initial display, the transition animation will handle initial
+  // layout. Avoid doing it here since that will potentially cause more views
+  // to be added to the hierarchy synchronously, slowing down inital load.  The
+  // rest of the time refreshing is necessary because the card views may have
+  // been purged and recreated or the orientation might have changed while in
+  // a modal view.
+  BOOL isInitialDisplay = _initialCardSize.height == 0.0;
+  if (isInitialDisplay) {
+    [_mainCardSet setObserver:self];
+    [_otrCardSet setObserver:self];
+    [self setInitialCardSizing];
+    [self viewportSizeWasChanged];
+  } else {
+    [self refreshCardDisplayWithAnimation:NO];
+    [self updateToolbarAppearanceWithAnimation:NO];
+  }
+  [self preloadCardViewsAsynchronously];
+
+  // Reset the gesture state tracker to clear gesture-related information from
+  // the last time the stack view was shown.
+  _gestureStateTracker.reset([[GestureStateTracker alloc] init]);
+
+  [super viewWillAppear:animated];
+}
+
+- (void)refreshCardDisplayWithAnimation:(BOOL)animates {
+  _lastInterfaceOrientation = GetInterfaceOrientation();
+  [self updateDeckOrientationWithAnimation:animates];
+  [self viewportSizeWasChanged];
+  [_mainCardSet updateCardVisibilities];
+  [_otrCardSet updateCardVisibilities];
+}
+
+- (void)viewDidDisappear:(BOOL)animated {
+  if (![self presentedViewController]) {
+    // Stop pre-loading card views if the stack view has been dismissed.
+    [NSObject cancelPreviousPerformRequestsWithTarget:self];
+    _isActive = NO;
+    [self clearInternalState];
+  }
+  [_toolbarController dismissToolsMenuPopup];
+
+  [super viewDidDisappear:animated];
+}
+
+- (void)dealloc {
+  [_mainCardSet clearGestureRecognizerTargetAndDelegateFromCards:self];
+  [_otrCardSet clearGestureRecognizerTargetAndDelegateFromCards:self];
+  // Card sets shouldn't have any other references, but nil the observer just
+  // in case one somehow does end up with another ref.
+  [_mainCardSet setObserver:nil];
+  [_otrCardSet setObserver:nil];
+  [self cleanUpViewsAndNotifications];
+  [super dealloc];
+}
+
+// Overridden to always return NO, ensuring that the status bar shows in
+// landscape on iOS8.
+- (BOOL)prefersStatusBarHidden {
+  return NO;
+}
+
+// Called when in the foreground and the OS needs more memory. Release as much
+// as possible.
+- (void)didReceiveMemoryWarning {
+  // Releases the view if it doesn't have a superview.
+  [super didReceiveMemoryWarning];
+  _receivedMemoryWarningInSession = YES;
+  [_mainCardSet setKeepOnlyVisibleCardViewsAlive:YES];
+  [_otrCardSet setKeepOnlyVisibleCardViewsAlive:YES];
+
+  if (![self isViewLoaded]) {
+    [self cleanUpViewsAndNotifications];
+  }
+}
+
+- (void)willRotateToInterfaceOrientation:(UIInterfaceOrientation)orient
+                                duration:(NSTimeInterval)duration {
+  [super willRotateToInterfaceOrientation:orient duration:duration];
+  // No animation is performed on rotation if the view is not on screen.
+  if (!_isActive)
+    return;
+
+  // Hide the inactive set. NOTE: Ideally this hiding would be done as a
+  // sliding-off-the-screen animation during the first half of the rotation
+  // animation. However, integrating that custom animation with the default
+  // animation that is being done to the cards on rotation has proved
+  // challenging. For now, the inactive set is invisible during the rotation
+  // itself.
+  [[[self inactiveCardSet] displayView] setHidden:YES];
+}
+
+- (void)willAnimateRotationToInterfaceOrientation:(UIInterfaceOrientation)orient
+                                         duration:(NSTimeInterval)duration {
+  [super willAnimateRotationToInterfaceOrientation:orient duration:duration];
+
+  if (orient == _lastInterfaceOrientation)
+    return;
+
+  // If the stack view controller is not actually active, internal state will
+  // not necessarily be consistent, and the animations could crash as a result.
+  // Short-circuit out in this case (which should happen only in rare race
+  // conditions involving the device being rotated as stack view is
+  // entered/exited).
+  if (!_isActive) {
+    _lastInterfaceOrientation = orient;
+    return;
+  }
+
+  [self updateToolbarAppearanceWithAnimation:YES];
+
+  [_toolbarController dismissToolsMenuPopup];
+
+  [self refreshCardDisplayWithAnimation:YES];
+
+  // Animate the update of the card tabs.
+  CGFloat halfOfTotalDuration = duration / 2.0;
+  void (^cardTabFadeIn)(void) = ^{
+    // Update the card tabs to their new positions instantaneously and then
+    // fade them back in.
+    [self animateActiveSetCardTabsToOpacity:1.0
+                               withDuration:halfOfTotalDuration
+                                 completion:nil];
+  };
+  [self animateActiveSetCardTabsToOpacity:0.0
+                             withDuration:halfOfTotalDuration
+                               completion:cardTabFadeIn];
+
+  [_gestureStateTracker setResetScrollCardOnNextDrag:YES];
+  [_gestureStateTracker setFirstPinchCardIndex:NSNotFound];
+  [_gestureStateTracker setSecondPinchCardIndex:NSNotFound];
+}
+
+- (void)didRotateFromInterfaceOrientation:(UIInterfaceOrientation)orient {
+  [super didRotateFromInterfaceOrientation:orient];
+  // No animation is performed on rotation if the view is not on screen.
+  if (!_isActive)
+    return;
+
+  // Animate the inactive card set sliding in. NOTE: Ideally this animation
+  // would be done during the second half of the rotation animation. However,
+  // integrating this animation and the default animation that is being done to
+  // the cards on rotation has proved challenging. For now, the inactive set is
+  // invisible during the rotation itself.
+  CardSet* inactiveSet = [self inactiveCardSet];
+  [self updateDeckAxisPositionForCardSet:inactiveSet
+                         withShiftAmount:
+                             [self shiftOffscreenAmountForCardSet:inactiveSet]];
+  [[inactiveSet displayView] setHidden:NO];
+  [UIView animateWithDuration:kDefaultAnimationDuration
+                        delay:0
+                      options:0
+                   animations:^{
+                     [self updateDeckAxisPositionForCardSet:inactiveSet
+                                            withShiftAmount:0];
+                   }
+                   completion:nil];
+}
+
+- (void)registerForNotifications {
+  NSNotificationCenter* defaultCenter = [NSNotificationCenter defaultCenter];
+  [defaultCenter addObserver:self
+                    selector:@selector(allModelTabsHaveClosed:)
+                        name:kTabModelAllTabsDidCloseNotification
+                      object:nil];
+}
+
+- (void)deregisterForNotifications {
+  NSNotificationCenter* defaultCenter = [NSNotificationCenter defaultCenter];
+  [defaultCenter removeObserver:self
+                           name:kTabModelAllTabsDidCloseNotification
+                         object:nil];
+}
+
+- (void)prepareForDismissal {
+  UIView* activeView = [_activeCardSet displayView];
+  [activeView removeGestureRecognizer:_pinchRecognizer];
+  [activeView removeGestureRecognizer:_modeSwitchRecognizer];
+  [activeView removeGestureRecognizer:_swipeDismissesCardRecognizer];
+  [[self view] removeGestureRecognizer:_swipeGestureRecognizer];
+  [_mainCardSet clearGestureRecognizerTargetAndDelegateFromCards:self];
+  [_otrCardSet clearGestureRecognizerTargetAndDelegateFromCards:self];
+  [_scrollView setDelegate:nil];
+  [_scrollView setScrollEnabled:YES];
+  _ignoreScrollCallbacks = NO;
+
+  // Record per-session metrics.
+  UMA_HISTOGRAM_BOOLEAN("MemoryWarning.OccurredDuringCardStackSession",
+                        _receivedMemoryWarningInSession);
+}
+
+- (void)cleanUpViewsAndNotifications {
+  [_mainCardSet setDisplayView:nil];
+  [_otrCardSet setDisplayView:nil];
+  // Stop pre-loading cards.
+  [NSObject cancelPreviousPerformRequestsWithTarget:self];
+  [_scrollView setDelegate:nil];
+  _scrollView.reset();
+  _backgroundView.reset();
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (UIStatusBarStyle)preferredStatusBarStyle {
+  // When dismissing the stack view, the status bar's style is updated when this
+  // view controller is still responsible.  If the stack view is dismissing into
+  // a non-incognito BVC, the status bar needs to use the default style.
+  BOOL useDefaultStyle = _isBeingDismissed && ![self isCurrentSetIncognito];
+  return useDefaultStyle ? UIStatusBarStyleDefault
+                         : UIStatusBarStyleLightContent;
+}
+
+#pragma mark -
+#pragma mark Card and Stack Construction
+
+- (void)preloadCardViewsAsynchronously {
+  // Start the deferred loading of card views. Defers the pre-loading slightly
+  // in order to give the initially visible cards a head start.
+  [NSObject cancelPreviousPerformRequestsWithTarget:self];
+  [self performSelector:@selector(preloadNextCardView)
+             withObject:nil
+             afterDelay:0.01];
+}
+
+- (void)preloadNextCardView {
+  if (_isBeingDismissed)
+    return;
+  // Preload one card from the active set, or if that's already loaded, from
+  // the other set.
+  BOOL preloadedCard = [_activeCardSet preloadNextCard];
+  if (!preloadedCard)
+    preloadedCard = [[self inactiveCardSet] preloadNextCard];
+  // If there was a card to preload, queue the next round.
+  if (preloadedCard) {
+    [self performSelector:@selector(preloadNextCardView)
+               withObject:nil
+               afterDelay:0];
+  } else {
+    [_testDelegate stackViewControllerPreloadCardViewsDidEnd];
+  }
+}
+
+- (void)animateOutCardView:(CardView*)cardView
+                     delay:(NSTimeInterval)delay
+                 clockwise:(BOOL)clockwise
+                completion:(ProceduralBlock)completion {
+  DCHECK(cardView);
+  void (^toDoWhenDone)(void) = ^{
+    [cardView removeFromSuperview];
+    if (completion)
+      completion();
+  };
+  BOOL isPortrait = UIInterfaceOrientationIsPortrait(_lastInterfaceOrientation);
+  ios_internal::page_animation_util::AnimateOutWithCompletion(
+      cardView, delay, clockwise, isPortrait, toDoWhenDone);
+}
+
+- (void)removeAllCardsFromSet:(CardSet*)cardSet {
+  // Ignore model updates while the cards are closing, to batch all the
+  // re-laying-out work.
+  [cardSet setIgnoresTabModelChanges:YES];
+
+  NSTimeInterval delay = 0;
+  NSArray* cards = [cardSet cards];
+  BOOL isPortrait = UIInterfaceOrientationIsPortrait(_lastInterfaceOrientation);
+
+  // Find the last visible card.
+  StackCard* lastVisibleCard = nil;
+  for (StackCard* card in [cards reverseObjectEnumerator]) {
+    if ([card viewIsLive]) {
+      lastVisibleCard = card;
+      break;
+    }
+  }
+  if (lastVisibleCard == nil) {
+    [cardSet.tabModel closeAllTabs];
+    return;
+  }
+
+  for (StackCard* card in cards) {
+    NSInteger cardIndex = [cards indexOfObject:card];
+    DCHECK(cardIndex != NSNotFound);
+    BOOL cardWasCollapsed = [cardSet cardIsCollapsed:card];
+
+    if ([card viewIsLive]) {
+      void (^toDoWhenDone)(void) = NULL;
+      if (card == lastVisibleCard) {
+        toDoWhenDone = ^{
+          [cardSet.tabModel closeAllTabs];
+        };
+      }
+      [self animateOutCardView:card.view
+                         delay:delay
+                     clockwise:isPortrait
+                    completion:toDoWhenDone];
+    } else {
+      // It's too late to create a view for this card now. This case should only
+      // occur if the card was covered, meaning that its animation out would
+      // have been invisible anyway.
+      DCHECK(cardWasCollapsed);
+    }
+
+    // Add a delay before the next card's animation if this card was not
+    // collapsed into the next card.
+    if (!cardWasCollapsed)
+      delay += kCascadingCardCloseDelay;
+  }
+}
+
+- (void)disableGestureHandlers {
+  // Disable gesture handlers before modifying the stack. Don't call this too
+  // late or a gesture callback could occur while still in the old state of the
+  // world.
+  // (see the comment in -cardSet:willRemoveCard:atIndex for details).
+  [_scrollView setScrollEnabled:NO];
+  _pinchRecognizer.get().enabled = NO;
+  _swipeGestureRecognizer.get().enabled = NO;
+}
+
+- (void)enableGestureHandlers {
+  // Reenable gesture handlers after modifying the stack. Don't call this too
+  // early or a gesture callback could occur while still in the old state of the
+  // world.
+  // (see the comment in -cardSet:willRemoveCard:atIndex for details).
+  [_scrollView setScrollEnabled:YES];
+  _pinchRecognizer.get().enabled = YES;
+  _swipeGestureRecognizer.get().enabled = YES;
+}
+
+- (void)activeCardCountChanged {
+  // Cancel any outstanding gestures (see the comment in
+  // -cardSet:willRemoveCard:atIndex).
+  [self disableGestureHandlers];
+  [self enableGestureHandlers];
+}
+
+- (void)setInitialCardSizing {
+  DCHECK(_initialCardSize.height == 0.0);
+  CGFloat viewportBreadth = [self scrollBreadth:[_scrollView bounds].size];
+  _initialCardSize = [self cardSizeForBreadth:viewportBreadth];
+
+  // Configure the stack layout behaviors. This is done only once because the
+  // fan-out, margins, etc. should stay the same even if the cards change size
+  // due to rotation.
+  [self updateDeckOrientationWithAnimation:NO];
+  [_mainCardSet configureLayoutParametersWithMargin:
+                    ios_internal::page_animation_util::kCardMargin];
+  [_otrCardSet configureLayoutParametersWithMargin:
+                   ios_internal::page_animation_util::kCardMargin];
+}
+
+- (void)updateDeckOrientationWithAnimation:(BOOL)animates {
+  [self updateDeckAxisPositions];
+  [self updateCardSizesWithAnimation:animates];
+}
+
+- (void)updateCardSizesWithAnimation:(BOOL)animates {
+  CGSize cardSize = [self cardSize];
+  NSTimeInterval animationDuration = animates ? kDefaultAnimationDuration : 0;
+  [UIView animateWithDuration:animationDuration
+                        delay:0
+                      options:UIViewAnimationOptionBeginFromCurrentState
+                   animations:^{
+                     [_mainCardSet setCardSize:cardSize];
+                     [_otrCardSet setCardSize:cardSize];
+                   }
+                   completion:nil];
+}
+
+- (void)animateActiveSetCardTabsToOpacity:(CGFloat)opacity
+                             withDuration:(CGFloat)duration
+                               completion:(ProceduralBlock)completion {
+  [UIView animateWithDuration:duration
+      delay:0
+      options:(UIViewAnimationOptionBeginFromCurrentState |
+               UIViewAnimationOptionOverrideInheritedDuration)
+      animations:^{
+        for (StackCard* card in [_activeCardSet cards]) {
+          if (card.viewIsLive)
+            [card.view setTabOpacity:opacity];
+        }
+      }
+      completion:^(BOOL) {
+        if (completion)
+          completion();
+      }];
+}
+
+- (void)updateDeckAxisPositions {
+  [self updateDeckAxisPositionsWithShiftAmount:0];
+}
+
+- (void)updateDeckAxisPositionsWithShiftAmount:(CGFloat)shiftAmount {
+  [self updateDeckAxisPositionForCardSet:_activeCardSet
+                         withShiftAmount:shiftAmount];
+  [self updateDeckAxisPositionForCardSet:[self inactiveCardSet]
+                         withShiftAmount:shiftAmount];
+}
+
+- (void)updateDeckAxisPositionForCardSet:(CardSet*)cardSet
+                         withShiftAmount:(CGFloat)shiftAmount {
+  // Skip axis layout if card size hasn't been set up yet; it will be handled
+  // when card size is.
+  if (_initialCardSize.height == 0.0)
+    return;
+
+  if (!cardSet)
+    return;
+
+  CGFloat viewportBreadth =
+      [self scrollBreadth:[_mainCardSet displayView].bounds.size];
+  CGFloat fullDisplayBreadth =
+      [self bothDecksShouldBeDisplayed]
+          ? (viewportBreadth * kActiveDeckDisplayFraction)
+          : viewportBreadth;
+
+  CGFloat center = (fullDisplayBreadth / 2.0);
+  if ([self isCurrentSetIncognito])
+    center += viewportBreadth - fullDisplayBreadth;
+  // Adjust the set's center if it's not the active card set.
+  if (cardSet != _activeCardSet) {
+    CGFloat inactiveSetDelta = fullDisplayBreadth -
+                               ios_internal::page_animation_util::kCardMargin +
+                               kCardFrameInset;
+    center = [self isCurrentSetIncognito] ? center - inactiveSetDelta
+                                          : center + inactiveSetDelta;
+  }
+  center += shiftAmount;
+
+  BOOL isPortrait = UIInterfaceOrientationIsPortrait(_lastInterfaceOrientation);
+  [cardSet setLayoutAxisPosition:center isVertical:isPortrait];
+}
+
+- (CGFloat)shiftOffscreenAmountForCardSet:(CardSet*)cardSet {
+  if (!cardSet)
+    return 0;
+
+  CGFloat viewportBreadth =
+      [self scrollBreadth:[_activeCardSet displayView].bounds.size];
+  // The incognito card set moves offscreen to the right; the main card set
+  // moves offscreen to the left.
+  CGFloat offset = (1 - kActiveDeckDisplayFraction) * viewportBreadth;
+  if (cardSet == _mainCardSet)
+    offset = -offset;
+  return offset;
+}
+
+- (BOOL)bothDecksShouldBeDisplayed {
+  return [[_otrCardSet cards] count] > 0;
+}
+
+#pragma mark -
+#pragma mark Current Set Handling
+
+- (BOOL)isCurrentSetIncognito {
+  return _activeCardSet == _otrCardSet.get();
+}
+
+- (CardSet*)inactiveCardSet {
+  return [self isCurrentSetIncognito] ? _mainCardSet.get() : _otrCardSet.get();
+}
+
+- (void)setActiveCardSet:(CardSet*)cardSet {
+  DCHECK(cardSet);
+  if (cardSet == _activeCardSet)
+    return;
+  [self activeCardCountChanged];
+  _activeCardSet = cardSet;
+
+  [self displayActiveCardSet];
+}
+
+- (void)displayActiveCardSet {
+  UIView* activeView = [_activeCardSet displayView];
+  DCHECK(activeView);
+  UIView* inactiveView = [[self inactiveCardSet] displayView];
+
+  [_scrollView bringSubviewToFront:activeView];
+
+  // |_swipeGestureRecognizer| is added to the main SVC view, so don't add or
+  // remove that here.
+  // TODO(blundell): Figure out which recognizers need to be associated with the
+  // active display view and which can just be on the superview.
+  [inactiveView removeGestureRecognizer:_pinchRecognizer];
+  [inactiveView removeGestureRecognizer:_modeSwitchRecognizer];
+  [inactiveView removeGestureRecognizer:_swipeDismissesCardRecognizer];
+  [activeView addGestureRecognizer:_pinchRecognizer];
+  [activeView addGestureRecognizer:_modeSwitchRecognizer];
+  [activeView addGestureRecognizer:_swipeDismissesCardRecognizer];
+
+  activeView.accessibilityElementsHidden = NO;
+  inactiveView.accessibilityElementsHidden = YES;
+
+  _inActiveDeckChangeAnimation = YES;  // This flag is used for testing.
+  [UIView animateWithDuration:kDefaultAnimationDuration
+      delay:0
+      options:UIViewAnimationOptionBeginFromCurrentState
+      animations:^{
+        [self updateDeckAxisPositions];
+      }
+      completion:^(BOOL finished) {
+        _inActiveDeckChangeAnimation = NO;
+      }];
+
+  [self updateToolbarAppearanceWithAnimation:YES];
+}
+
+- (void)displayMainCardSetOnly {
+  [self updateCardSizesWithAnimation:YES];
+  if ([self isCurrentSetIncognito]) {
+    [self setActiveCardSet:[self inactiveCardSet]];
+  } else {
+    // Ensure that layout axis position is up to date.
+    [self displayActiveCardSet];
+  }
+}
+
+- (void)updateToolbarAppearanceWithAnimation:(BOOL)animate {
+  [_toolbarController setTabCount:[_activeCardSet.cards count]];
+  [[_toolbarController openNewTabButton]
+      setIncognito:[self isCurrentSetIncognito]
+          animated:animate];
+
+  // Position the toolbar above/below the cards depending on the current state
+  // of the cards and the device. In landscape with multiple stacks, the cards
+  // must be behind the toolbar to avoid covering it. In all other cases, the
+  // cards are positioned to go in front of the toolbar.
+  BOOL toolbarShouldHaveBackground = NO;
+  if (([[_otrCardSet cards] count] > 0) && IsLandscape())
+    toolbarShouldHaveBackground = YES;
+
+  NSUInteger scrollViewIndex =
+      [[[self view] subviews] indexOfObject:_scrollView];
+  NSUInteger toolbarViewIndex =
+      [[[self view] subviews] indexOfObject:[_toolbarController view]];
+  BOOL toolbarInFrontOfScrollView = (toolbarViewIndex > scrollViewIndex);
+
+  // If moving the toolbar to the front, have it cover the cards before any
+  // animation of the background starts to occur, as this looks cleanest.
+  if (toolbarShouldHaveBackground && !toolbarInFrontOfScrollView) {
+    [[self view] exchangeSubviewAtIndex:scrollViewIndex
+                     withSubviewAtIndex:toolbarViewIndex];
+  }
+
+  void (^updateToolbar)(void) = ^{
+    CGFloat alpha = toolbarShouldHaveBackground ? 1.0 : 0.0;
+    [_toolbarController backgroundView].alpha = alpha;
+    [_toolbarController shadowView].alpha = alpha;
+  };
+
+  // If moving the toolbar to the back, have the cards move forward only after
+  // the toolbar background finishes disappearing, as this looks cleanest.
+  void (^toDoWhenDone)(void) = ^{
+    if (!toolbarShouldHaveBackground && toolbarInFrontOfScrollView) {
+      [[self view] exchangeSubviewAtIndex:scrollViewIndex
+                       withSubviewAtIndex:toolbarViewIndex];
+      [_scrollView setClipsToBounds:NO];
+    }
+  };
+
+  if (animate) {
+    [UIView animateWithDuration:kDefaultAnimationDuration
+        delay:0
+        options:UIViewAnimationOptionBeginFromCurrentState
+        animations:^{
+          updateToolbar();
+        }
+        completion:^(BOOL finished) {
+          toDoWhenDone();
+        }];
+  } else {
+    updateToolbar();
+    toDoWhenDone();
+  }
+}
+
+#pragma mark -
+#pragma mark Sizing/Measuring Helpers
+
+- (CGSize)cardSize {
+  DCHECK(_initialCardSize.height != 0.0);
+  CGFloat availableBreadth = [self scrollBreadth:[_scrollView bounds].size];
+  if ([self bothDecksShouldBeDisplayed])
+    availableBreadth *= kActiveDeckDisplayFraction;
+  CGSize idealCardSize = [self cardSizeForBreadth:availableBreadth];
+
+  // Crop the ideal size so that it's no bigger than the initial size.
+  return CGSizeMake(std::min(idealCardSize.width, _initialCardSize.width),
+                    std::min(idealCardSize.height, _initialCardSize.height));
+}
+
+- (CGSize)cardSizeForBreadth:(CGFloat)breadth {
+  BOOL isPortrait = IsPortrait();
+  CGFloat cardBreadth =
+      breadth - 2 * ios_internal::page_animation_util::kCardMargin;
+  CGFloat contentBreadthInset =
+      isPortrait ? kCardImageInsets.left + kCardImageInsets.right
+                 : kCardImageInsets.top + kCardImageInsets.bottom;
+  CGFloat contentBreadth = cardBreadth - contentBreadthInset;
+  CGSize viewSize = [_scrollView bounds].size;
+  CGFloat aspectRatio =
+      [self scrollLength:viewSize] / [self scrollBreadth:viewSize];
+  CGFloat contentLength = std::floor(aspectRatio * contentBreadth);
+  CGFloat contentLengthInset =
+      isPortrait ? kCardImageInsets.top + kCardImageInsets.bottom
+                 : kCardImageInsets.left + kCardImageInsets.right;
+  CGFloat cardLength = contentLength + contentLengthInset;
+  // Truncate the card length so that the entire card can be visible at once.
+  CGFloat viewLength = isPortrait ? viewSize.height : viewSize.width;
+  CGFloat truncatedCardLength = viewLength -
+                                ios_internal::page_animation_util::kCardMargin -
+                                kCardBottomPadding;
+  cardLength = std::min(cardLength, truncatedCardLength);
+  return [self sizeForScrollLength:cardLength breadth:cardBreadth];
+}
+
+- (CGFloat)scrollOffsetAmountForPoint:(CGPoint)point {
+  return IsPortrait() ? point.y : point.x;
+}
+
+- (CGFloat)scrollOffsetAmountForPosition:(LayoutRectPosition)position {
+  return IsPortrait() ? position.originY : position.leading;
+}
+
+- (CGPoint)scrollOffsetPointWithAmount:(CGFloat)offset {
+  return IsPortrait() ? CGPointMake(0, offset) : CGPointMake(offset, 0);
+}
+
+- (CGFloat)scrollLength:(CGSize)size {
+  return IsPortrait() ? size.height : size.width;
+}
+
+- (CGFloat)scrollBreadth:(CGSize)size {
+  return IsPortrait() ? size.width : size.height;
+}
+
+- (CGSize)sizeForScrollLength:(CGFloat)length breadth:(CGFloat)breadth {
+  return IsPortrait() ? CGSizeMake(breadth, length)
+                      : CGSizeMake(length, breadth);
+}
+
+- (CGRect)inactiveDeckRegion {
+  // If only one deck is showing, there's no inactive deck region.
+  if (![self bothDecksShouldBeDisplayed])
+    return CGRectZero;
+
+  CGSize viewportSize = [_activeCardSet displayView].frame.size;
+  CGFloat viewportBreadth = [self scrollBreadth:viewportSize];
+  CGFloat inactiveBreadth = (1 - kActiveDeckDisplayFraction) * viewportBreadth;
+  CGSize regionSize = [self sizeForScrollLength:[self scrollLength:viewportSize]
+                                        breadth:inactiveBreadth];
+  CGPoint regionOrigin = [_scrollView contentOffset];
+  if (IsPortrait()) {
+    BOOL inactiveOnRight = UseRTLLayout() == [self isCurrentSetIncognito];
+    if (inactiveOnRight)
+      regionOrigin.x = viewportBreadth - regionSize.width;
+  } else {
+    BOOL inactiveOnBottom = ![self isCurrentSetIncognito];
+    if (inactiveOnBottom)
+      regionOrigin.y = viewportBreadth - regionSize.height;
+  }
+  return {regionOrigin, regionSize};
+}
+
+- (NSUInteger)indexOfCardAtPoint:(CGPoint)point {
+  UIView* view = [_activeCardSet.displayView hitTest:point withEvent:nil];
+  while (view && ![view isKindOfClass:[CardView class]]) {
+    view = [view superview];
+  }
+  if (!view)
+    return NSNotFound;
+  StackCard* card = [self cardForView:(CardView*)view];
+  return [_activeCardSet.cards indexOfObject:card];
+}
+
+#pragma mark -
+#pragma mark Stack View Transition Helpers
+
+// Determine what should be the first visible card. Preference is to start one
+// card before the current card so that the current card ends up in the middle
+// of the visible cards. However, if the current card is the last in a stack of
+// > 2 cards, start two cards before so that the screen is fully populated (and
+// if the current card is the first card, the only option is to start with the
+// first card).
+- (NSUInteger)startIndexOfInitialFanoutForCardSet:(CardSet*)cardSet {
+  if ([[cardSet cards] count] == 0)
+    return 0;
+  NSUInteger currentCardIndex =
+      [cardSet.tabModel indexOfTab:cardSet.tabModel.currentTab];
+  NSUInteger startingCardIndex =
+      (currentCardIndex == 0) ? 0 : currentCardIndex - 1;
+  if ((currentCardIndex > 1) &&
+      (currentCardIndex == ([cardSet.tabModel count] - 1)))
+    startingCardIndex -= 1;
+  return startingCardIndex;
+}
+
+- (void)showWithSelectedTabAnimation {
+  [self animateTransitionWithStyle:STACK_TRANSITION_STYLE_PRESENTING];
+
+  [_testDelegate stackViewControllerShowWithSelectedTabAnimationDidStart];
+
+  [_activeCardSet.currentCard setIsActiveTab:YES];
+
+  // When in accessbility mode, fan out cards from the start, announce open tabs
+  // and move the VoiceOver cursor to the New Tab button. Fanning out the cards
+  // from the start eliminates the screen change that would otherwise occur when
+  // moving the VoiceOver cursor from the Show Tabs button to the card stack.
+  if (UIAccessibilityIsVoiceOverRunning()) {
+    [_activeCardSet fanOutCardsWithStartIndex:0];
+    [self postOpenTabsAccessibilityNotification];
+    UIAccessibilityPostNotification(UIAccessibilityScreenChangedNotification,
+                                    _toolbarController.get().view);
+  }
+}
+
+- (void)cancelTransitionAnimation {
+  // Set up transaction.
+  [CATransaction begin];
+  [CATransaction setCompletionBlock:^{
+    [self finishTransitionAnimation];
+  }];
+  self.transitionWasCancelled = YES;
+  // Reverse all the animations.
+  [self reverseDummyToolbarBackgroundViewAnimation];
+  [self reverseTransitionAnimationsForCardSet:_activeCardSet];
+  [self reverseTransitionAnimationsForCardSet:[self inactiveCardSet]];
+  [self.transitionToolbarController reverseTransitionAnimations];
+  // Commit the transaction.  Since the animations added for the previous
+  // transition are all removed, this commit will call the previous
+  // animation's completion block.
+  [CATransaction commit];
+}
+
+- (void)finishTransitionAnimation {
+  // Early return if cancelled.
+  if (self.transitionWasCancelled) {
+    // Notify the delegates.
+    [self notifyDelegatesTransitionFinished];
+    // When transitions are cancelled, reverse the transition style so that the
+    // new completion block sends the correct delegate methods.
+    self.transitionStyle =
+        self.transitionStyle == STACK_TRANSITION_STYLE_PRESENTING
+            ? STACK_TRANSITION_STYLE_DISMISSING
+            : STACK_TRANSITION_STYLE_PRESENTING;
+    self.transitionWasCancelled = NO;
+    return;
+  }
+  // Clean up card view animations.
+  for (StackCard* card in _activeCardSet.cards) {
+    if ([card viewIsLive])
+      [card.view cleanUpAnimations];
+  }
+  for (StackCard* card in [self inactiveCardSet].cards) {
+    if ([card viewIsLive])
+      [card.view cleanUpAnimations];
+  }
+  // Clean up toolbar animations.
+  [self.transitionToolbarController.view removeFromSuperview];
+  [self.transitionToolbarOwner reparentToolbarController];
+  [self.transitionToolbarController cleanUpTransitionAnimations];
+  self.transitionToolbarController.view.animatingTransition = NO;
+  [self.transitionToolbarController view].frame = self.transitionToolbarFrame;
+  self.transitionToolbarController = nil;
+  self.transitionToolbarFrame = CGRectZero;
+  self.transitionToolbarOwner = nil;
+  // Clean up dummy toolbar background.
+  [self.dummyToolbarBackgroundView removeFromSuperview];
+  self.dummyToolbarBackgroundView = nil;
+  // Notify the delegates.
+  [self notifyDelegatesTransitionFinished];
+  // Reset the current transition style.
+  StackTransitionStyle transitionStyleAtFinish = self.transitionStyle;
+  self.transitionStyle = STACK_TRANSITION_STYLE_NONE;
+  // Restore the original subview ordering.
+  [self reorderSubviewsForTransition];
+  // Dismiss immediately if a card was selected mid-presentation.
+  if (self.transitionTappedCard) {
+    _activeCardSet.currentCard = self.transitionTappedCard;
+    self.transitionTappedCard = nil;
+    [self dismissWithSelectedTabAnimation];
+  }
+
+  if (transitionStyleAtFinish == STACK_TRANSITION_STYLE_DISMISSING) {
+    // Dismissal is complete and delegate was told that stack view has been
+    // dismissed. Make sure that internal state reflects that.
+    _isActive = NO;
+    [self clearInternalState];
+  }
+}
+
+- (void)notifyDelegatesTransitionFinished {
+  // Notify delegates.
+  DCHECK_NE(self.transitionStyle, STACK_TRANSITION_STYLE_NONE);
+  if (self.transitionStyle == STACK_TRANSITION_STYLE_PRESENTING) {
+    [_testDelegate stackViewControllerShowWithSelectedTabAnimationDidEnd];
+    [_delegate tabSwitcherPresentationTransitionDidEnd:self];
+  } else {
+    [_delegate tabSwitcherDismissTransitionDidEnd:self];
+  }
+}
+
+- (void)animateTransitionWithStyle:(StackTransitionStyle)transitionStyle {
+  // If the dummy toolbar background view is instantiated, reverse the current
+  // transition animations.
+  if (self.dummyToolbarBackgroundView) {
+    [self cancelTransitionAnimation];
+    return;
+  }
+
+  // The transition style must be specified.
+  DCHECK_NE(transitionStyle, STACK_TRANSITION_STYLE_NONE);
+  self.transitionStyle = transitionStyle;
+  BOOL isPresenting = self.transitionStyle == STACK_TRANSITION_STYLE_PRESENTING;
+
+  // Get reference to toolbar for transition.
+  self.transitionToolbarOwner = [_delegate tabSwitcherTransitionToolbarOwner];
+  self.transitionToolbarController =
+      [self.transitionToolbarOwner relinquishedToolbarController];
+  self.transitionToolbarController.view.animatingTransition = YES;
+  self.transitionToolbarFrame = self.transitionToolbarController.view.frame;
+
+  // Create dummy toolbar background view.
+  self.dummyToolbarBackgroundView =
+      [[[UIView alloc] initWithFrame:CGRectZero] autorelease];
+  [self.dummyToolbarBackgroundView setClipsToBounds:YES];
+
+  // Set the transition completion block.
+  [CATransaction begin];
+  [CATransaction setCompletionBlock:^{
+    [self finishTransitionAnimation];
+  }];
+
+  // Slide in/out the inactive card set.
+  [self animateInactiveSetTransition];
+
+  // The current card's frame is necessary for the toolbar animation below.  For
+  // dismissals, the toolbar animates from the card's current frame (i.e. the
+  // frame before the animation is added).  For presentation, the toolbar
+  // animates to the final frame (i.e. the frame after the animation is added).
+  LayoutRect currentCardLayout = _activeCardSet.currentCard.layout;
+  [self animateActiveSetTransition];
+  if (isPresenting)
+    currentCardLayout = _activeCardSet.currentCard.layout;
+  CGRect currentCardFrame =
+      AlignRectOriginAndSizeToPixels(LayoutRectGetRect(currentCardLayout));
+
+  // Animate the dummy toolbar background view.
+  [self animateDummyToolbarForCardFrame:currentCardFrame
+                        transitionStyle:transitionStyle];
+
+  // Animate the transition toolbar.
+  [self animateTransitionToolbarWithCardFrame:currentCardFrame
+                              transitionStyle:transitionStyle];
+
+  // Update the order of the view hierarchy.
+  [self reorderSubviewsForTransition];
+
+  [CATransaction commit];
+}
+
+- (void)reorderSubviewsForTransition {
+  if (self.transitionStyle != STACK_TRANSITION_STYLE_NONE) {
+    // Add the card set display views to the main view and insert the toolbar
+    // between them.
+    [self.view addSubview:[self inactiveCardSet].displayView];
+    [self inactiveCardSet].displayView.frame = [_scrollView frame];
+    [self.view addSubview:_activeCardSet.displayView];
+    _activeCardSet.displayView.frame = [_scrollView frame];
+    [self.view insertSubview:[_toolbarController view]
+                belowSubview:_activeCardSet.displayView];
+  } else {
+    // Add the display views back into the scroll view.
+    [_scrollView addSubview:[self inactiveCardSet].displayView];
+    [_scrollView addSubview:_activeCardSet.displayView];
+    [self updateToolbarAppearanceWithAnimation:NO];
+    [self alignDisplayViewsToViewport];
+  }
+}
+
+- (void)animateCardSet:(CardSet*)cardSet
+      fromBeginLayouts:(std::vector<LayoutRect>)beginLayouts
+          toEndLayouts:(std::vector<LayoutRect>)endLayouts {
+  NSUInteger cardCount = [cardSet.cards count];
+  DCHECK_EQ(cardCount, beginLayouts.size());
+  DCHECK_EQ(cardCount, endLayouts.size());
+
+  [CATransaction begin];
+  [CATransaction setDisableActions:YES];
+  // Place cards into final position.
+  for (NSUInteger i = 0; i < cardCount; ++i)
+    [cardSet.cards[i] setLayout:endLayouts[i]];
+  // For presentation, update visibilty so only cards that will ultimately be
+  // shown are live.
+  BOOL isPresenting = self.transitionStyle == STACK_TRANSITION_STYLE_PRESENTING;
+  if (isPresenting)
+    [cardSet updateCardVisibilities];
+  [CATransaction commit];
+
+  // Animate each card to its final frame.
+  StackCard* currentCard = cardSet.currentCard;
+  BOOL isActiveCardSet = (cardSet == _activeCardSet);
+  for (NSUInteger i = 0; i < cardCount; ++i) {
+    StackCard* card = cardSet.cards[i];
+    if ([card viewIsLive]) {
+      CardTabAnimationStyle tabAnimationStyle = CARD_TAB_ANIMATION_STYLE_NONE;
+      if (isActiveCardSet && card == currentCard) {
+        tabAnimationStyle = isPresenting ? CARD_TAB_ANIMATION_STYLE_FADE_IN
+                                         : CARD_TAB_ANIMATION_STYLE_FADE_OUT;
+      }
+      [card.view animateFromBeginFrame:LayoutRectGetRect(beginLayouts[i])
+                            toEndFrame:LayoutRectGetRect(endLayouts[i])
+                     tabAnimationStyle:tabAnimationStyle];
+    }
+  }
+}
+
+- (void)reverseTransitionAnimationsForCardSet:(CardSet*)cardSet {
+  for (StackCard* card in cardSet.cards) {
+    if ([card viewIsLive])
+      [card.view reverseAnimations];
+  }
+}
+
+- (void)animateActiveSetTransition {
+  // Early return for an empty active card set.
+  if (![_activeCardSet.cards count])
+    return;
+
+  std::vector<LayoutRect> beginLayouts;
+  std::vector<LayoutRect> endLayouts;
+  BOOL isPresenting = self.transitionStyle == STACK_TRANSITION_STYLE_PRESENTING;
+  if (isPresenting) {
+    // For presentation, animate from transition frames to fan frames.
+    NSUInteger activeSetStartIndex =
+        [self startIndexOfInitialFanoutForCardSet:_activeCardSet];
+    beginLayouts = [self cardTransitionLayouts];
+    [_activeCardSet fanOutCardsWithStartIndex:activeSetStartIndex];
+    endLayouts = [_activeCardSet cardLayouts];
+  } else {
+    // For dismissal, animate from the cards' current frames to the transition
+    // frames.
+    beginLayouts = [_activeCardSet cardLayouts];
+    endLayouts = [self cardTransitionLayouts];
+    // For dismissals, the status bar needs to be updated early.
+    [self performSelector:@selector(setNeedsStatusBarAppearanceUpdate)
+               withObject:nil
+               afterDelay:kDismissalStatusBarUpdateDelay];
+    // Ensure that the current card view is visible.
+    _activeCardSet.currentCard.view.hidden = NO;
+  }
+
+  // Add animations.
+  [self animateCardSet:_activeCardSet
+      fromBeginLayouts:beginLayouts
+          toEndLayouts:endLayouts];
+}
+
+- (void)animateInactiveSetTransition {
+  // Early return for an emtpy inactive card set.
+  CardSet* inactiveCardSet = [self inactiveCardSet];
+  if (![[inactiveCardSet cards] count])
+    return;
+
+  BOOL isPresenting = self.transitionStyle == STACK_TRANSITION_STYLE_PRESENTING;
+
+  // Calculate transition animation card frames
+  if (isPresenting) {
+    // For presentation, fan out the cards for the transition.  Otherwise, use
+    // the current frames of the cards.
+    NSUInteger inactiveSetStartIndex =
+        [self startIndexOfInitialFanoutForCardSet:inactiveCardSet];
+    [inactiveCardSet fanOutCardsWithStartIndex:inactiveSetStartIndex];
+  }
+  std::vector<LayoutRect> cardStackLayouts = [inactiveCardSet cardLayouts];
+  BOOL isPortrait = UIInterfaceOrientationIsPortrait(_lastInterfaceOrientation);
+  CGFloat shiftAmount = [self shiftOffscreenAmountForCardSet:inactiveCardSet];
+  std::vector<LayoutRect> shiftedStackLayouts;
+  for (const auto& cardLayout : cardStackLayouts) {
+    LayoutRect shiftedLayout = cardLayout;
+    if (isPortrait)
+      shiftedLayout.position.leading += shiftAmount;
+    else
+      shiftedLayout.position.originY += shiftAmount;
+    shiftedStackLayouts.push_back(shiftedLayout);
+  }
+
+  std::vector<LayoutRect> beginLayouts =
+      isPresenting ? shiftedStackLayouts : cardStackLayouts;
+  std::vector<LayoutRect> endLayouts =
+      isPresenting ? cardStackLayouts : shiftedStackLayouts;
+
+  // Add animations.
+  [self animateCardSet:inactiveCardSet
+      fromBeginLayouts:beginLayouts
+          toEndLayouts:endLayouts];
+}
+
+- (void)animateDummyToolbarForCardFrame:(CGRect)cardFrame
+                        transitionStyle:(StackTransitionStyle)transitionStyle {
+  // Install the dummy toolbar background view into the card tab.
+  CardView* cardView = _activeCardSet.currentCard.view;
+  [cardView installDummyToolbarBackgroundView:self.dummyToolbarBackgroundView];
+
+  // When calculating the frames below, convert them into the card's tab's
+  // coordinate system, whose origin is at |cardTabOriginOffset| from the card's
+  // frame origin.
+  CGVector cardTabOriginOffset =
+      CGVectorMake(kCardFrameInset, kCardTabTopInset);
+
+  // The card's frame image extends beyond the edges of the screen when the
+  // current card is scaled to the full content area, so extend the toolbar
+  // background to match the card's width.  For the NTP toolbar, extend the
+  // frame downward so that it covers the portion of the card frame that
+  // overlaps with the content snapshot.
+  UIView* toolbarView = [_toolbarController view];
+  UIView* displayView = _activeCardSet.displayView;
+  CGRect screenToolbarFrame = [displayView convertRect:toolbarView.frame
+                                              fromView:toolbarView.superview];
+  CGFloat bottomOutset = [self.transitionToolbarController
+                             isKindOfClass:[NewTabPageToolbarController class]]
+                             ? -kCardFrameImageSnapshotOverlap
+                             : 0.0;
+  UIEdgeInsets screenToolbarFrameOutsets =
+      UIEdgeInsetsMake(0.0, kCardFrameInset - kCardImageInsets.left,
+                       bottomOutset, kCardFrameInset - kCardImageInsets.right);
+  screenToolbarFrame =
+      UIEdgeInsetsInsetRect(screenToolbarFrame, screenToolbarFrameOutsets);
+  CGPoint screenCardOrigin =
+      CGPointMake(displayView.bounds.origin.x - kCardImageInsets.left,
+                  displayView.bounds.origin.y - kCardImageInsets.top);
+  screenToolbarFrame = CGRectOffset(
+      screenToolbarFrame, -(screenCardOrigin.x + cardTabOriginOffset.dx),
+      -(screenCardOrigin.y + cardTabOriginOffset.dy));
+
+  // The frame should interpolate to the frame of the card's tab view.
+  CGRect cardToolbarFrame =
+      CGRectInset(cardFrame, kCardFrameInset, kCardFrameInset);
+  cardToolbarFrame.size.height = kCardImageInsets.top - kCardFrameInset;
+  cardToolbarFrame = CGRectOffset(
+      cardToolbarFrame, -(cardFrame.origin.x + cardTabOriginOffset.dx),
+      -(cardFrame.origin.y + cardTabOriginOffset.dy));
+
+  // Calculate colors for the crossfade.
+  UIColor* cardBackgroundColor =
+      [self isCurrentSetIncognito]
+          ? [UIColor colorWithWhite:kCardFrameBackgroundBrightnessIncognito
+                              alpha:1.0]
+          : [UIColor colorWithWhite:kCardFrameBackgroundBrightness alpha:1.0];
+  UIColor* toolbarBackgroundColor = cardBackgroundColor;
+  if ([self.transitionToolbarController
+          isKindOfClass:[NewTabPageToolbarController class]]) {
+    // Use white for the non-incognito NTP toolbar.
+    toolbarBackgroundColor = [UIColor whiteColor];
+  } else if (self.transitionToolbarController.backgroundView.hidden ||
+             self.transitionToolbarController.backgroundView.alpha == 0) {
+    // If the background view isn't visible, use the base toolbar view's
+    // background color.
+    toolbarBackgroundColor =
+        self.transitionToolbarController.view.backgroundColor;
+  }
+
+  // Create frame animation.
+  CFTimeInterval duration = ios::material::kDuration1;
+  CAMediaTimingFunction* timingFunction =
+      ios::material::TimingFunction(ios::material::CurveEaseInOut);
+  BOOL isPresentingStackView =
+      (transitionStyle == STACK_TRANSITION_STYLE_PRESENTING);
+  CGRect beginFrame =
+      isPresentingStackView ? screenToolbarFrame : cardToolbarFrame;
+  CGRect endFrame =
+      isPresentingStackView ? cardToolbarFrame : screenToolbarFrame;
+  CAAnimation* frameAnimation = FrameAnimationMake(
+      self.dummyToolbarBackgroundView.layer, beginFrame, endFrame);
+  frameAnimation.duration = duration;
+  frameAnimation.timingFunction = timingFunction;
+
+  // Create color animation.
+  UIColor* beginColor =
+      isPresentingStackView ? toolbarBackgroundColor : cardBackgroundColor;
+  UIColor* endColor =
+      isPresentingStackView ? cardBackgroundColor : toolbarBackgroundColor;
+  CABasicAnimation* colorAnimation =
+      [CABasicAnimation animationWithKeyPath:@"backgroundColor"];
+  colorAnimation.fromValue = reinterpret_cast<id>(beginColor.CGColor);
+  colorAnimation.toValue = reinterpret_cast<id>(endColor.CGColor);
+  colorAnimation.fillMode = kCAFillModeBoth;
+  colorAnimation.removedOnCompletion = NO;
+  colorAnimation.duration = duration;
+  colorAnimation.timingFunction = timingFunction;
+
+  // Create corner radius animation.
+  CGFloat toolbarCornerRadius = toolbarView.layer.cornerRadius;
+  CGFloat beginCornerRadius =
+      isPresentingStackView ? toolbarCornerRadius : kCardFrameCornerRadius;
+  CGFloat endCornerRadius =
+      isPresentingStackView ? kCardFrameCornerRadius : toolbarCornerRadius;
+  CABasicAnimation* cornerRadiusAnimation =
+      [CABasicAnimation animationWithKeyPath:@"cornerRadius"];
+  cornerRadiusAnimation.fromValue = @(beginCornerRadius);
+  cornerRadiusAnimation.toValue = @(endCornerRadius);
+  cornerRadiusAnimation.fillMode = kCAFillModeBoth;
+  cornerRadiusAnimation.removedOnCompletion = NO;
+  cornerRadiusAnimation.duration = duration;
+  cornerRadiusAnimation.timingFunction = timingFunction;
+
+  // Add animations.
+  CAAnimation* animation = AnimationGroupMake(
+      @[ frameAnimation, colorAnimation, cornerRadiusAnimation ]);
+  [self.dummyToolbarBackgroundView.layer
+      addAnimation:animation
+            forKey:kDummyToolbarBackgroundViewAnimationKey];
+}
+
+- (void)reverseDummyToolbarBackgroundViewAnimation {
+  ReverseAnimationsForKeyForLayers(kDummyToolbarBackgroundViewAnimationKey,
+                                   @[ self.dummyToolbarBackgroundView.layer ]);
+}
+
+- (void)animateTransitionToolbarWithCardFrame:(CGRect)cardFrame
+                              transitionStyle:
+                                  (StackTransitionStyle)transitionStyle {
+  // Add the transition toolbar and update its frame.
+  CGFloat toolbarHeight =
+      self.transitionToolbarController.view.frame.size.height;
+  [_activeCardSet.displayView
+      insertSubview:self.transitionToolbarController.view
+       aboveSubview:_activeCardSet.currentCard.view];
+  CGRect toolbarFrame =
+      [_activeCardSet.displayView convertRect:[_toolbarController view].frame
+                                     fromView:self.view];
+  CGFloat heightDifference = toolbarFrame.size.height - toolbarHeight;
+  toolbarFrame.origin.y += heightDifference;
+  toolbarFrame.size.height -= heightDifference;
+  self.transitionToolbarController.view.frame = toolbarFrame;
+
+  // The toolbar should animate such that its frame interpolates between the
+  // normal toolbar frame at the top of the screen and the frame of the current
+  // card's tab view.
+  CGRect screenToolbarFrame = self.transitionToolbarController.view.frame;
+  CGFloat cardTabHeight = kCardImageInsets.top - kCardFrameInset;
+  CGRect cardToolbarFrame =
+      CGRectInset(cardFrame, kCardFrameInset, kCardFrameInset);
+  cardToolbarFrame.size.height = cardTabHeight;
+
+  // Add animations.
+  BOOL isPresentingStackView =
+      (transitionStyle == STACK_TRANSITION_STYLE_PRESENTING);
+  ToolbarTransitionStyle style = isPresentingStackView
+                                     ? TOOLBAR_TRANSITION_STYLE_TO_STACK_VIEW
+                                     : TOOLBAR_TRANSITION_STYLE_TO_BVC;
+  CGRect beginFrame =
+      isPresentingStackView ? screenToolbarFrame : cardToolbarFrame;
+  CGRect endFrame =
+      isPresentingStackView ? cardToolbarFrame : screenToolbarFrame;
+  [self.transitionToolbarController animateTransitionWithBeginFrame:beginFrame
+                                                           endFrame:endFrame
+                                                    transitionStyle:style];
+}
+
+- (void)dismissWithSelectedTabAnimation {
+  if (_isBeingDismissed || _activeCardSet.closingCard ||
+      !_activeCardSet.cards.count) {
+    return;
+  }
+  DCHECK(_isActive);
+  [self prepareForDismissal];
+  _isBeingDismissed = YES;
+  // Once the stack view is starting to be dismissed, stop loading cards in the
+  // background.
+  [NSObject cancelPreviousPerformRequestsWithTarget:self];
+
+  [_delegate tabSwitcher:self
+      dismissTransitionWillStartWithActiveModel:_activeCardSet.tabModel];
+
+  [self animateTransitionWithStyle:STACK_TRANSITION_STYLE_DISMISSING];
+}
+
+- (std::vector<LayoutRect>)cardTransitionLayouts {
+  std::vector<LayoutRect> cardLayouts;
+  UIView* activeSetView = _activeCardSet.displayView;
+
+  // Setting a card's layout to |fullscreenLayout| will scale the content
+  // snapshot such that it will fill the entire portion of the screen below the
+  // toolbar.  Used for the current card.
+  LayoutRect fullscreenLayout = LayoutRectZero;
+  fullscreenLayout.boundingWidth = CGRectGetWidth(activeSetView.bounds);
+  fullscreenLayout.position.leading = -UIEdgeInsetsGetLeading(kCardImageInsets);
+  fullscreenLayout.position.originY = -kCardImageInsets.top;
+  fullscreenLayout.size.width = fullscreenLayout.boundingWidth +
+                                kCardImageInsets.left + kCardImageInsets.right;
+  fullscreenLayout.size.height = CGRectGetHeight(activeSetView.bounds) +
+                                 kCardImageInsets.top + kCardImageInsets.bottom;
+
+  // Cards above the current card (in z-index terms) should start/end offscreen.
+  // Also account for the shadow so that the shadows cast by offscreen cards are
+  // not visible at the beginning/end of the animation.
+  CGFloat viewportLength =
+      [self scrollLength:activeSetView.bounds.size] + kCardShadowThickness;
+  LayoutRect offscreenLayout = fullscreenLayout;
+  if (IsPortrait()) {
+    offscreenLayout.position.originY += viewportLength + kCardImageInsets.top;
+  } else {
+    offscreenLayout.position.leading +=
+        viewportLength + UIEdgeInsetsGetLeading(kCardImageInsets);
+  }
+
+  // Cards below the current card (in z-index terms) should be top-aligned with
+  // the toolbar and at the final card size.
+  LayoutRect cardLayout = LayoutRectZero;
+  cardLayout.boundingWidth = CGRectGetWidth(activeSetView.bounds);
+  cardLayout.size = [self cardSize];
+  cardLayout.position.leading = ios_internal::page_animation_util::kCardMargin;
+  cardLayout.position.originY = -kCardImageInsets.top;
+
+  for (StackCard* card in _activeCardSet.cards) {
+    if (card == _activeCardSet.currentCard) {
+      // Current card takes the full screen.
+      cardLayout = fullscreenLayout;
+    } else if (LayoutRectEqualToRect(cardLayout, fullscreenLayout)) {
+      // The card after the current card animates from off screen.
+      cardLayout = offscreenLayout;
+    }
+    cardLayouts.push_back(cardLayout);
+  }
+
+  return cardLayouts;
+}
+
+- (Tab*)dismissWithNewTabAnimationToModel:(TabModel*)targetModel
+                                  withURL:(const GURL&)url
+                                  atIndex:(NSUInteger)position
+                               transition:(ui::PageTransition)transition {
+  if (_isBeingDismissed)
+    return NULL;
+  if ([_activeCardSet tabModel] != targetModel)
+    [self setActiveCardSet:[self inactiveCardSet]];
+  return [self dismissWithNewTabAnimation:url
+                                  atIndex:position
+                               transition:transition];
+}
+
+- (void)setLastTapPoint:(id)sender {
+  UIView* parentView = nil;
+  CGPoint center;
+  if ([sender isKindOfClass:[UIView class]]) {
+    center = [sender center];
+    parentView = [sender superview];
+  }
+  if ([sender isKindOfClass:[ToolsMenuViewItem class]]) {
+    parentView = [[sender tableViewCell] superview];
+    center = [[sender tableViewCell] center];
+  }
+
+  if (parentView) {
+    CGPoint viewCoordinate = [parentView convertPoint:center toView:self.view];
+    _lastTapPoint = viewCoordinate;
+  }
+}
+
+- (Tab*)dismissWithNewTabAnimation:(const GURL&)URL
+                           atIndex:(NSUInteger)position
+                        transition:(ui::PageTransition)transition {
+  // This helps smooth out the animation.
+  [[_scrollView layer] setShouldRasterize:YES];
+  if (_isBeingDismissed)
+    return NULL;
+  DCHECK(_isActive);
+  [self prepareForDismissal];
+  _isBeingDismissed = YES;
+  [self setNeedsStatusBarAppearanceUpdate];
+  DCHECK(URL.is_valid());
+  // Stop pre-loading cards.
+  [NSObject cancelPreviousPerformRequestsWithTarget:self];
+
+  // This uses a custom animation, so ignore the change that would be triggered
+  // by adding a new tab to the model. This is left on since the stack view is
+  // going away at this point, so staying in sync doesn't matter any more.
+  [_activeCardSet setIgnoresTabModelChanges:YES];
+  if (position == NSNotFound)
+    position = [_activeCardSet.tabModel count];
+  DCHECK(position <= [_activeCardSet.tabModel count]);
+
+  Tab* tab = [_activeCardSet.tabModel insertOrUpdateTabWithURL:URL
+                                                      referrer:web::Referrer()
+                                                    transition:transition
+                                                    windowName:nil
+                                                        opener:nil
+                                                   openedByDOM:NO
+                                                       atIndex:position
+                                                  inBackground:NO];
+  [_activeCardSet.tabModel setCurrentTab:tab];
+
+  [_delegate tabSwitcher:self
+      dismissTransitionWillStartWithActiveModel:_activeCardSet.tabModel];
+
+  CGFloat statusBarHeight = StatusBarHeight();
+  CGRect viewBounds, remainder;
+  CGRectDivide([self.view bounds], &remainder, &viewBounds, statusBarHeight,
+               CGRectMinYEdge);
+  UIImageView* newCard =
+      [[[UIImageView alloc] initWithFrame:viewBounds] autorelease];
+  // Temporarily resize the tab's view to ensure it matches the card while
+  // generating a snapshot, but then restore the original frame.
+  CGRect originalTabFrame = [tab view].frame;
+  [tab view].frame = viewBounds;
+  newCard.image = [tab updateSnapshotWithOverlay:YES visibleFrameOnly:YES];
+  [tab view].frame = originalTabFrame;
+  newCard.center =
+      CGPointMake(CGRectGetMidX(viewBounds), CGRectGetMidY(viewBounds));
+  [self.view addSubview:newCard];
+
+  void (^completionBlock)(void) = ^{
+    [newCard removeFromSuperview];
+    [[_scrollView layer] setShouldRasterize:NO];
+    [_delegate tabSwitcherDismissTransitionDidEnd:self];
+  };
+
+  CGPoint origin = _lastTapPoint;
+  _lastTapPoint = CGPointZero;
+  ios_internal::page_animation_util::AnimateInPaperWithAnimationAndCompletion(
+      newCard, -statusBarHeight,
+      newCard.frame.size.height - newCard.image.size.height, origin,
+      [self isCurrentSetIncognito], nil, completionBlock);
+  // TODO(stuartmorgan): Animate the other set off to the side.
+
+  return tab;
+}
+
+#pragma mark UIGestureRecognizerDelegate methods
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer*)recognizer
+       shouldReceiveTouch:(UITouch*)touch {
+  // Don't swallow any touches while the tools popup menu is open.
+  if ([_toolbarController toolsPopupController])
+    return NO;
+
+  if ((recognizer == _pinchRecognizer) ||
+      (recognizer == _swipeGestureRecognizer.get()))
+    return YES;
+
+  // Only the mode switch recognizer should be triggered in the inactive deck
+  // region (and it should only be triggered there).
+  CGPoint touchLocation = [touch locationInView:_scrollView];
+  BOOL inInactiveDeckRegion =
+      CGRectContainsPoint([self inactiveDeckRegion], touchLocation);
+  if (recognizer == _modeSwitchRecognizer.get())
+    return inInactiveDeckRegion;
+  else if (inInactiveDeckRegion)
+    return NO;
+
+  // Extract the card on which the touch is occurring.
+  CardView* cardView = nil;
+  StackCard* card = nil;
+  if (recognizer == _swipeDismissesCardRecognizer.get()) {
+    UIView* activeView = _activeCardSet.displayView;
+    CGPoint locationInActiveView = [touch locationInView:activeView];
+    NSUInteger cardIndex = [self indexOfCardAtPoint:locationInActiveView];
+    // |_swipeDismissesCardRecognizer| is interested only in touches that are
+    // on cards in the active set.
+    if (cardIndex == NSNotFound)
+      return NO;
+    DCHECK(cardIndex < [[_activeCardSet cards] count]);
+    card = [[_activeCardSet cards] objectAtIndex:cardIndex];
+    // This case seems like it should never happen, but it can be easily
+    // handled anyway.
+    if (![card viewIsLive])
+      return YES;
+    cardView = card.view;
+  } else {
+    // The recognizer is one of those attached to the card.
+    DCHECK([recognizer.view isKindOfClass:[CardView class]]);
+    cardView = (CardView*)recognizer.view;
+    card = [self cardForView:cardView];
+  }
+
+  // Prevent taps/presses in an uncollapsed card's close button from being
+  // swallowed by the swipe-triggers-dismissal long press recognizer or
+  // the card's tap/long press recognizer.
+  if (CGRectContainsPoint([cardView closeButtonFrame],
+                          [touch locationInView:cardView]) &&
+      card && ![_activeCardSet cardIsCollapsed:card])
+    return NO;
+
+  return YES;
+}
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer*)gestureRecognizer
+    shouldRecognizeSimultaneouslyWithGestureRecognizer:
+        (UIGestureRecognizer*)otherGestureRecognizer {
+  // Pinch and scroll must be allowed to recognize simultaneously to enable
+  // smooth transitioning between scrolling and pinching.
+  BOOL pinchRecognizerInvolved = (gestureRecognizer == _pinchRecognizer ||
+                                  otherGestureRecognizer == _pinchRecognizer);
+  BOOL scrollRecognizerInvolved =
+      (gestureRecognizer == _scrollGestureRecognizer ||
+       otherGestureRecognizer == _scrollGestureRecognizer);
+  if (pinchRecognizerInvolved && scrollRecognizerInvolved)
+    return YES;
+
+  // Swiping must be allowed to recognize simultaneously with the recognizer of
+  // long presses that turn ambiguous swipes into card dismissals.
+  BOOL swipeRecognizerInvolved =
+      (gestureRecognizer == _swipeGestureRecognizer ||
+       otherGestureRecognizer == _swipeGestureRecognizer);
+  BOOL swipeDismissesCardRecognizerInvolved =
+      (gestureRecognizer == _swipeDismissesCardRecognizer.get() ||
+       otherGestureRecognizer == _swipeDismissesCardRecognizer.get());
+  if (swipeRecognizerInvolved && swipeDismissesCardRecognizerInvolved)
+    return YES;
+
+  // The swipe-triggers-card-dismissal long press recognizer must be allowed to
+  // recognize simultaneously with the cards' long press recognizers that
+  // trigger show-more-of-card.
+  BOOL longPressRecognizerInvolved =
+      ([gestureRecognizer isKindOfClass:[UILongPressGestureRecognizer class]] ||
+       [otherGestureRecognizer
+           isKindOfClass:[UILongPressGestureRecognizer class]]);
+  if (swipeDismissesCardRecognizerInvolved && longPressRecognizerInvolved)
+    return YES;
+
+  return NO;
+}
+
+#pragma mark Action Handlers
+
+- (void)closeTab:(id)sender {
+  // Don't close any tabs mid-dismissal.
+  if (_isBeingDismissed)
+    return;
+
+  // Remove the frame animation before adding the fade out animation.
+  DCHECK([sender isKindOfClass:[CardView class]]);
+  CardView* cardView = static_cast<CardView*>(sender);
+  [cardView removeFrameAnimation];
+
+  base::RecordAction(UserMetricsAction("MobileStackViewCloseTab"));
+  StackCard* card = [self cardForView:cardView];
+  DCHECK(card);
+  NSUInteger tabIndex = [_activeCardSet.cards indexOfObject:card];
+  if (tabIndex == NSNotFound)
+    return;
+
+  // TODO(blundell): Crashes have been seen wherein |tabIndex| is out of bounds
+  // of the TabModel's array. It is not currently understood how this case
+  // occurs. To work around these crashes, close the tab only if it is indeed
+  // the tab that corresponds to this card; otherwise, remove the card directly
+  // without modifying the tab model. b/8321162
+  BOOL cardCorrespondsToTab = NO;
+  if (tabIndex < [_activeCardSet.tabModel count]) {
+    Tab* tab = [_activeCardSet.tabModel tabAtIndex:tabIndex];
+    cardCorrespondsToTab = (card.tabID == reinterpret_cast<NSUInteger>(tab));
+  }
+
+  _activeCardSet.closingCard = card;
+  if (cardCorrespondsToTab) {
+    [_activeCardSet.tabModel closeTabAtIndex:tabIndex];
+  } else {
+    if (tabIndex < [_activeCardSet.tabModel count])
+      DLOG(ERROR) << "Closed a card that didn't match the tab at its index";
+    else
+      DLOG(ERROR) << "Closed card at an index out of range of the tab model";
+    [_activeCardSet removeCardAtIndex:tabIndex];
+  }
+}
+
+- (void)handleLongPressFrom:(UIGestureRecognizer*)recognizer {
+  DCHECK(!_isBeingDismissed);
+  DCHECK(_isActive);
+
+  if (recognizer == _swipeDismissesCardRecognizer.get())
+    return;
+
+  UIGestureRecognizerState state = [recognizer state];
+  if (state != UIGestureRecognizerStateBegan)
+    return;
+  if ([recognizer numberOfTouches] == 0)
+    return;
+
+  // Don't take action on a card that is in the inactive stack, collapsed, or
+  // the last card.
+  CardView* cardView = (CardView*)recognizer.view;
+  StackCard* card = [self cardForView:cardView];
+  DCHECK(card);
+  NSUInteger cardIndex = [[_activeCardSet cards] indexOfObject:card];
+  DCHECK(cardIndex != NSNotFound);
+  NSUInteger numCards = [[_activeCardSet cards] count];
+  UIView* activeView = _activeCardSet.displayView;
+
+  if ([cardView superview] != activeView ||
+      [_activeCardSet cardIsCollapsed:card] || cardIndex == (numCards - 1))
+    return;
+
+  // Defer hiding the views of any cards that will be covered after the scroll
+  // until the animation completes, as otherwise these cards immediately
+  // disappear at the start of the animation.
+  _activeCardSet.defersCardHiding = YES;
+  [UIView animateWithDuration:kDefaultAnimationDuration
+      animations:^{
+        [_activeCardSet scrollCardAtIndex:cardIndex + 1 awayFromNeighbor:YES];
+      }
+      completion:^(BOOL finished) {
+        _activeCardSet.defersCardHiding = NO;
+      }];
+}
+
+- (void)handlePinchFrom:(UIPinchGestureRecognizer*)recognizer {
+  DCHECK(!_isBeingDismissed);
+  DCHECK(_isActive);
+  UIView* currentView = _activeCardSet.displayView;
+  DCHECK(recognizer.view == currentView);
+
+  [_gestureStateTracker setPinching:YES];
+  // Disable scrollView scrolling while a pinch is occurring. If the user lifts
+  // a finger while pinching, callbacks to |handlePinchFrom:| will continue to
+  // be made, and the code below will ensure that the cards get scrolled
+  // properly.
+  // TODO(blundell): Try to figure out how to re-enable deceleration for
+  // such scrolls. b/5976932
+  if ([_scrollView isScrollEnabled]) {
+    [_scrollView setScrollEnabled:NO];
+    _ignoreScrollCallbacks = YES;
+    [self recenterScrollViewIfNecessary];
+  }
+
+  UIGestureRecognizerState state = [recognizer state];
+  if ((state == UIGestureRecognizerStateCancelled) ||
+      (state == UIGestureRecognizerStateEnded)) {
+    [_gestureStateTracker setScrollingInPinch:NO];
+    [self pinchEnded];
+    _ignoreScrollCallbacks = NO;
+    [_scrollView setScrollEnabled:YES];
+    [_gestureStateTracker setPinching:NO];
+    return;
+  }
+
+  DCHECK((state == UIGestureRecognizerStateBegan) ||
+         (state == UIGestureRecognizerStateChanged));
+
+  CardStackPinchGestureRecognizer* pinchGestureRecognizer =
+      base::mac::ObjCCastStrict<CardStackPinchGestureRecognizer>(recognizer);
+  if ([pinchGestureRecognizer numberOfActiveTouches] < 2) {
+    // Clear the pinch card indices so that they are refetched if the user puts
+    // a second finger back down.
+    [_gestureStateTracker setFirstPinchCardIndex:NSNotFound];
+    [_gestureStateTracker setSecondPinchCardIndex:NSNotFound];
+
+    // The recognizer may continue to register two touches for a short period
+    // after one of the touches is no longer active. Wait until there is only
+    // one touch to be sure of accessing the information for the right touch.
+    if ([recognizer numberOfTouches] != 1) {
+      return;
+    }
+
+    CGPoint fingerLocation =
+        [_pinchRecognizer locationOfTouch:0 inView:currentView];
+    CGFloat fingerOffset = [self scrollOffsetAmountForPoint:fingerLocation];
+    if (![_gestureStateTracker scrollingInPinch]) {
+      NSUInteger scrolledIndex = [self indexOfCardAtPoint:fingerLocation];
+      if (scrolledIndex != NSNotFound) {
+        // Begin the scroll.
+        [_gestureStateTracker setScrollCardIndex:scrolledIndex];
+        [_gestureStateTracker setPreviousFirstPinchOffset:fingerOffset];
+        [_gestureStateTracker setPreviousScrollTime:(base::TimeTicks::Now())];
+        [_gestureStateTracker setScrollingInPinch:YES];
+        // Animate back overpinch as necessary.
+        [self pinchEnded];
+      }
+      return;
+    }
+
+    // Perform the scroll.
+    CGFloat delta =
+        fingerOffset - [_gestureStateTracker previousFirstPinchOffset];
+    NSInteger scrolledIndex = [_gestureStateTracker scrollCardIndex];
+    DCHECK(scrolledIndex != NSNotFound);
+    [_activeCardSet scrollCardAtIndex:scrolledIndex
+                              byDelta:delta
+                 allowEarlyOverscroll:YES
+                    decayOnOverscroll:YES
+                   scrollLeadingCards:YES];
+    [_gestureStateTracker setPreviousFirstPinchOffset:fingerOffset];
+    [_gestureStateTracker updateScrollVelocityWithScrollDistance:delta];
+    [_gestureStateTracker setPreviousScrollTime:(base::TimeTicks::Now())];
+    return;
+  }
+
+  [_gestureStateTracker setScrollingInPinch:NO];
+
+  DCHECK([recognizer numberOfTouches] >= 2);
+  // Extract first and second offsets of the pinch.
+  CGPoint firstPinchPoint = [recognizer locationOfTouch:0 inView:currentView];
+  CGPoint secondPinchPoint = [recognizer locationOfTouch:1 inView:currentView];
+  if ([self scrollOffsetAmountForPoint:firstPinchPoint] >
+      [self scrollOffsetAmountForPoint:secondPinchPoint]) {
+    CGPoint temp = firstPinchPoint;
+    firstPinchPoint = secondPinchPoint;
+    secondPinchPoint = temp;
+  }
+  CGFloat firstOffset = [self scrollOffsetAmountForPoint:firstPinchPoint];
+  CGFloat secondOffset = [self scrollOffsetAmountForPoint:secondPinchPoint];
+  NSInteger firstPinchCardIndex = [_gestureStateTracker firstPinchCardIndex];
+  NSInteger secondPinchCardIndex = [_gestureStateTracker secondPinchCardIndex];
+
+  // Pinch does not actually cause cards to move until user has started moving
+  // fingers with each finger on a distinct card.
+  if ((state == UIGestureRecognizerStateBegan) ||
+      (firstPinchCardIndex == NSNotFound) ||
+      (secondPinchCardIndex == NSNotFound) ||
+      (firstPinchCardIndex == secondPinchCardIndex)) {
+    [_gestureStateTracker
+        setFirstPinchCardIndex:[self indexOfCardAtPoint:firstPinchPoint]];
+    [_gestureStateTracker
+        setSecondPinchCardIndex:[self indexOfCardAtPoint:secondPinchPoint]];
+    [_gestureStateTracker setPreviousFirstPinchOffset:firstOffset];
+    [_gestureStateTracker setPreviousSecondPinchOffset:secondOffset];
+    return;
+  }
+
+  DCHECK(firstPinchCardIndex != NSNotFound);
+  DCHECK(secondPinchCardIndex != NSNotFound);
+  DCHECK(firstPinchCardIndex < secondPinchCardIndex);
+
+  CGFloat firstDelta =
+      firstOffset - [_gestureStateTracker previousFirstPinchOffset];
+  CGFloat secondDelta =
+      secondOffset - [_gestureStateTracker previousSecondPinchOffset];
+  [_activeCardSet.stackModel handleMultitouchWithFirstDelta:firstDelta
+                                                secondDelta:secondDelta
+                                             firstCardIndex:firstPinchCardIndex
+                                            secondCardIndex:secondPinchCardIndex
+                                           decayOnOverpinch:YES];
+
+  [_activeCardSet updateCardVisibilities];
+
+  [_gestureStateTracker setPreviousFirstPinchOffset:firstOffset];
+  [_gestureStateTracker setPreviousSecondPinchOffset:secondOffset];
+}
+
+- (void)handleTapFrom:(UITapGestureRecognizer*)recognizer {
+  DCHECK(!_isBeingDismissed);
+  DCHECK(_isActive);
+  if (recognizer.state != UIGestureRecognizerStateEnded)
+    return;
+
+  if (recognizer == _modeSwitchRecognizer.get()) {
+    DCHECK(CGRectContainsPoint([self inactiveDeckRegion],
+                               [recognizer locationInView:_scrollView]));
+    [self setActiveCardSet:[self inactiveCardSet]];
+    return;
+  }
+
+  CardView* cardView = (CardView*)recognizer.view;
+  UIView* activeView = _activeCardSet.displayView;
+  if ([cardView superview] != activeView)
+    return;
+
+  // Don't open the card if it's collapsed behind its succeeding neighbor, as
+  // this was likely just a misplaced tap in that case.
+  StackCard* card = [self cardForView:cardView];
+  // TODO(blundell) : The card should not be nil here, see b/6759862.
+  if (!card || [_activeCardSet cardIsCollapsed:card])
+    return;
+
+  DCHECK(!CGRectContainsPoint([cardView closeButtonFrame],
+                              [recognizer locationInView:cardView]));
+
+  if (self.transitionStyle == STACK_TRANSITION_STYLE_NONE) {
+    [_activeCardSet setCurrentCard:card];
+    [self dismissWithSelectedTabAnimation];
+  } else if ([card isEqual:_activeCardSet.currentCard]) {
+    // If the currently selected card is tapped mid-presentation animation,
+    // simply reverse the animation immediately if it hasn't already been
+    // reversed.
+    if (self.transitionStyle != STACK_TRANSITION_STYLE_DISMISSING)
+      [self cancelTransitionAnimation];
+  } else {
+    // If a new card is tapped mid-presentation, store a reference to the card
+    // so that it can be selected upon dismissal in the presentation's
+    // completion block.
+    self.transitionTappedCard = card;
+  }
+}
+
+- (void)handlePanFrom:(UIPanGestureRecognizer*)gesture {
+  DCHECK(!_isBeingDismissed);
+  DCHECK(_isActive);
+  // Check if the gesture's initial state needs to be set.
+  if (gesture.state == UIGestureRecognizerStateBegan ||
+      [_gestureStateTracker resetSwipedCardOnNextSwipe]) {
+    // Save first position to be able to calculate swipe distances later.
+    BOOL isPortrait =
+        UIInterfaceOrientationIsPortrait(_lastInterfaceOrientation);
+    // TODO(crbug.com/228456): All of the swipe code should be operating on the
+    // swipe's first touch in order to avoid the "dancing swipe" bug. Note that
+    // this might involve adding some checks to handle the case where the number
+    // of touches in the swipe is 0.
+    CGPoint point = [gesture locationInView:_scrollView];
+    [_gestureStateTracker
+        setSwipeStartingPosition:(isPortrait ? point.x : point.y)];
+
+    // Save the index of the card on which the swipe started (if any).
+    CGPoint activePoint = [gesture locationInView:_activeCardSet.displayView];
+    NSUInteger cardIndex = [self indexOfCardAtPoint:activePoint];
+    [_gestureStateTracker setSwipedCardIndex:cardIndex];
+
+    [_gestureStateTracker setResetSwipedCardOnNextSwipe:NO];
+    // Signal that the swipe is beginning so that the type of the swipe will be
+    // calculated on the next callback (note that it is too early to calculate
+    // it here as the direction of the swipe, which is a component used in the
+    // calculation, is currently unknown).
+    [_gestureStateTracker setSwipeIsBeginning:YES];
+    // Determine whether a swipe of ambiguous intent should change decks or
+    // dismiss a card.
+    UIGestureRecognizerState state = [_swipeDismissesCardRecognizer state];
+    BOOL ambiguousSwipeChangesDecks =
+        (state != UIGestureRecognizerStateBegan &&
+         state != UIGestureRecognizerStateChanged);
+    [_gestureStateTracker
+        setAmbiguousSwipeChangesDecks:ambiguousSwipeChangesDecks];
+    return;
+  }
+
+  if ([_gestureStateTracker swipeIsBeginning]) {
+    [self determineSwipeType:gesture];
+    [_gestureStateTracker setSwipeIsBeginning:NO];
+  }
+
+  if ([_gestureStateTracker swipeChangesDecks]) {
+    [self swipeDeck:gesture];
+    return;
+  }
+
+  // Check whether the swipe is actually on a card.
+  NSUInteger cardIndex = [_gestureStateTracker swipedCardIndex];
+  if (cardIndex == NSNotFound) {
+    [_gestureStateTracker setResetSwipedCardOnNextSwipe:YES];
+    return;
+  }
+  // Take action only if the card being swiped is not collapsed.
+  DCHECK(cardIndex < [[_activeCardSet cards] count]);
+  StackCard* card = [[_activeCardSet cards] objectAtIndex:cardIndex];
+  if ([_activeCardSet cardIsCollapsed:card]) {
+    [_gestureStateTracker setResetSwipedCardOnNextSwipe:YES];
+    return;
+  }
+  // Remove the transition toolbar controller from the view hierarchy if the
+  // card swipe occurs while a transition animation is occurring.
+  if ([self.transitionToolbarController.view isDescendantOfView:self.view])
+    [self.transitionToolbarController.view removeFromSuperview];
+  [self swipeCard:gesture];
+}
+
+- (void)determineSwipeType:(UIPanGestureRecognizer*)gesture {
+  if (![self bothDecksShouldBeDisplayed]) {
+    [_gestureStateTracker setSwipeChangesDecks:NO];
+    return;
+  }
+
+  if ([_gestureStateTracker swipedCardIndex] == NSNotFound) {
+    [_gestureStateTracker setSwipeChangesDecks:YES];
+    return;
+  }
+
+  // The swipe is on a card. Check whether the intent of the swipe is
+  // ambiguous.
+  BOOL isPortrait = UIInterfaceOrientationIsPortrait(_lastInterfaceOrientation);
+  CGPoint swipePoint = [gesture locationInView:_scrollView];
+  CGFloat swipePosition = isPortrait ? swipePoint.x : swipePoint.y;
+  CGFloat swipeStartingPosition = [_gestureStateTracker swipeStartingPosition];
+  CGFloat swipeDistance = swipePosition - swipeStartingPosition;
+  if (UseRTLLayout() && isPortrait)
+    swipeDistance *= -1;
+  BOOL mainSetActive = (_activeCardSet == _mainCardSet);
+  BOOL swipeIntentIsAmbiguous = (mainSetActive && swipeDistance < 0.0) ||
+                                (!mainSetActive && swipeDistance > 0.0);
+
+  BOOL swipeChangesDecks =
+      swipeIntentIsAmbiguous ? [_gestureStateTracker ambiguousSwipeChangesDecks]
+                             : NO;
+  [_gestureStateTracker setSwipeChangesDecks:swipeChangesDecks];
+}
+
+- (CGFloat)distanceForSwipeToTriggerAction {
+  return ([self scrollBreadth:[self view].bounds.size] *
+          kSwipeCardScreenFraction);
+}
+
+- (BOOL)swipeShouldTriggerAction:(CGFloat)endingPosition {
+  CGFloat swipeStartingPosition = [_gestureStateTracker swipeStartingPosition];
+  CGFloat threshold = [self distanceForSwipeToTriggerAction];
+  return std::abs(endingPosition - swipeStartingPosition) > threshold;
+}
+
+- (void)swipeDeck:(UIPanGestureRecognizer*)gesture {
+  // StateBegan is handled by the caller handlePanFrom.
+  DCHECK(gesture.state != UIGestureRecognizerStateBegan);
+  // Swiping between decks should only be invoked when more than one deck is
+  // being displayed.
+  DCHECK([self bothDecksShouldBeDisplayed]);
+
+  CGPoint point = [gesture locationInView:_scrollView];
+  BOOL isPortrait = UIInterfaceOrientationIsPortrait(_lastInterfaceOrientation);
+  CGFloat position = isPortrait ? point.x : point.y;
+  CGFloat swipeStartingPosition = [_gestureStateTracker swipeStartingPosition];
+
+  // In portrait on RTL, the incognito card stack is laid out to the left of
+  // the maint stack, so invert the pan direction.
+  BOOL shouldInvert = UseRTLLayout() && isPortrait;
+
+  if (gesture.state == UIGestureRecognizerStateChanged) {
+    CGFloat offset = position - swipeStartingPosition;
+    // Decay drag if going off screen to mimic UIScrollView's bounce.
+    BOOL isIncognito = [self isCurrentSetIncognito];
+    if ((isIncognito && swipeStartingPosition > position) ||
+        (!isIncognito && swipeStartingPosition < position))
+      offset /= 2;
+    if (shouldInvert)
+      offset *= -1;
+    [self updateDeckAxisPositionsWithShiftAmount:offset];
+
+  } else if (gesture.state == UIGestureRecognizerStateEnded) {
+    if ([self swipeShouldTriggerAction:position]) {
+      // |topLeftCardSet| is the card set on the left in portrait and on top in
+      // landscape, and |bottomRightCardSet| is the card set on the right in
+      // portrait and the bottom in landscape.  If |position| is greater than
+      // |swipeStartingPosition|, the gesture is dragging |topLeftCardSet| into
+      // view. Otherwise, |bottomRightCardSet| is being dragged into view. Can't
+      // just flip the active card set because this swipe might be a bounce that
+      // is leaving the active card set unchanged.
+      CardSet* topLeftCardSet = shouldInvert ? _otrCardSet : _mainCardSet;
+      CardSet* bottomRightCardSet = shouldInvert ? _mainCardSet : _otrCardSet;
+      _activeCardSet = position > swipeStartingPosition ? topLeftCardSet
+                                                        : bottomRightCardSet;
+    }
+    [self displayActiveCardSet];
+  }
+}
+
+- (void)swipeCard:(UIPanGestureRecognizer*)gesture {
+  // StateBegan is handled by the caller handlePanFrom.
+  DCHECK(gesture.state != UIGestureRecognizerStateBegan);
+
+  CGPoint point = [gesture locationInView:_scrollView];
+  BOOL isPortrait = UIInterfaceOrientationIsPortrait(_lastInterfaceOrientation);
+  CGFloat position = isPortrait ? point.x : point.y;
+  CGFloat swipeStartingPosition = [_gestureStateTracker swipeStartingPosition];
+  CGFloat distanceMoved = fabs(position - swipeStartingPosition);
+
+  // Calculate fractions of animation breadth to trigger dismissal that have
+  // been covered so far.
+  CGFloat fractionOfAnimationBreadth =
+      distanceMoved /
+      ios_internal::page_animation_util::AnimateOutTransformBreadth();
+  // User can potentially move their finger further than animation breath/
+  // dismissal threshold distance. Ensure that these corner cases don't cause
+  // any unexpected behavior.
+  fractionOfAnimationBreadth =
+      std::min(fractionOfAnimationBreadth, CGFloat(1.0));
+
+  // Calculate direction of the swipe.
+  BOOL clockwise = position - swipeStartingPosition > 0;
+  if (!isPortrait)
+    clockwise = !clockwise;
+
+  NSUInteger swipedCardIndex = [_gestureStateTracker swipedCardIndex];
+  StackCard* card = [_activeCardSet.cards objectAtIndex:swipedCardIndex];
+  _activeCardSet.closingCard = card;
+
+  if (gesture.state == UIGestureRecognizerStateChanged) {
+    // Transform card along |AnimateOutTransform| by the fraction of the
+    // animation breadth that has been covered so far.
+    [card view].transform =
+        ios_internal::page_animation_util::AnimateOutTransform(
+            fractionOfAnimationBreadth, clockwise, isPortrait);
+    // Fade the card to become transparent at the conclusion of the animation,
+    // and the card's tab to become transparent at the time that the card
+    // reaches the threshold for being dismissed.
+    [card view].alpha = 1 - fractionOfAnimationBreadth;
+  } else {
+    if (gesture.state == UIGestureRecognizerStateEnded &&
+        [self swipeShouldTriggerAction:position]) {
+      // Track card if animation should dismiss in reverse from the norm of
+      // clockwise in portrait, counter-clockwise in landscape.
+      if ((isPortrait && !clockwise) || (!isPortrait && clockwise))
+        _reverseDismissCard.reset([card retain]);
+      // This will trigger the completion of the close card animation.
+      [self closeTab:card.view];
+    } else {
+      // Animate back to starting position.
+      [UIView animateWithDuration:kDefaultAnimationDuration
+          delay:0
+          options:UIViewAnimationCurveEaseOut
+          animations:^{
+            [card view].alpha = 1;
+            [[card view] setTabOpacity:1];
+            [card view].transform = CGAffineTransformIdentity;
+          }
+          completion:^(BOOL finished) {
+            _activeCardSet.closingCard = nil;
+          }];
+    }
+  }
+}
+
+- (StackCard*)cardForView:(CardView*)view {
+  // This isn't terribly efficient, but since it is only intended for use in
+  // response to a user action it's not worth the bookkeeping of a reverse
+  // mapping to make it constant time.
+  for (StackCard* card in _activeCardSet.cards) {
+    if (card.viewIsLive && card.view == view) {
+      return card;
+    }
+  }
+  return nil;
+}
+
+- (IBAction)chromeExecuteCommand:(id)sender {
+  int command = [sender tag];
+
+  switch (command) {
+    case IDC_SHOW_TOOLS_MENU:
+      [self showToolsMenuPopup];
+      break;
+    // Closing all while the main set is active closes everything, but closing
+    // all while incognito is active only closes incognito tabs.
+    case IDC_CLOSE_ALL_TABS:
+      DCHECK(![self isCurrentSetIncognito]);
+      [self removeAllCardsFromSet:_mainCardSet];
+      [self removeAllCardsFromSet:_otrCardSet];
+      break;
+    case IDC_CLOSE_ALL_INCOGNITO_TABS:
+      DCHECK([self isCurrentSetIncognito]);
+      [self removeAllCardsFromSet:_activeCardSet];
+      break;
+    case IDC_NEW_INCOGNITO_TAB:
+    case IDC_NEW_TAB:
+      // Ensure that the right mode is showing.
+      if ([self isCurrentSetIncognito] != (command == IDC_NEW_INCOGNITO_TAB))
+        [self setActiveCardSet:[self inactiveCardSet]];
+      [self setLastTapPoint:sender];
+      [self dismissWithNewTabAnimation:GURL(kChromeUINewTabURL)
+                               atIndex:NSNotFound
+                            transition:ui::PAGE_TRANSITION_TYPED];
+      break;
+    case IDC_TOGGLE_TAB_SWITCHER:
+      [self dismissWithSelectedTabAnimation];
+      break;
+    default:
+      [super chromeExecuteCommand:sender];
+      break;
+  }
+}
+
+- (void)showToolsMenuPopup {
+  base::scoped_nsobject<ToolsMenuContext> context(
+      [[ToolsMenuContext alloc] initWithDisplayView:[self view]]);
+  [context setInTabSwitcher:YES];
+  // When checking for the existence of tabs, catch the case where the main set
+  // is both active and empty, but the incognito set has some cards.
+  if (([[_activeCardSet cards] count] == 0) &&
+      (_activeCardSet == _otrCardSet || [[_otrCardSet cards] count] == 0))
+    [context setNoOpenedTabs:YES];
+  if (_activeCardSet == _otrCardSet)
+    [context setInIncognito:YES];
+  [_toolbarController showToolsMenuPopupWithContext:context];
+}
+
+#pragma mark Notification Handlers
+
+- (void)allModelTabsHaveClosed:(NSNotification*)notify {
+  // Early return if the stack view is not active.  This can sometimes occur if
+  // |clearInternalState| triggers the deletion of a tab model.
+  if (!_isActive)
+    return;
+
+  CardSet* closedSet =
+      (notify.object == [_mainCardSet tabModel]) ? _mainCardSet : _otrCardSet;
+
+  // If the tabModel that send the notification is not one handled by one of
+  // the two card sets, just return. This will happen when the otr tab model is
+  // deleted because the incognito profile is deleted.
+  if (notify.object != [closedSet tabModel])
+    return;
+
+  if (closedSet == _activeCardSet)
+    [self activeCardCountChanged];
+  for (UIView* card in [closedSet.displayView subviews]) {
+    [card removeFromSuperview];
+  }
+  [closedSet setIgnoresTabModelChanges:NO];
+  // No need to re-sync with the card set here, since the tab model (and thus
+  // the card set) is known to be empty.
+
+  // The animation of closing all the main set's cards interacts badly with the
+  // animation of switching to main-card-set-only mode, so if the incognito set
+  // finishes closing while the main set is still animating (in the case of
+  // closing all cards at once) wait until the main set finishes before updating
+  // the display (neccessary so the state is right if a new tab is opened).
+  if ((closedSet == _otrCardSet && ![_mainCardSet ignoresTabModelChanges]) ||
+      (closedSet == _mainCardSet && [[_otrCardSet cards] count] == 0)) {
+    [self displayMainCardSetOnly];
+  }
+
+  [_toolbarController setTabCount:[_activeCardSet.cards count]];
+}
+
+#pragma mark CardSetObserver Methods
+
+- (void)cardSet:(CardSet*)cardSet didAddCard:(StackCard*)newCard {
+  [self updateScrollViewContentSize];
+
+  if (cardSet == _activeCardSet) {
+    [self activeCardCountChanged];
+    [_toolbarController setTabCount:[_activeCardSet.cards count]];
+  }
+
+  // Place the card at the right destination point to animate in: staggered
+  // from its previous neighbor if it is the last card, or in the location of
+  // its successive neighbor (which will slide down to make room) otherwise.
+  NSArray* cards = [cardSet cards];
+  NSUInteger cardIndex = [cards indexOfObject:newCard];
+  CGFloat maxStagger = [[cardSet stackModel] maxStagger];
+
+  if (newCard == [cards lastObject]) {
+    if ([cards count] == 1) {
+      // Simply lay out the card.
+      [cardSet fanOutCards];
+    } else {
+      StackCard* previousCard = [cards objectAtIndex:cardIndex - 1];
+      BOOL isPortrait =
+          UIInterfaceOrientationIsPortrait(_lastInterfaceOrientation);
+      LayoutRect layout = previousCard.layout;
+      if (isPortrait)
+        layout.position.originY += maxStagger;
+      else
+        layout.position.leading += maxStagger;
+      newCard.layout = layout;
+    }
+
+  } else {
+    DCHECK(cardIndex != NSNotFound);
+    DCHECK(cardIndex + 1 < [cards count]);
+    newCard.layout = [[cards objectAtIndex:cardIndex + 1] layout];
+  }
+
+  // Animate the new card in at its destination location.
+  ios_internal::page_animation_util::AnimateInCardWithAnimationAndCompletion(
+      newCard.view, NULL, NULL);
+
+  // Set up the animation of the existing cards.
+  NSUInteger indexToScroll = cardIndex + 1;
+  CGFloat scrollAmount = maxStagger;
+  if (newCard == [cards lastObject] ||
+      [cardSet isCardInEndStaggerRegion:newCard]) {
+    // No scrolling actually needs to be done, although |scrollCardAtIndex:|
+    // still has to be called if the new card is not in the start stack in
+    // order to ensure that the end stack is re-laid out if necessary.
+    indexToScroll = cardIndex;
+    scrollAmount = 0;
+  }
+
+  // If the new card is in the start stack, just re-lay out the start stack.
+  // Otherwise, slide down the successive cards to make room and/or re-lay out
+  // the end stack. TODO(blundell): The animation is behaving incorrectly when
+  // the card being inserted is near the end stack: sometimes the slide down
+  // doesn't occur, and sometimes it overscrolls, causing a visible bounce.
+  void (^stackAnimation)(void) = ^{
+    if ([cardSet isCardInStartStaggerRegion:newCard]) {
+      [cardSet layOutStartStack];
+    } else {
+      [cardSet scrollCardAtIndex:indexToScroll
+                         byDelta:scrollAmount
+            allowEarlyOverscroll:NO
+               decayOnOverscroll:NO
+              scrollLeadingCards:YES];
+    }
+  };
+
+  cardSet.defersCardHiding = YES;
+  [UIView animateWithDuration:kDefaultAnimationDuration
+                        delay:0
+                      options:UIViewAnimationOptionBeginFromCurrentState
+                   animations:stackAnimation
+                   completion:^(BOOL) {
+                     cardSet.defersCardHiding = NO;
+                     if (cardSet == _activeCardSet) {
+                       // Ensure that state is properly reset if there was a
+                       // scroll/pinch occurring.
+                       [self scrollEnded];
+                     }
+                   }];
+}
+
+- (void)cardSet:(CardSet*)cardSet
+    willRemoveCard:(StackCard*)cardBeingRemoved
+           atIndex:(NSUInteger)index {
+  // All handlers working on that card must be stopped to prevent concurrency
+  // and/or UI inconcistencies.
+  if (cardSet == _activeCardSet) {
+    // Cancel any outstanding gestures that were tracking a card index, as they
+    // might have been operating on cards that no longer exist. Ideally, these
+    // events would allow the gestures to continue and just reset the cards on
+    // which they are operating. However, doing that correctly in all cases
+    // proves near-impossible: if the call to -disableGestureHandlers happens
+    // slightly too late, then a gesture callback could occur in the new state
+    // of the world with the gesture still operating on the old state of the
+    // world. Meanwhile if the call to -enableGestureHandlers happens
+    // slightly too early, then a gesture callback could occur while still in
+    // the old state of the world, meaning that the card being tracked would
+    // revert to the old (problematic) card.
+    [self disableGestureHandlers];
+  }
+}
+
+- (void)cardSet:(CardSet*)cardSet
+    didRemoveCard:(StackCard*)removedCard
+          atIndex:(NSUInteger)index {
+  if (cardSet == _activeCardSet) {
+    // Reenable the gesture handlers (disabled in
+    // -cardSet:willRemoveCard:atIndex). It is now safe to do so as the card
+    // that was being removed has been removed at this point.
+    [self enableGestureHandlers];
+    [_toolbarController setTabCount:[_activeCardSet.cards count]];
+  }
+
+  // If no view was ever created for this card, it's too late to make one. This
+  // can only happen if a tab is closed by something other than user action,
+  // and even then only if the card hasn't been pre-loaded yet, so not doing th
+  // animation isn't a problem.
+  if (removedCard.viewIsLive) {
+    // Determine what direction animation should rotate in. The norm is
+    // clockwise in portrait, counter-clockwise in landscape; however, it needs
+    // to be reversed if this animation is occurring as the conclusion of a
+    // swipe that went in the opposite direction from the norm.
+    BOOL isPortrait =
+        UIInterfaceOrientationIsPortrait(_lastInterfaceOrientation);
+    BOOL clockwise = isPortrait ? _reverseDismissCard != removedCard
+                                : _reverseDismissCard == removedCard;
+    [self animateOutCardView:removedCard.view
+                       delay:0
+                   clockwise:clockwise
+                  completion:nil];
+    // Reset |reverseDismissCard| if that card was the one dismissed.
+    if ((isPortrait && !clockwise) || (!isPortrait && clockwise))
+      _reverseDismissCard.reset();
+  }
+  // Nil out the the closing card after all closing animations have finished.
+  [CATransaction begin];
+  [CATransaction setCompletionBlock:^{
+    cardSet.closingCard = nil;
+  }];
+  // If the last incognito card closes, switch back to just the main set.
+  if ([cardSet.cards count] == 0 && cardSet == _otrCardSet.get()) {
+    [self displayMainCardSetOnly];
+  } else {
+    NSUInteger numCards = [[cardSet cards] count];
+    if (numCards == 0) {
+      // Commit the transaction before early return.
+      [CATransaction commit];
+      return;
+    }
+    if (index == numCards) {
+      // If the card that was closed was the last card and was in the start
+      // stack, the start stack might need to be re-laid out to show a
+      // previously hidden card.
+      if ([cardSet overextensionTowardStartOnCardAtIndex:numCards - 1]) {
+        [UIView animateWithDuration:kDefaultAnimationDuration
+                         animations:^{
+                           [cardSet layOutStartStack];
+                         }];
+      }
+    } else {
+      // Scroll up the card following the removed card to be placed where the
+      // removed card was.
+      LayoutRectPosition removedCardPosition = removedCard.layout.position;
+      LayoutRectPosition followingCardPosition =
+          [[cardSet cards][index] layout].position;
+      CGFloat scrollAmount =
+          [self scrollOffsetAmountForPosition:removedCardPosition] -
+          [self scrollOffsetAmountForPosition:followingCardPosition];
+      [cardSet updateShadowLayout];
+      [UIView animateWithDuration:kDefaultAnimationDuration
+                       animations:^{
+                         [cardSet scrollCardAtIndex:index
+                                            byDelta:scrollAmount
+                               allowEarlyOverscroll:YES
+                                  decayOnOverscroll:NO
+                                 scrollLeadingCards:NO];
+                         [cardSet updateShadowLayout];
+                       }];
+    }
+  }
+  [CATransaction commit];
+}
+
+- (void)cardSet:(CardSet*)cardSet displayedCard:(StackCard*)card {
+  // Add gesture recognizers to the card.
+  [card.view addCardCloseTarget:self action:@selector(closeTab:)];
+  [card.view addAccessibilityTarget:self
+                             action:@selector(accessibilityFocusedOnElement:)];
+
+  base::scoped_nsobject<UIGestureRecognizer> tapRecognizer([
+      [UITapGestureRecognizer alloc] initWithTarget:self
+                                             action:@selector(handleTapFrom:)]);
+  tapRecognizer.get().delegate = self;
+  [card.view addGestureRecognizer:tapRecognizer.get()];
+
+  base::scoped_nsobject<UIGestureRecognizer> longPressRecognizer(
+      [[UILongPressGestureRecognizer alloc]
+          initWithTarget:self
+                  action:@selector(handleLongPressFrom:)]);
+  longPressRecognizer.get().delegate = self;
+  [card.view addGestureRecognizer:longPressRecognizer.get()];
+}
+
+- (void)cardSetRecreatedCards:(CardSet*)cardSet {
+  // Remove the old card views, if any, then start loading the new ones.
+  for (UIView* card in [cardSet.displayView subviews]) {
+    [card removeFromSuperview];
+  }
+  [self preloadCardViewsAsynchronously];
+}
+
+#pragma mark -
+
+// The following method is based on Apple sample code available at
+// http://developer.apple.com/library/ios/samplecode/StreetScroller/
+// Introduction/Intro.html.
+- (void)recenterScrollViewIfNecessary {
+  CGFloat contentOffset =
+      [self scrollOffsetAmountForPoint:[_scrollView contentOffset]];
+  CGFloat contentLength = [self scrollLength:[_scrollView contentSize]];
+  CGFloat viewportLength = [self scrollLength:[_scrollView bounds].size];
+  DCHECK(contentLength > viewportLength || [_activeCardSet.cards count] == 0);
+
+  CGFloat centerOffset = (contentLength - viewportLength) / 2.0;
+  CGFloat distanceFromCenter = fabs(contentOffset - centerOffset);
+
+  if (distanceFromCenter > centerOffset / 2.0) {
+    _ignoreScrollCallbacks = YES;
+    [_scrollView
+        setContentOffset:[self scrollOffsetPointWithAmount:centerOffset]];
+    [self alignDisplayViewsToViewport];
+    _ignoreScrollCallbacks = NO;
+  }
+}
+
+- (void)alignDisplayViewsToViewport {
+  DCHECK(CGSizeEqualToSize([_mainCardSet displayView].frame.size,
+                           [_scrollView frame].size));
+  DCHECK(CGSizeEqualToSize([_otrCardSet displayView].frame.size,
+                           [_scrollView frame].size));
+  CGRect newDisplayViewFrame = CGRectMake(
+      [_scrollView contentOffset].x, [_scrollView contentOffset].y,
+      [_scrollView frame].size.width, [_scrollView frame].size.height);
+  [_mainCardSet displayView].frame = newDisplayViewFrame;
+  [_otrCardSet displayView].frame = newDisplayViewFrame;
+}
+
+// Caps overscroll once the stack becomes fully overextended or deceleration
+// slows below a given velocity to achieve a nice-looking bounce effect.
+- (BOOL)shouldEndScroll {
+  if ([[_activeCardSet cards] count] == 0 ||
+      ![_activeCardSet stackIsOverextended] || ![_scrollView isDecelerating])
+    return NO;
+  if ([_activeCardSet stackIsFullyOverextended])
+    return YES;
+  NSUInteger lastCardIndex = [[_activeCardSet cards] count] - 1;
+  // Kill the scroll in the case where a fling wasn't detected early enough,
+  // resulting in part of the stack being overscrolled toward the start without
+  // the whole stack being overscrolled toward the start.
+  if ([_activeCardSet overextensionTowardStartOnCardAtIndex:0] &&
+      ![_activeCardSet overextensionTowardStartOnCardAtIndex:lastCardIndex])
+    return YES;
+  return [_gestureStateTracker scrollVelocity] < kMinFlingVelocityInOverscroll;
+}
+
+- (void)scrollEnded {
+  if ([_activeCardSet stackIsOverextended]) {
+    void (^toDoWhenDone)(void) = ^{
+      [self recenterScrollViewIfNecessary];
+    };
+    [self animateOverextensionEliminationWithCompletion:toDoWhenDone];
+  } else {
+    [self recenterScrollViewIfNecessary];
+  }
+}
+
+- (void)pinchEnded {
+  BOOL scrollingInPinch = [_gestureStateTracker scrollingInPinch];
+
+  if (![_activeCardSet stackIsOverextended]) {
+    if (!scrollingInPinch)
+      [self recenterScrollViewIfNecessary];
+    return;
+  }
+
+  if (scrollingInPinch) {
+    NSUInteger scrollCardIndex = [_gestureStateTracker scrollCardIndex];
+    DCHECK(scrollCardIndex != NSNotFound);
+    if ([_activeCardSet overextensionOnCardAtIndex:scrollCardIndex])
+      return;
+  }
+
+  void (^toDoWhenDone)(void) = NULL;
+  if (!scrollingInPinch) {
+    toDoWhenDone = ^{
+      [self recenterScrollViewIfNecessary];
+    };
+  }
+  [self animateOverextensionEliminationWithCompletion:toDoWhenDone];
+}
+
+- (void)animateOverextensionEliminationWithCompletion:
+    (ProceduralBlock)completion {
+  _activeCardSet.defersCardHiding = YES;
+  [UIView animateWithDuration:kOverextensionEliminationAnimationDuration
+      delay:0
+      options:(UIViewAnimationOptionAllowUserInteraction |
+               UIViewAnimationOptionOverrideInheritedCurve |
+               UIViewAnimationOptionCurveEaseOut)
+      animations:^{
+        [_activeCardSet eliminateOverextension];
+      }
+      completion:^(BOOL finished) {
+        _activeCardSet.defersCardHiding = NO;
+        if (completion)
+          completion();
+      }];
+}
+
+- (void)killScrollDeceleration {
+  _ignoreScrollCallbacks = YES;
+  [_scrollView setContentOffset:[_scrollView contentOffset] animated:NO];
+  // The above call does not always generate a callback to
+  // |scrollViewDidScroll:|, so it is necessary to update the gesture state
+  // tracker's previous scroll offset explicitly here.
+  [_gestureStateTracker
+      setPreviousScrollOffset:
+          [self scrollOffsetAmountForPoint:[_scrollView contentOffset]]];
+  _ignoreScrollCallbacks = NO;
+}
+
+// To mimic standard iOS behavior on overscroll, the stack is allowed to
+// overscroll approximately half of the screen length on drag and a lesser
+// amount on fling.
+- (void)adjustMaximumOverextensionAmount:(BOOL)scrollIsFling {
+  CGFloat screenLength = [self scrollLength:self.view.bounds.size];
+  CGFloat maximumOverextensionAmount =
+      scrollIsFling ? [_activeCardSet overextensionAmount] + screenLength / 4.0
+                    : screenLength / 2.0;
+
+  // The overextension amount is not allowed to grow after a fling begins, as
+  // otherwise the fling would just keep overextending further and further.
+  if (scrollIsFling &&
+      maximumOverextensionAmount > [_activeCardSet maximumOverextensionAmount])
+    return;
+  [_activeCardSet setMaximumOverextensionAmount:maximumOverextensionAmount];
+}
+
+#pragma mark UIScrollViewDelegate methods
+
+- (void)scrollViewDidScroll:(UIScrollView*)scrollView {
+  DCHECK(!_isBeingDismissed);
+  DCHECK(_isActive);
+  DCHECK(scrollView == _scrollView);
+  // Whether this callback will trigger a scroll or not, have to ensure that
+  // the display views' positions are updated after any change in the scroll
+  // view's content offset.
+  [self alignDisplayViewsToViewport];
+
+  if (_ignoreScrollCallbacks) {
+    [_gestureStateTracker
+        setPreviousScrollOffset:
+            [self scrollOffsetAmountForPoint:[_scrollView contentOffset]]];
+    return;
+  }
+
+  if ([[_activeCardSet cards] count] == 0)
+    return;
+
+  // First check if the scrolled card needs to be reset. Have to be careful to
+  // do this only when the user is actually starting a new scroll.
+  if ([_scrollView isTracking] &&
+      [_gestureStateTracker resetScrollCardOnNextDrag]) {
+    CGPoint fingerLocation =
+        [_scrollGestureRecognizer locationOfTouch:0
+                                           inView:_activeCardSet.displayView];
+    [_gestureStateTracker
+        setScrollCardIndex:[self indexOfCardAtPoint:fingerLocation]];
+    // In certain corner cases the previous scroll offset is not up-to-date
+    // when the scrolled card needs to be reset (most notably, when rotating
+    // the device while scrolling). Below provides a fix for these cases
+    // without harming other cases.
+    [_gestureStateTracker
+        setPreviousScrollOffset:
+            [self scrollOffsetAmountForPoint:[_scrollView contentOffset]]];
+    [_gestureStateTracker setPreviousScrollTime:(base::TimeTicks::Now())];
+    [_gestureStateTracker setResetScrollCardOnNextDrag:NO];
+  }
+
+  CGFloat contentOffset =
+      [self scrollOffsetAmountForPoint:[_scrollView contentOffset]];
+  CGFloat delta = contentOffset - [_gestureStateTracker previousScrollOffset];
+
+  // If overscrolled and in a fling, compute the delta to apply manually to
+  // achieve a nice-looking deceleration effect.
+  if ([_activeCardSet stackIsOverextended] && ![_scrollView isTracking]) {
+    CGFloat currentVelocity = [_gestureStateTracker scrollVelocity];
+    CGFloat elapsedTime = CGFloat(
+        (base::TimeTicks::Now() - [_gestureStateTracker previousScrollTime])
+            .InMilliseconds());
+    if (elapsedTime > 0.0) {
+      CGFloat sign = (delta >= 0) ? 1.0 : -1.0;
+      CGFloat distanceAtCurrentVelocity = sign * currentVelocity * elapsedTime;
+      delta = distanceAtCurrentVelocity * kDecayFactorInBounce;
+    }
+  }
+  [_gestureStateTracker updateScrollVelocityWithScrollDistance:delta];
+
+  if ([self shouldEndScroll]) {
+    [self killScrollDeceleration];
+    return;
+  }
+
+  // Perform the scroll.
+  NSInteger scrolledIndex = [_gestureStateTracker scrollCardIndex];
+  if (scrolledIndex == NSNotFound) {
+    // User is scrolling outside the active card stack. Ideally, this scroll
+    // would be ignored; however, that is challenging to implement properly
+    // (in particular, continuing to ensure that scroll view is recentered
+    // when it needs to be). For now, pick a reasonable index to do the
+    // scrolling on. TODO(blundell): Figure out how to ignore these scrolls
+    // while ensuring that scroll view is recentered as necessary. b/5858386
+    scrolledIndex = 0;
+    if (delta > 0)
+      scrolledIndex = [[_activeCardSet cards] count] - 1;
+    // On the next scroll, check again so that if the user starts scrolling on
+    // a card, the scroll moves to be on that card.
+    [_gestureStateTracker setResetScrollCardOnNextDrag:YES];
+  }
+
+  DCHECK(scrolledIndex != NSNotFound);
+
+  // Scrolls that are greater than a given velocity are assumed to be flings
+  // even if the user's finger is still registered as being down, as it is
+  // extremely likely that the user is actually in the middle of doing a fling
+  // motion (and if the scrolled card is allowed to visibly overscroll before
+  // the stack is fully collapsed, the ability to handle the fling as a fling
+  // from a UI perspective is lost). The latter heuristic has the cost of
+  // sometimes ending up in the scrolled card not tracking the user's finger if
+  // the user is scrolling very fast near the start stack.
+  BOOL isFling =
+      ![_scrollView isTracking] || ([_gestureStateTracker scrollVelocity] >
+                                    kThresholdVelocityForTreatingScrollAsFling);
+  [self adjustMaximumOverextensionAmount:isFling];
+
+  // The scroll view's content offset increases with scrolling toward the start
+  // stack. These semantics are inverted from those of
+  // |scrollCardAtIndex:byDelta:|.  If the scroll is a drag, then overscroll
+  // occurs with the scrolled card and the scroll decays once overscrolling
+  // begins to mimic the native iOS behavior on overscroll. In the case of
+  // fling, overscroll does not occur until the scroll is fully
+  // collapsed/expanded and no decay occurs on overscroll as the delta has
+  // already been manually adjusted in this case (see above).
+  BOOL inverseFanDirection = UseRTLLayout() && !IsPortrait();
+  if (inverseFanDirection) {
+    // In landscape RTL layouts, StackCard's application of its layout values to
+    // its underlying CardView is flipped across the midpoint Y axis, but the
+    // scroll view maintains its non-RTL scrolling behavior.  In this
+    // situation, reverse the scrolling direction before applying it to the
+    // CardSet.
+    delta *= -1;
+  }
+  [_activeCardSet scrollCardAtIndex:scrolledIndex
+                            byDelta:-delta
+               allowEarlyOverscroll:!isFling
+                  decayOnOverscroll:!isFling
+                 scrollLeadingCards:YES];
+
+  // Verify that if scroll view's content offset has hit a boundary point, the
+  // active card stack is fully scrolled in the corresponding direction. Note
+  // that this check intentionally doesn't take into account overextension: due
+  // to the fact that overextension is a transient state, the stack is not
+  // guaranteed to be fully overextended when these checks are performed (and
+  // that is OK).
+  DCHECK(contentOffset >= 0);
+  CGFloat epsilon = std::numeric_limits<CGFloat>::epsilon();
+  if (contentOffset < epsilon) {
+    if (inverseFanDirection)
+      DCHECK([_activeCardSet stackIsFullyCollapsed]);
+    else
+      DCHECK([_activeCardSet stackIsFullyFannedOut]);
+  }
+  CGFloat viewportLength = [self scrollLength:[_scrollView bounds].size];
+  CGFloat contentSizeUpperLimit =
+      [self scrollLength:[_scrollView contentSize]] - viewportLength;
+  DCHECK(contentOffset <= contentSizeUpperLimit);
+  if (std::abs(contentSizeUpperLimit - contentOffset) < epsilon) {
+    if (inverseFanDirection)
+      DCHECK([_activeCardSet stackIsFullyFannedOut]);
+    else
+      DCHECK([_activeCardSet stackIsFullyCollapsed]);
+  }
+
+  [_gestureStateTracker setPreviousScrollTime:(base::TimeTicks::Now())];
+  [_gestureStateTracker
+      setPreviousScrollOffset:
+          [self scrollOffsetAmountForPoint:[_scrollView contentOffset]]];
+}
+
+- (void)scrollViewDidEndDragging:(UIScrollView*)scrollView
+                  willDecelerate:(BOOL)willDecelerate {
+  DCHECK(scrollView == _scrollView);
+  [_gestureStateTracker setResetScrollCardOnNextDrag:YES];
+  // Recenter the scroll view's content offset after making sure that there is
+  // no scrolling currently occurring.
+  if (willDecelerate || [_scrollView isDragging] ||
+      [_scrollView isDecelerating] || [_gestureStateTracker pinching])
+    return;
+  [self scrollEnded];
+}
+
+- (void)scrollViewDidEndDecelerating:(UIScrollView*)scrollView {
+  DCHECK(scrollView == _scrollView);
+  // Recenter the scroll view's content offset after making sure that there is
+  // no scrolling currently occurring (this deceleration might have been ended
+  // by the user starting a new scroll).
+  if ([_scrollView isDragging] || [_scrollView isDecelerating] ||
+      [_gestureStateTracker pinching])
+    return;
+  [self scrollEnded];
+}
+
+#pragma mark - Accessibility methods
+
+// Handles scrolling through the card stack and scrolling between main and
+// incognito card stacks while in voiceover mode. Three finger scroll toward
+// an edge stack displays the next few collapsed tabs from the appropriate edge
+// stack. Three finger scroll toward the inactive stack switches between the
+// main and incognito card stacks, as appropriate.
+- (BOOL)accessibilityScroll:(UIAccessibilityScrollDirection)direction {
+  BOOL isPortrait = IsPortrait();
+  BOOL shouldScrollTowardEnd = NO;
+  BOOL shouldScrollTowardStart = NO;
+  BOOL shouldSwitchToMain = NO;
+  BOOL shouldSwitchToIncognito = NO;
+
+  switch (direction) {
+    case UIAccessibilityScrollDirectionDown:
+      if (isPortrait) {
+        shouldScrollTowardEnd = YES;
+      } else {
+        shouldSwitchToIncognito = YES;
+      }
+      break;
+    case UIAccessibilityScrollDirectionUp:
+      if (isPortrait) {
+        shouldScrollTowardStart = YES;
+      } else {
+        shouldSwitchToMain = YES;
+      }
+      break;
+    case UIAccessibilityScrollDirectionLeft:
+      if (isPortrait) {
+        shouldSwitchToIncognito = YES;
+      } else {
+        shouldScrollTowardEnd = YES;
+      }
+      break;
+    case UIAccessibilityScrollDirectionRight:
+      if (isPortrait) {
+        shouldSwitchToMain = YES;
+      } else {
+        shouldScrollTowardStart = YES;
+      }
+      break;
+    default:
+      break;
+  }
+
+  if (shouldScrollTowardEnd) {
+    DCHECK([_activeCardSet.stackModel firstEndStackCardIndex] > -1);
+    [_activeCardSet
+        fanOutCardsWithStartIndex:
+            std::min(
+                (NSInteger)[_activeCardSet.cards count] - 1,
+                (NSInteger)[_activeCardSet.stackModel firstEndStackCardIndex])];
+  } else if (shouldScrollTowardStart) {
+    DCHECK([_activeCardSet.stackModel lastStartStackCardIndex] > -1);
+    [_activeCardSet
+        fanOutCardsWithStartIndex:
+            std::max((NSInteger)0,
+                     (NSInteger)(
+                         [_activeCardSet.stackModel lastStartStackCardIndex] -
+                         [_activeCardSet.stackModel fannedStackCount]))];
+  } else if ([self bothDecksShouldBeDisplayed]) {
+    if (shouldSwitchToMain) {
+      [self setActiveCardSet:_mainCardSet];
+    } else if (shouldSwitchToIncognito) {
+      [self setActiveCardSet:_otrCardSet];
+    }
+  } else {
+    return NO;
+  }
+
+  NSUInteger firstCardIndex = std::max(
+      [_activeCardSet.stackModel lastStartStackCardIndex], (NSInteger)0);
+  StackCard* card = [_activeCardSet.cards objectAtIndex:firstCardIndex];
+  [[card view] postAccessibilityNotification];
+  [self postOpenTabsAccessibilityNotification];
+
+  return YES;
+}
+
+// Posts accessibility notification that announces to the user which tabs are
+// currently visible on the screen.
+- (void)postOpenTabsAccessibilityNotification {
+  if ([_activeCardSet.cards count] == 0) {
+    return;
+  }
+
+  NSInteger count = [_activeCardSet.cards count];
+  NSInteger lastStartIndex =
+      [_activeCardSet.stackModel lastStartStackCardIndex];
+  DCHECK(lastStartIndex < (int)[_activeCardSet.cards count]);
+  if (lastStartIndex < 0) {
+    lastStartIndex = 0;
+  }
+  NSInteger firstEndIndex = [_activeCardSet.stackModel firstEndStackCardIndex];
+  NSInteger first = lastStartIndex < 0 ? 1 : lastStartIndex + 1;
+  NSInteger last = firstEndIndex < 0 ? count : firstEndIndex;
+
+  // Post notification to voiceover to read which tabs are currently visible.
+  NSString* incognito = [self isCurrentSetIncognito] ? @"Incognito" : @"";
+  NSString* firstVisible = [NSString stringWithFormat:@"%" PRIuNS, first];
+  NSString* lastVisible = [NSString stringWithFormat:@"%" PRIuNS, last];
+  NSString* numCards = [NSString stringWithFormat:@"%" PRIuNS, count];
+  UIAccessibilityPostNotification(
+      UIAccessibilityPageScrolledNotification,
+      l10n_util::GetNSStringF(IDS_IOS_CARD_STACK_SCROLLED_NOTIFICATION,
+                              base::SysNSStringToUTF16(incognito),
+                              base::SysNSStringToUTF16(firstVisible),
+                              base::SysNSStringToUTF16(lastVisible),
+                              base::SysNSStringToUTF16(numCards)));
+}
+
+// Returns the StackCard with |element| in its view hierarchy.
+// Handles CardView, TitleLabel, and CloseButton elements.
+- (StackCard*)cardForAccessibilityElement:(UIView*)element {
+  DCHECK([element isKindOfClass:[CardView class]] ||
+         [element isKindOfClass:[TitleLabel class]] ||
+         [element isKindOfClass:[CloseButton class]]);
+
+  if ([element isKindOfClass:[CardView class]]) {
+    for (StackCard* card in _activeCardSet.cards) {
+      if (card.view == element) {
+        return card;
+      }
+    }
+  } else {
+    for (StackCard* card in _activeCardSet.cards) {
+      if (card.view == element.superview.superview) {
+        return card;
+      }
+    }
+  }
+  return nil;
+}
+
+- (void)accessibilityFocusedOnElement:(id)element {
+  StackCard* card = [self cardForAccessibilityElement:element];
+  DCHECK(card);
+  NSInteger index = [_activeCardSet.cards indexOfObject:card];
+
+  if (![_activeCardSet.stackModel cardLabelCovered:card]) {
+    return;
+  }
+
+  if (index >= [_activeCardSet.stackModel firstEndStackCardIndex] - 1) {
+    // If card is in the end stack, scroll it toward the start.
+    [_activeCardSet scrollCardAtIndex:index awayFromNeighbor:NO];
+  } else if (index == [_activeCardSet.stackModel lastStartStackCardIndex] - 1) {
+    // If card is the last covered card in the start stack, scroll the last
+    // start stack card away from the start stack to reveal it.
+    [_activeCardSet scrollCardAtIndex:index + 1 awayFromNeighbor:YES];
+  } else {
+    // If the card is in the middle of a stack that is not the end stack, fan
+    // the cards out starting with that card.
+    [_activeCardSet fanOutCardsWithStartIndex:index];
+    [card.view postAccessibilityNotification];
+    [self postOpenTabsAccessibilityNotification];
+  }
+}
+
+#pragma mark - UIResponder
+
+- (NSArray*)keyCommands {
+  base::WeakNSObject<StackViewController> weakSelf(self);
+
+  // Block to execute a command from the |tag|.
+  base::mac::ScopedBlock<void (^)(NSInteger)> execute(
+      ^(NSInteger tag) {
+        [weakSelf
+            chromeExecuteCommand:[GenericChromeCommand commandWithTag:tag]];
+      },
+      base::scoped_policy::RETAIN);
+
+  return @[
+    [UIKeyCommand cr_keyCommandWithInput:@"t"
+                           modifierFlags:UIKeyModifierCommand
+                                   title:l10n_util::GetNSStringWithFixup(
+                                             IDS_IOS_TOOLS_MENU_NEW_TAB)
+                                  action:^{
+                                    if ([weakSelf isCurrentSetIncognito])
+                                      execute.get()(IDC_NEW_INCOGNITO_TAB);
+                                    else
+                                      execute.get()(IDC_NEW_TAB);
+                                  }],
+    [UIKeyCommand
+        cr_keyCommandWithInput:@"n"
+                 modifierFlags:UIKeyModifierCommand | UIKeyModifierShift
+                         title:l10n_util::GetNSStringWithFixup(
+                                   IDS_IOS_TOOLS_MENU_NEW_INCOGNITO_TAB)
+                        action:^{
+                          execute.get()(IDC_NEW_INCOGNITO_TAB);
+                        }],
+    [UIKeyCommand cr_keyCommandWithInput:@"n"
+                           modifierFlags:UIKeyModifierCommand
+                                   title:nil
+                                  action:^{
+                                    if ([weakSelf isCurrentSetIncognito])
+                                      execute.get()(IDC_NEW_INCOGNITO_TAB);
+                                    else
+                                      execute.get()(IDC_NEW_TAB);
+                                  }],
+  ];
+}
+
+@end
+
+@implementation StackViewController (Testing)
+
+- (UIScrollView*)scrollView {
+  return _scrollView.get();
+}
+
+@end