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

ios/chrome/browser/ui/tabs/tab_strip_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/tabs/tab_strip_controller.h"
 #import "ios/chrome/browser/ui/tabs/tab_strip_controller_private.h"
 
 #include <cmath>
 #include <vector>
 
 #include "base/i18n/rtl.h"
-#import "base/ios/weak_nsobject.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/foundation_util.h"
-#include "base/mac/objc_property_releaser.h"
-#include "base/mac/scoped_nsobject.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/browser_state/chrome_browser_state.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/commands/UIKit+ChromeExecuteCommand.h"
 #include "ios/chrome/browser/ui/commands/ios_command_ids.h"
 #import "ios/chrome/browser/ui/fullscreen_controller.h"
 #include "ios/chrome/browser/ui/rtl_geometry.h"
 #include "ios/chrome/browser/ui/tab_switcher/tab_switcher_tab_strip_placeholder_view.h"
 #import "ios/chrome/browser/ui/tabs/tab_strip_controller+tab_switcher_animation.h"
 #import "ios/chrome/browser/ui/tabs/tab_strip_view.h"
 #import "ios/chrome/browser/ui/tabs/tab_view.h"
 #include "ios/chrome/browser/ui/tabs/target_frame_cache.h"
 #include "ios/chrome/browser/ui/ui_util.h"
 #import "ios/chrome/browser/ui/uikit_ui_util.h"
 #import "ios/chrome/browser/ui/util/snapshot_util.h"
 #include "ios/chrome/grit/ios_strings.h"
 #import "ios/web/public/web_state/web_state.h"
 #include "third_party/google_toolbox_for_mac/src/iPhone/GTMFadeTruncatingLabel.h"
 #include "ui/gfx/image/image.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 using base::UserMetricsAction;
 
 NSString* const kWillStartTabStripTabAnimation =
     @"kWillStartTabStripTabAnimation";
 NSString* const kTabStripDragStarted = @"kTabStripDragStarted";
 NSString* const kTabStripDragEnded = @"kTabStripDragEnded";
 
 namespace TabStrip {
 UIColor* BackgroundColor() {
   DCHECK(IsIPadIdiom());
@@ skipping 59 matching lines @@
 
 // Offsets needed to keep the UI properly centered on high-res screens, in
 // points.
 const CGFloat kNewTabButtonBottomOffsetHighRes = 2.0;
 }
 
 @interface TabStripController ()<TabModelObserver,
                                  TabStripViewLayoutDelegate,
                                  UIGestureRecognizerDelegate,
                                  UIScrollViewDelegate> {
-  base::scoped_nsobject<TabModel> _tabModel;
+  TabModel* _tabModel;
   UIView* _view;
   TabStripView* _tabStripView;
   UIButton* _buttonNewTab;
-  base::scoped_nsobject<UIButton> _tabSwitcherButton;
+  UIButton* _tabSwitcherButton;
 
   // Background view of the tab switcher button. Only visible while in compact
   // layout.
-  base::scoped_nsobject<UIImageView> _tabSwitcherButtonBackgroundView;
+  UIImageView* _tabSwitcherButtonBackgroundView;
 
   TabStrip::Style _style;
-  base::WeakNSProtocol<id<FullScreenControllerDelegate>> _fullscreenDelegate;
+  __weak id<FullScreenControllerDelegate> _fullscreenDelegate;
 
   // Array of TabViews.  There is a one-to-one correspondence between this array
   // and the set of Tabs in the TabModel.
-  base::scoped_nsobject<NSMutableArray> _tabArray;
+  NSMutableArray* _tabArray;
 
   // Set of TabViews that are currently closing.  These TabViews are also in
   // |_tabArray|.  Used to translate between |_tabArray| indexes and TabModel
   // indexes.
-  base::scoped_nsobject<NSMutableSet> _closingTabs;
+  NSMutableSet* _closingTabs;
 
   // Tracks target frames for TabViews.
   // TODO(rohitrao): This is unnecessary, as UIKit updates view frames
   // immediately, so [view frame] will always return the end state of the
   // current animation.  We can remove this cache entirely.  b/5516053
   TargetFrameCache _targetFrames;
 
   // Animate when doing layout.  This flag is set by setNeedsLayoutWithAnimation
   // and cleared in layoutSubviews.
   BOOL _animateLayout;
 
   // The current tab width.  Recomputed whenever a tab is added or removed.
   CGFloat _currentTabWidth;
 
   // View used to dim unselected tabs when in reordering mode.  Nil when not
   // reordering tabs.
-  base::scoped_nsobject<UIView> _dimmingView;
+  UIView* _dimmingView;
 
   // Is the selected tab highlighted, used when dragging or swiping tabs.
   BOOL _highlightsSelectedTab;
 
   // YES when in reordering mode.
   // TODO(rohitrao): This is redundant with |_draggedTab|.  Remove it.
   BOOL _isReordering;
 
   // The tab that is currently being dragged.  nil when not in reordering mode.
-  base::scoped_nsobject<TabView> _draggedTab;
+  TabView* _draggedTab;
 
   // The last known location of the touch that is dragging the tab.  This
   // location is in the coordinate system of |[_tabStripView superview]| because
   // that coordinate system does not change as the scroll view scrolls.
   CGPoint _lastDragLocation;
 
   // Timer used to autoscroll when in reordering mode.  Is nil when not active.
   // Owned by its runloop.
   NSTimer* _autoscrollTimer;  // weak
 
   // The distance to scroll for each autoscroll timer tick.  If negative, the
   // tabstrip will scroll to the left; if positive, to the right.
   CGFloat _autoscrollDistance;
 
   // The model index of the placeholder gap, if one exists.  This value is used
   // as the new model index of the dragged tab when it is dropped.
   NSUInteger _placeholderGapModelIndex;
-
-  base::mac::ObjCPropertyReleaser _propertyReleaser_TabStripController;
 }
 
 @property(nonatomic, readonly, retain) TabStripView* tabStripView;
 @property(nonatomic, readonly, retain) UIButton* buttonNewTab;
 
 // Initializes the tab array based on the the entries in the TabModel.  Creates
 // one TabView per Tab and adds it to the tabstrip.  A later call to
 // |-layoutTabs| is needed to properly place the tabs in the correct positions.
 - (void)initializeTabArrayFromTabModel;
 
@@ skipping 121 matching lines @@
 @implementation TabStripController
 
 @synthesize buttonNewTab = _buttonNewTab;
 @synthesize highlightsSelectedTab = _highlightsSelectedTab;
 @synthesize tabStripView = _tabStripView;
 @synthesize view = _view;
 
 - (instancetype)initWithTabModel:(TabModel*)tabModel
                            style:(TabStrip::Style)style {
   if ((self = [super init])) {
-    _propertyReleaser_TabStripController.Init(self, [TabStripController class]);
-    _tabArray.reset([[NSMutableArray alloc] initWithCapacity:10]);
-    _closingTabs.reset([[NSMutableSet alloc] initWithCapacity:5]);
+    _tabArray = [[NSMutableArray alloc] initWithCapacity:10];
+    _closingTabs = [[NSMutableSet alloc] initWithCapacity:5];
 
-    _tabModel.reset([tabModel retain]);
+    _tabModel = tabModel;
     [_tabModel addObserver:self];
     _style = style;
 
     // |self.view| setup.
     CGRect tabStripFrame = [UIApplication sharedApplication].keyWindow.bounds;
     tabStripFrame.size.height = kTabStripHeight;
     _view = [[UIView alloc] initWithFrame:tabStripFrame];
     _view.autoresizingMask = (UIViewAutoresizingFlexibleWidth |
                               UIViewAutoresizingFlexibleBottomMargin);
     _view.backgroundColor = TabStrip::BackgroundColor();
@@ skipping 81 matching lines @@
 
 - (instancetype)init {
   NOTREACHED();
   return nil;
 }
 
 - (void)dealloc {
   [_tabStripView setDelegate:nil];
   [_tabStripView setLayoutDelegate:nil];
   [_tabModel removeObserver:self];
-  [super dealloc];
 }
 
 - (id<FullScreenControllerDelegate>)fullscreenDelegate {
   return _fullscreenDelegate;
 }
 
 - (void)setFullscreenDelegate:
     (id<FullScreenControllerDelegate>)fullscreenDelegate {
-  _fullscreenDelegate.reset(fullscreenDelegate);
+  _fullscreenDelegate = fullscreenDelegate;
 }
 
 - (void)initializeTabArrayFromTabModel {
   DCHECK(_tabModel);
-  for (Tab* tab in _tabModel.get()) {
+  for (Tab* tab in _tabModel) {
     BOOL isSelectedTab = [_tabModel currentTab] == tab;
     TabView* view = [self tabViewForTab:tab isSelected:isSelectedTab];
     [_tabArray addObject:view];
     [_tabStripView addSubview:view];
   }
 }
 
 - (void)initializeTabArrayWithNoModel {
   DCHECK(!_tabModel);
   TabView* view = [self emptyTabView];
   [_tabArray addObject:view];
   [_tabStripView addSubview:view];
   [view setSelected:YES];
   return;
 }
 
 - (TabView*)emptyTabView {
-  TabView* view =
-      [[[TabView alloc] initWithEmptyView:YES selected:YES] autorelease];
+  TabView* view = [[TabView alloc] initWithEmptyView:YES selected:YES];
   [view setIncognitoStyle:(_style == TabStrip::kStyleIncognito)];
   [view setContentMode:UIViewContentModeRedraw];
 
   // Setting the tab to be hidden marks it as a new tab.  The layout code will
   // make the tab visible and set up the appropriate animations.
   [view setHidden:YES];
 
   return view;
 }
 
 - (TabView*)tabViewForTab:(Tab*)tab isSelected:(BOOL)isSelected {
-  TabView* view =
-      [[[TabView alloc] initWithEmptyView:NO selected:isSelected] autorelease];
+  TabView* view = [[TabView alloc] initWithEmptyView:NO selected:isSelected];
   if (UseRTLLayout())
     [view setTransform:CGAffineTransformMakeScale(-1, 1)];
   [view setIncognitoStyle:(_style == TabStrip::kStyleIncognito)];
   [view setContentMode:UIViewContentModeRedraw];
   [[view titleLabel] setText:[tab title]];
   [view setFavicon:[tab favicon]];
 
   // Set the tab buttons' action messages.
   [view addTarget:self
                 action:@selector(tabTapped:)
       forControlEvents:UIControlEventTouchUpInside];
   [[view closeButton] addTarget:self
                          action:@selector(closeTab:)
                forControlEvents:UIControlEventTouchUpInside];
 
   // Install a long press gesture recognizer to handle drag and drop.
-  base::scoped_nsobject<UILongPressGestureRecognizer> longPress(
+  UILongPressGestureRecognizer* longPress =
       [[UILongPressGestureRecognizer alloc]
           initWithTarget:self
-                  action:@selector(handleLongPress:)]);
+                  action:@selector(handleLongPress:)];
   [longPress setMinimumPressDuration:kDragAndDropLongPressDuration];
   [longPress setDelegate:self];
   [view addGestureRecognizer:longPress];
 
   // Giving the tab view exclusive touch prevents other views from receiving
   // touches while a TabView is handling a touch.
   [view setExclusiveTouch:YES];
 
   // Setting the tab to be hidden marks it as a new tab.  The layout code will
   // make the tab visible and set up the appropriate animations.
@@ skipping 14 matching lines @@
 - (void)installDimmingViewWithAnimation:(BOOL)animate {
   // The dimming view should not cover the bottom 2px of the tab strip, as those
   // pixels are visually part of the top border of the toolbar.  The bottom
   // inset constants take into account the conversion from pixels to points.
   CGRect frame = [_tabStripView bounds];
   frame.size.height -= (IsHighResScreen() ? kDimmingViewBottomInsetHighRes
                                           : kDimmingViewBottomInset);
 
   // Create the dimming view if it doesn't exist.  In all cases, make sure it's
   // set up correctly.
-  if (_dimmingView.get())
+  if (_dimmingView)
     [_dimmingView setFrame:frame];
   else
-    _dimmingView.reset([[UIView alloc] initWithFrame:frame]);
+    _dimmingView = [[UIView alloc] initWithFrame:frame];
 
   // Enable user interaction in order to eat touches from views behind it.
   [_dimmingView setUserInteractionEnabled:YES];
   [_dimmingView setBackgroundColor:[TabStrip::BackgroundColor()
                                        colorWithAlphaComponent:0]];
   [_dimmingView setAutoresizingMask:(UIViewAutoresizingFlexibleWidth |
                                      UIViewAutoresizingFlexibleHeight)];
   [_tabStripView addSubview:_dimmingView];
 
   CGFloat duration = animate ? kTabStripFadeAnimationDuration : 0;
@@ skipping 10 matching lines @@
     CGFloat duration = animate ? kTabStripFadeAnimationDuration : 0;
     [UIView animateWithDuration:duration
         animations:^{
           [_dimmingView setBackgroundColor:[TabStrip::BackgroundColor()
                                                colorWithAlphaComponent:0]];
         }
         completion:^(BOOL finished) {
           // Do not remove the dimming view if the animation was aborted.
           if (finished) {
             [_dimmingView removeFromSuperview];
-            _dimmingView.reset();
+            _dimmingView = nil;
           }
         }];
   }
 }
 
 - (void)recordUserMetrics:(id)sender {
   if (sender == _buttonNewTab)
     base::RecordAction(UserMetricsAction("MobileTabStripNewTab"));
-  else if (sender == _tabSwitcherButton.get())
+  else if (sender == _tabSwitcherButton)
     base::RecordAction(UserMetricsAction("MobileTabSwitcherOpen"));
   else
     LOG(WARNING) << "Trying to record metrics for unknown sender "
                  << base::SysNSStringToUTF8([sender description]);
 }
 
 - (void)tabTapped:(id)sender {
   DCHECK([sender isKindOfClass:[TabView class]]);
 
   // Ignore taps while in reordering mode.
@@ skipping 53 matching lines @@
                         object:nil];
       break;
     default:
       NOTREACHED();
   }
 }
 
 - (NSUInteger)indexForModelIndex:(NSUInteger)modelIndex {
   NSUInteger index = modelIndex;
   NSUInteger i = 0;
-  for (TabView* tab in _tabArray.get()) {
+  for (TabView* tab in _tabArray) {
     if ([_closingTabs containsObject:tab])
       ++index;
 
     if (i == index)
       break;
 
     ++i;
   }
 
   DCHECK_GE(index, modelIndex);
   return index;
 }
 
 - (NSUInteger)modelIndexForIndex:(NSUInteger)index {
   NSUInteger modelIndex = 0;
   NSUInteger arrayIndex = 0;
-  for (TabView* tab in _tabArray.get()) {
+  for (TabView* tab in _tabArray) {
     if (arrayIndex == index) {
       if ([_closingTabs containsObject:tab])
         return NSNotFound;
       return modelIndex;
     }
 
     if (![_closingTabs containsObject:tab])
       ++modelIndex;
 
     ++arrayIndex;
@@ skipping 22 matching lines @@
   // Install the dimming view, hide the new tab button, and select the tab so it
   // appears highlighted.
   Tab* tab = [_tabModel tabAtIndex:index];
   self.highlightsSelectedTab = YES;
   _buttonNewTab.hidden = YES;
   [_tabModel setCurrentTab:tab];
 
   // Set up initial drag state.
   _lastDragLocation = [gesture locationInView:[_tabStripView superview]];
   _isReordering = YES;
-  _draggedTab.reset([view retain]);
+  _draggedTab = view;
   _placeholderGapModelIndex = [self modelIndexForTabView:_draggedTab];
 
   // Update the autoscroll distance and timer.
   [self computeAutoscrollDistanceForTabView:_draggedTab];
   if (_autoscrollDistance != 0)
     [self installAutoscrollTimerIfNeeded];
   else
     [self removeAutoscrollTimer];
 }
 
@@ skipping 54 matching lines @@
   [self setNeedsLayoutWithAnimation];
 }
 
 - (void)resetDragState {
   self.highlightsSelectedTab = NO;
   _buttonNewTab.hidden = NO;
   [self removeAutoscrollTimer];
 
   _isReordering = NO;
   _placeholderGapModelIndex = NSNotFound;
-  _draggedTab.reset();
+  _draggedTab = nil;
 }
 
 - (BOOL)isReorderingTabs {
   return _isReordering;
 }
 
 - (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer*)recognizer {
   DCHECK([recognizer isKindOfClass:[UILongPressGestureRecognizer class]]);
 
   // If a drag is already in progress, do not allow another to start.
@@ skipping 147 matching lines @@
 
 // Observer method.
 - (void)tabModel:(TabModel*)model
       didMoveTab:(Tab*)tab
        fromIndex:(NSUInteger)fromIndex
          toIndex:(NSUInteger)toIndex {
   DCHECK(!_isReordering);
 
   // Reorder the objects in _tabArray to keep in sync with the model ordering.
   NSUInteger arrayIndex = [self indexForModelIndex:fromIndex];
-  base::scoped_nsobject<TabView> view(
-      [[_tabArray objectAtIndex:arrayIndex] retain]);
+  TabView* view = [_tabArray objectAtIndex:arrayIndex];
   [_tabArray removeObject:view];
   [_tabArray insertObject:view atIndex:toIndex];
   [self setNeedsLayoutWithAnimation];
 }
 
 // Observer method.
 - (void)tabModel:(TabModel*)model
     didChangeActiveTab:(Tab*)newTab
            previousTab:(Tab*)previousTab
                atIndex:(NSUInteger)modelIndex {
-  for (TabView* view in _tabArray.get()) {
+  for (TabView* view in _tabArray) {
     [view setSelected:NO];
   }
 
   NSUInteger index = [self indexForModelIndex:modelIndex];
   TabView* activeView = [_tabArray objectAtIndex:index];
   [activeView setSelected:YES];
 
   // No need to animate this change, as selecting a new tab simply changes the
   // z-ordering of the TabViews.  If a new tab was selected as a result of a tab
   // closure, then the animated layout has already been scheduled.
@@ skipping 46 matching lines @@
       [UIImage imageNamed:@"tabswitcher_tab_switcher_button"];
   tabSwitcherButtonIcon = [tabSwitcherButtonIcon
       imageWithRenderingMode:UIImageRenderingModeAlwaysTemplate];
   int tabSwitcherButtonIdsAccessibilityLabel =
       IDS_IOS_TAB_STRIP_ENTER_TAB_SWITCHER;
   NSString* tabSwitcherButtonEnglishUiAutomationName = @"Enter Tab Switcher";
   const CGFloat tabStripHeight = _view.frame.size.height;
   CGRect buttonFrame =
       CGRectMake(CGRectGetMaxX(_view.frame) - kTabSwitcherButtonWidth, 0.0,
                  kTabSwitcherButtonWidth, tabStripHeight);
-  _tabSwitcherButton.reset(
-      [[UIButton buttonWithType:UIButtonTypeCustom] retain]);
+  _tabSwitcherButton = [UIButton buttonWithType:UIButtonTypeCustom];
   [_tabSwitcherButton setTintColor:[UIColor whiteColor]];
   [_tabSwitcherButton setFrame:buttonFrame];
   [_tabSwitcherButton setContentMode:UIViewContentModeCenter];
   [_tabSwitcherButton setAutoresizingMask:UIViewAutoresizingFlexibleLeftMargin];
   [_tabSwitcherButton setBackgroundColor:[UIColor clearColor]];
   [_tabSwitcherButton setExclusiveTouch:YES];
   [_tabSwitcherButton setImage:tabSwitcherButtonIcon
                       forState:UIControlStateNormal];
   // Set target/action to bubble up with command id as tag.
   [_tabSwitcherButton addTarget:nil
@@ skipping 120 matching lines @@
     }
 
     // To handle content offset change without making views appear to jump,
     // shift all of the subviews by an amount equal to the size change.
     [self shiftTabStripSubviews:oldOffset];
     return;
   }
 
   NSUInteger numNonClosingTabsToLeft = 0;
   NSUInteger i = 0;
-  for (TabView* tab in _tabArray.get()) {
+  for (TabView* tab in _tabArray) {
     if ([_closingTabs containsObject:tab])
       ++i;
 
     if (i == tabIndex)
       break;
 
     ++numNonClosingTabsToLeft;
     ++i;
   }
 
@@ skipping 36 matching lines @@
 
 - (void)updateScrollViewFrameForTabSwitcherButton {
   CGRect tabFrame = _tabStripView.frame;
   tabFrame.size.width = _view.bounds.size.width;
   if (!IsCompactTablet()) {
     tabFrame.size.width -= kTabSwitcherButtonWidth;
     _tabStripView.contentInset = UIEdgeInsetsZero;
     [_tabSwitcherButtonBackgroundView setHidden:YES];
   } else {
     if (!_tabSwitcherButtonBackgroundView) {
-      _tabSwitcherButtonBackgroundView.reset([[UIImageView alloc] init]);
+      _tabSwitcherButtonBackgroundView = [[UIImageView alloc] init];
       const CGFloat tabStripHeight = _view.frame.size.height;
       const CGRect backgroundViewFrame = CGRectMake(
           CGRectGetMaxX(_view.frame) - kTabSwitcherButtonBackgroundWidth, 0.0,
           kTabSwitcherButtonBackgroundWidth, tabStripHeight);
       [_tabSwitcherButtonBackgroundView setFrame:backgroundViewFrame];
       [_tabSwitcherButtonBackgroundView
           setAutoresizingMask:UIViewAutoresizingFlexibleLeftMargin];
       UIImage* backgroundTabSwitcherImage =
           [UIImage imageNamed:@"tabstrip_toggle_button_gradient"];
       [_tabSwitcherButtonBackgroundView setImage:backgroundTabSwitcherImage];
@@ skipping 303 matching lines @@
 }
 
 @end
 
 #pragma mark - TabSwitcherAnimation
 
 @implementation TabStripController (TabSwitcherAnimation)
 
 - (TabSwitcherTabStripPlaceholderView*)placeholderView {
   TabSwitcherTabStripPlaceholderView* placeholderView =
-      [[[TabSwitcherTabStripPlaceholderView alloc]
-          initWithFrame:self.view.bounds] autorelease];
+      [[TabSwitcherTabStripPlaceholderView alloc]
+          initWithFrame:self.view.bounds];
   CGFloat xOffset = [_tabStripView contentOffset].x;
   UIView* previousView = nil;
   const NSUInteger selectedModelIndex =
       [_tabModel indexOfTab:[_tabModel currentTab]];
   const NSUInteger selectedArrayIndex =
       [self indexForModelIndex:selectedModelIndex];
   [self updateContentSizeAndRepositionViews];
   [self layoutTabStripSubviews];
   for (NSUInteger tabArrayIndex = 0; tabArrayIndex < [_tabArray count];
        ++tabArrayIndex) {
@@ skipping 22 matching lines @@
 
 @implementation TabStripController (Testing)
 
 - (TabView*)existingTabViewForTab:(Tab*)tab {
   NSUInteger tabIndex = [_tabModel indexOfTab:tab];
   NSUInteger tabViewIndex = [self indexForModelIndex:tabIndex];
   return [_tabArray objectAtIndex:tabViewIndex];
 }
 
 @end