[ObjC ARC] Converts ios/chrome/browser/ui/stack_view:stack_view to ARC.

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_macros.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"
@@ skipping 19 matching lines @@
 #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"
 #import "ios/shared/chrome/browser/ui/tools_menu/tools_menu_configuration.h"
 #include "ios/web/public/referrer.h"
 #import "net/base/mac/url_conversions.h"
 #include "ui/base/l10n/l10n_util.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 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.
 
@@ skipping 363 matching lines @@
 // 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;
+  UIScrollView* _scrollView;
   // The view containing the stack view's background.
-  base::scoped_nsobject<UIView> _backgroundView;
+  UIView* _backgroundView;
   // The main card set.
-  base::scoped_nsobject<CardSet> _mainCardSet;
+  CardSet* _mainCardSet;
   // The off-the-record card set.
-  base::scoped_nsobject<CardSet> _otrCardSet;
+  CardSet* _otrCardSet;
   // The currently active card set; one of _mainCardSet or _otrCardSet.
-  CardSet* _activeCardSet;                            // weak
-  id<TabSwitcherDelegate> _delegate;                  // weak
-  id<StackViewControllerTestDelegate> _testDelegate;  // weak
+  __weak CardSet* _activeCardSet;
+  __weak id<TabSwitcherDelegate> _delegate;
+  __weak id<StackViewControllerTestDelegate> _testDelegate;
   // Controller for the stack view toolbar.
-  base::scoped_nsobject<StackViewToolbarController> _toolbarController;
+  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;
+  UITapGestureRecognizer* _modeSwitchRecognizer;
   // Gesture recognizer to catch pinches in the active scroll view.
-  base::scoped_nsobject<UIGestureRecognizer> _pinchRecognizer;
+  UIGestureRecognizer* _pinchRecognizer;
   // Gesture recognizer to catch swipes to switch decks/dismiss cards.
-  base::scoped_nsobject<UIGestureRecognizer> _swipeGestureRecognizer;
+  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;
+  UILongPressGestureRecognizer* _swipeDismissesCardRecognizer;
   // Tracks the parameters of gesture-related events.
-  base::scoped_nsobject<GestureStateTracker> _gestureStateTracker;
+  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
+  __weak UIPanGestureRecognizer* _scrollGestureRecognizer;
   // 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;
+  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]
+    _swipeDismissesCardRecognizer = [[UILongPressGestureRecognizer alloc]
         initWithTarget:self
-                action:@selector(handleLongPressFrom:)]);
+                action:@selector(handleLongPressFrom:)];
     [_swipeDismissesCardRecognizer
         setMinimumPressDuration:
             kPressDurationForAmbiguousSwipeToTriggerDismissal];
     [_swipeDismissesCardRecognizer setDelegate:self];
-    _pinchRecognizer.reset([[CardStackPinchGestureRecognizer alloc]
+    _pinchRecognizer = [[CardStackPinchGestureRecognizer alloc]
         initWithTarget:self
-                action:@selector(handlePinchFrom:)]);
+                action:@selector(handlePinchFrom:)];
     [_pinchRecognizer setDelegate:self];
-    _modeSwitchRecognizer.reset([[UITapGestureRecognizer alloc]
+    _modeSwitchRecognizer = [[UITapGestureRecognizer alloc]
         initWithTarget:self
-                action:@selector(handleTapFrom:)]);
+                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* mainCardSet = [[CardSet alloc] initWithModel:mainModel];
+  CardSet* otrCardSet = [[CardSet alloc] initWithModel:otrModel];
   CardSet* activeCardSet =
-      (activeModel == mainModel) ? mainCardSet.get() : otrCardSet.get();
+      (activeModel == mainModel) ? mainCardSet : otrCardSet;
   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]);
+  _mainCardSet = mainCardSet;
+  _otrCardSet = otrCardSet;
   if (experimental_flags::IsLRUSnapshotCacheEnabled()) {
     [_mainCardSet setKeepOnlyVisibleCardViewsAlive:YES];
     [_otrCardSet setKeepOnlyVisibleCardViewsAlive:YES];
   }
   _activeCardSet = (activeCardSet == mainCardSet) ? mainCardSet : otrCardSet;
-  _gestureStateTracker.reset([[GestureStateTracker alloc] init]);
-  _pinchRecognizer.reset([[CardStackPinchGestureRecognizer alloc]
+  _gestureStateTracker = [[GestureStateTracker alloc] init];
+  _pinchRecognizer = [[CardStackPinchGestureRecognizer alloc]
       initWithTarget:self
-              action:@selector(handlePinchFrom:)]);
+              action:@selector(handlePinchFrom:)];
   [_pinchRecognizer setDelegate:self];
-  _modeSwitchRecognizer.reset([[UITapGestureRecognizer alloc]
-      initWithTarget:self
-              action:@selector(handleTapFrom:)]);
+  _modeSwitchRecognizer =
+      [[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* mainCardSet = [[CardSet alloc] initWithModel:mainModel];
+  CardSet* otrCardSet = [[CardSet alloc] initWithModel:otrModel];
   CardSet* activeCardSet =
-      (activeModel == mainModel) ? mainCardSet.get() : otrCardSet.get();
+      (activeModel == mainModel) ? mainCardSet : otrCardSet;
   [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];
@@ skipping 11 matching lines @@
 - (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();
+  _mainCardSet = nil;
+  _otrCardSet = nil;
   _activeCardSet = nil;
 
   // Remove gesture recognizers and notifications.
   [self prepareForDismissal];
-  _gestureStateTracker.reset();
-  _pinchRecognizer.reset();
-  _modeSwitchRecognizer.reset();
-  _swipeGestureRecognizer.reset();
+  _gestureStateTracker = nil;
+  _pinchRecognizer = nil;
+  _modeSwitchRecognizer = nil;
+  _swipeGestureRecognizer = nil;
 
   // 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];
@@ skipping 16 matching lines @@
   _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]);
+  UIView* mainDisplayView = [[UIView alloc] initWithFrame:displayViewFrame];
   [mainDisplayView setAutoresizingMask:UIViewAutoresizingFlexibleWidth |
                                        UIViewAutoresizingFlexibleHeight];
-  base::scoped_nsobject<UIView> otrDisplayView(
-      [[UIView alloc] initWithFrame:displayViewFrame]);
+  UIView* otrDisplayView = [[UIView alloc] initWithFrame:displayViewFrame];
   [otrDisplayView setAutoresizingMask:UIViewAutoresizingFlexibleWidth |
                                       UIViewAutoresizingFlexibleHeight];
 
   [_scrollView addSubview:mainDisplayView];
   [_scrollView addSubview:otrDisplayView];
   [_mainCardSet setDisplayView:mainDisplayView];
   [_otrCardSet setDisplayView:otrDisplayView];
 }
 
 - (void)prepareForDisplay {
@@ skipping 12 matching lines @@
             : 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);
+  _swipeGestureRecognizer = panGestureRecognizer;
   [[self view] addGestureRecognizer:_swipeGestureRecognizer];
   [_swipeGestureRecognizer setDelegate:self];
 }
 
 - (void)loadView {
   [super loadView];
 
-  _backgroundView.reset([[UIView alloc] initWithFrame:self.view.bounds]);
+  _backgroundView = [[UIView alloc] initWithFrame:self.view.bounds];
   [_backgroundView setAutoresizingMask:(UIViewAutoresizingFlexibleHeight |
                                         UIViewAutoresizingFlexibleWidth)];
   [self.view addSubview:_backgroundView];
 
-  _toolbarController.reset(
-      [[StackViewToolbarController alloc] initWithStackViewToolbar]);
+  _toolbarController =
+      [[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]);
+  _scrollView = [[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];
 
@@ skipping 20 matching lines @@
     [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]);
+  _gestureStateTracker = [[GestureStateTracker alloc] init];
 
   [super viewWillAppear:animated];
 }
 
 - (void)refreshCardDisplayWithAnimation:(BOOL)animates {
   _lastInterfaceOrientation = GetInterfaceOrientation();
   [self updateDeckOrientationWithAnimation:animates];
   [self viewportSizeWasChanged];
   [_mainCardSet updateCardVisibilities];
   [_otrCardSet updateCardVisibilities];
@@ skipping 12 matching lines @@
 }
 
 - (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.
@@ skipping 123 matching lines @@
   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();
+  _scrollView = nil;
+  _backgroundView = nil;
   [[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;
@@ skipping 95 matching lines @@
       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;
+  _pinchRecognizer.enabled = NO;
+  _swipeGestureRecognizer.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;
+  _pinchRecognizer.enabled = YES;
+  _swipeGestureRecognizer.enabled = YES;
 }
 
 - (void)activeCardCountChanged {
   // Cancel any outstanding gestures (see the comment in
   // -cardSet:willRemoveCard:atIndex).
   [self disableGestureHandlers];
   [self enableGestureHandlers];
 }
 
 - (void)setInitialCardSizing {
@@ skipping 108 matching lines @@
 }
 
 - (BOOL)bothDecksShouldBeDisplayed {
   return [[_otrCardSet cards] count] > 0;
 }
 
 #pragma mark -
 #pragma mark Current Set Handling
 
 - (BOOL)isCurrentSetIncognito {
-  return _activeCardSet == _otrCardSet.get();
+  return _activeCardSet == _otrCardSet;
 }
 
 - (CardSet*)inactiveCardSet {
-  return [self isCurrentSetIncognito] ? _mainCardSet.get() : _otrCardSet.get();
+  return [self isCurrentSetIncognito] ? _mainCardSet : _otrCardSet;
 }
 
 - (void)setActiveCardSet:(CardSet*)cardSet {
   DCHECK(cardSet);
   if (cardSet == _activeCardSet)
     return;
   [self activeCardCountChanged];
   _activeCardSet = cardSet;
 
   [self displayActiveCardSet];
@@ skipping 232 matching lines @@
   [_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);
+                                    _toolbarController.view);
   }
 }
 
 - (void)cancelTransitionAnimation {
   // Set up transaction.
   [CATransaction begin];
   [CATransaction setCompletionBlock:^{
     [self finishTransitionAnimation];
   }];
   self.transitionWasCancelled = YES;
@@ skipping 90 matching lines @@
   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 = [[UIView alloc] initWithFrame:CGRectZero];
   [self.dummyToolbarBackgroundView setClipsToBounds:YES];
 
   // Set the transition completion block.
   [CATransaction begin];
   [CATransaction setCompletionBlock:^{
     [self finishTransitionAnimation];
   }];
 
   // Slide in/out the inactive card set.
   [self animateInactiveSetTransition];
@@ skipping 458 matching lines @@
                                           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];
+  UIImageView* newCard = [[UIImageView alloc] initWithFrame:viewBounds];
   // 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];
 
@@ skipping 25 matching lines @@
 
 #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()))
+      (recognizer == _swipeGestureRecognizer))
     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())
+  if (recognizer == _modeSwitchRecognizer)
     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()) {
+  if (recognizer == _swipeDismissesCardRecognizer) {
     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
@@ skipping 31 matching lines @@
        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());
+      (gestureRecognizer == _swipeDismissesCardRecognizer ||
+       otherGestureRecognizer == _swipeDismissesCardRecognizer);
   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]]);
@@ skipping 42 matching lines @@
     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())
+  if (recognizer == _swipeDismissesCardRecognizer)
     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.
@@ skipping 154 matching lines @@
   [_gestureStateTracker setPreviousFirstPinchOffset:firstOffset];
   [_gestureStateTracker setPreviousSecondPinchOffset:secondOffset];
 }
 
 - (void)handleTapFrom:(UITapGestureRecognizer*)recognizer {
   DCHECK(!_isBeingDismissed);
   DCHECK(_isActive);
   if (recognizer.state != UIGestureRecognizerStateEnded)
     return;
 
-  if (recognizer == _modeSwitchRecognizer.get()) {
+  if (recognizer == _modeSwitchRecognizer) {
     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;
@@ skipping 219 matching lines @@
     // 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]);
+        _reverseDismissCard = card;
       // 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];
@@ skipping 49 matching lines @@
     case IDC_TOGGLE_TAB_SWITCHER:
       [self dismissWithSelectedTabAnimation];
       break;
     default:
       [super chromeExecuteCommand:sender];
       break;
   }
 }
 
 - (void)showToolsMenuPopup {
-  base::scoped_nsobject<ToolsMenuConfiguration> configuration(
-      [[ToolsMenuConfiguration alloc] initWithDisplayView:[self view]]);
+  ToolsMenuConfiguration* configuration =
+      [[ToolsMenuConfiguration alloc] initWithDisplayView:[self view]];
   [configuration 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))
     [configuration setNoOpenedTabs:YES];
   if (_activeCardSet == _otrCardSet)
     [configuration setInIncognito:YES];
   [_toolbarController showToolsMenuPopupWithConfiguration:configuration];
 }
@@ skipping 168 matching lines @@
     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();
+      _reverseDismissCard = nil;
   }
   // 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()) {
+  if ([cardSet.cards count] == 0 && cardSet == _otrCardSet) {
     [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
@@ skipping 28 matching lines @@
   }
   [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()];
+  UIGestureRecognizer* tapRecognizer =
+      [[UITapGestureRecognizer alloc] initWithTarget:self
+                                              action:@selector(handleTapFrom:)];
+  tapRecognizer.delegate = self;
+  [card.view addGestureRecognizer:tapRecognizer];
 
-  base::scoped_nsobject<UIGestureRecognizer> longPressRecognizer(
+  UIGestureRecognizer* longPressRecognizer =
       [[UILongPressGestureRecognizer alloc]
           initWithTarget:self
-                  action:@selector(handleLongPressFrom:)]);
-  longPressRecognizer.get().delegate = self;
-  [card.view addGestureRecognizer:longPressRecognizer.get()];
+                  action:@selector(handleLongPressFrom:)];
+  longPressRecognizer.delegate = self;
+  [card.view addGestureRecognizer:longPressRecognizer];
 }
 
 - (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];
 }
 
@@ skipping 465 matching lines @@
     // 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);
+  __weak 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);
+  void (^execute)(NSInteger) = ^(NSInteger tag) {
+    [weakSelf chromeExecuteCommand:[GenericChromeCommand commandWithTag:tag]];
+  };
 
   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);
+                                      execute(IDC_NEW_INCOGNITO_TAB);
                                     else
-                                      execute.get()(IDC_NEW_TAB);
+                                      execute(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);
+                          execute(IDC_NEW_INCOGNITO_TAB);
                         }],
     [UIKeyCommand cr_keyCommandWithInput:@"n"
                            modifierFlags:UIKeyModifierCommand
                                    title:nil
                                   action:^{
                                     if ([weakSelf isCurrentSetIncognito])
-                                      execute.get()(IDC_NEW_INCOGNITO_TAB);
+                                      execute(IDC_NEW_INCOGNITO_TAB);
                                     else
-                                      execute.get()(IDC_NEW_TAB);
+                                      execute(IDC_NEW_TAB);
                                   }],
   ];
 }
 
 @end
 
 @implementation StackViewController (Testing)
 
 - (UIScrollView*)scrollView {
-  return _scrollView.get();
+  return _scrollView;
 }
 
 @end