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

ios/chrome/browser/ui/tab_switcher/tab_switcher_controller.mm

 // Copyright 2015 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/tab_switcher/tab_switcher_controller.h"
 
 #include "base/ios/block_types.h"
-#include "base/ios/weak_nsobject.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 "components/browser_sync/profile_sync_service.h"
 #include "components/sessions/core/tab_restore_service_helper.h"
 #include "components/sync/driver/sync_service.h"
 #include "components/sync_sessions/open_tabs_ui_delegate.h"
 #import "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/chrome_url_constants.h"
 #import "ios/chrome/browser/metrics/tab_usage_recorder.h"
@@ skipping 26 matching lines @@
 #include "ios/chrome/browser/ui/ui_util.h"
 #import "ios/chrome/browser/ui/uikit_ui_util.h"
 #include "ios/chrome/grit/ios_strings.h"
 #include "ios/chrome/grit/ios_theme_resources.h"
 #import "ios/third_party/material_components_ios/src/components/Palettes/src/MaterialPalettes.h"
 #import "ios/web/public/navigation_manager.h"
 #include "ios/web/public/referrer.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 
 // Offsets for computing the panels' indexes in the TabSwitcherView.
 const int kSignInPromoPanelIndex = 2;
 const int kHeaderDistantSessionIndexOffset = 2;
 const int kLocalTabsOffTheRecordPanelIndex = 0;
 const int kLocalTabsOnTheRecordPanelIndex = 1;
 // The duration of the tab switcher toggle animation.
 const CGFloat kTransitionAnimationDuration = 0.25;
 // The height of the browser view controller header.
@@ skipping 18 matching lines @@
                                     TabSwitcherHeaderViewDataSource,
                                     TabSwitcherPanelControllerDelegate> {
   // weak.
   ios::ChromeBrowserState* _browserState;
   // weak.
   id<TabSwitcherDelegate> _delegate;
   // The model selected when the tab switcher was toggled.
   // weak.
   TabModel* _onLoadActiveModel;
   // The view this controller manages.
-  base::scoped_nsobject<TabSwitcherView> _tabSwitcherView;
+  TabSwitcherView* _tabSwitcherView;
   // The list of panels controllers for distant sessions.
-  base::scoped_nsobject<NSMutableArray> _controllersOfDistantSessions;
+  NSMutableArray* _controllersOfDistantSessions;
   // The panel controllers for the local sessions.
-  base::scoped_nsobject<TabSwitcherPanelController> _onTheRecordSession;
-  base::scoped_nsobject<TabSwitcherPanelController> _offTheRecordSession;
+  TabSwitcherPanelController* _onTheRecordSession;
+  TabSwitcherPanelController* _offTheRecordSession;
   // The model storing the state of what is shown by the tab switcher.
-  base::scoped_nsobject<TabSwitcherModel> _tabSwitcherModel;
+  TabSwitcherModel* _tabSwitcherModel;
   // Stores the current sign-in panel type.
   TabSwitcherSignInPanelsType _signInPanelType;
   // Cache for the panel's cells.
-  base::scoped_nsobject<TabSwitcherCache> _cache;
+  TabSwitcherCache* _cache;
   // Stores the background color of the window when the tab switcher was
   // presented.
-  base::scoped_nsobject<UIColor> _initialWindowBackgroundColor;
+  UIColor* _initialWindowBackgroundColor;
   // Indicate whether a previous promo panel header cell should be removed or
   // added.
   BOOL _shouldRemovePromoPanelHeaderCell;
   BOOL _shouldAddPromoPanelHeaderCell;
 }
 
 // Updates the window background color to the tab switcher's background color.
 // The original background color can be restored by calling
 //  -restoreWindowBackgroundColor.
 - (void)updateWindowBackgroundColor;
@@ skipping 67 matching lines @@
                         mainTabModel:(TabModel*)mainTabModel
                          otrTabModel:(TabModel*)otrTabModel
                       activeTabModel:(TabModel*)activeTabModel {
   DCHECK(mainTabModel);
   DCHECK(otrTabModel);
   DCHECK(activeTabModel == otrTabModel || activeTabModel == mainTabModel);
   self = [super initWithNibName:nil bundle:nil];
   if (self) {
     _browserState = browserState;
     _onLoadActiveModel = activeTabModel;
-    _cache.reset([[TabSwitcherCache alloc] init]);
+    _cache = [[TabSwitcherCache alloc] init];
     [_cache setMainTabModel:mainTabModel otrTabModel:otrTabModel];
-    _tabSwitcherModel.reset([[TabSwitcherModel alloc]
-        initWithBrowserState:browserState
-                    delegate:self
-                mainTabModel:mainTabModel
-                 otrTabModel:otrTabModel
-                   withCache:_cache]);
-    _controllersOfDistantSessions.reset([[NSMutableArray alloc] init]);
+    _tabSwitcherModel =
+        [[TabSwitcherModel alloc] initWithBrowserState:browserState
+                                              delegate:self
+                                          mainTabModel:mainTabModel
+                                           otrTabModel:otrTabModel
+                                             withCache:_cache];
+    _controllersOfDistantSessions = [[NSMutableArray alloc] init];
     [self loadTabSwitcherView];
-    _onTheRecordSession.reset([[TabSwitcherPanelController alloc]
+    _onTheRecordSession = [[TabSwitcherPanelController alloc]
                 initWithModel:_tabSwitcherModel
         forLocalSessionOfType:TabSwitcherSessionType::REGULAR_SESSION
                     withCache:_cache
-                 browserState:_browserState]);
+                 browserState:_browserState];
     [_onTheRecordSession setDelegate:self];
-    _offTheRecordSession.reset([[TabSwitcherPanelController alloc]
+    _offTheRecordSession = [[TabSwitcherPanelController alloc]
                 initWithModel:_tabSwitcherModel
         forLocalSessionOfType:TabSwitcherSessionType::OFF_THE_RECORD_SESSION
                     withCache:_cache
-                 browserState:_browserState]);
+                 browserState:_browserState];
     [_offTheRecordSession setDelegate:self];
     [_tabSwitcherView addPanelView:[_offTheRecordSession view]
                            atIndex:kLocalTabsOffTheRecordPanelIndex];
     [_tabSwitcherView addPanelView:[_onTheRecordSession view]
                            atIndex:kLocalTabsOnTheRecordPanelIndex];
     [self addPromoPanelForSignInPanelType:[_tabSwitcherModel signInPanelType]];
     [[_tabSwitcherView headerView] reloadData];
     [_tabSwitcherModel syncedSessionsChanged];
     [self selectPanelForTabModel:_onLoadActiveModel];
   }
   return self;
 }
 
 #pragma mark - UIViewController
 
 - (BOOL)prefersStatusBarHidden {
   return NO;
 }
 
 - (UIStatusBarStyle)preferredStatusBarStyle {
   return UIStatusBarStyleLightContent;
 }
 
 - (CGRect)tabSwitcherInitialFrame {
   return [[UIScreen mainScreen] bounds];
 }
 
 - (void)loadTabSwitcherView {
   DCHECK(![_tabSwitcherView superview]);
-  _tabSwitcherView.reset(
-      [[TabSwitcherView alloc] initWithFrame:[self tabSwitcherInitialFrame]]);
+  _tabSwitcherView =
+      [[TabSwitcherView alloc] initWithFrame:[self tabSwitcherInitialFrame]];
   [_tabSwitcherView setAutoresizingMask:UIViewAutoresizingFlexibleWidth |
                                         UIViewAutoresizingFlexibleHeight];
   [_tabSwitcherView setDelegate:self];
   [[_tabSwitcherView headerView] setDelegate:self];
   [[_tabSwitcherView headerView] setDataSource:self];
 }
 
 - (void)viewDidLoad {
   [super viewDidLoad];
   [self.view setAutoresizingMask:UIViewAutoresizingFlexibleWidth |
                                  UIViewAutoresizingFlexibleHeight];
   [_tabSwitcherView setFrame:self.view.bounds];
   [self.view addSubview:_tabSwitcherView];
 }
 
 #pragma mark - UIResponder
 
 - (NSArray*)keyCommands {
-  base::WeakNSObject<TabSwitcherController> weakSelf(self);
+  __weak TabSwitcherController* weakSelf = self;
   return @[
     [UIKeyCommand
         cr_keyCommandWithInput:@"t"
                  modifierFlags:UIKeyModifierCommand
                          title:l10n_util::GetNSStringWithFixup(
                                    IDS_IOS_TOOLS_MENU_NEW_TAB)
                         action:^{
-                          base::scoped_nsobject<TabSwitcherController>
-                              strongSelf([weakSelf retain]);
+                          TabSwitcherController* strongSelf = weakSelf;
                           if (!strongSelf)
                             return;
                           if ([strongSelf currentPanelIndex] ==
                               kLocalTabsOffTheRecordPanelIndex) {
                             [strongSelf openNewTabInPanelAtIndex:
                                             kLocalTabsOffTheRecordPanelIndex];
                           } else {
                             [strongSelf openNewTabInPanelAtIndex:
                                             kLocalTabsOnTheRecordPanelIndex];
                           }
@@ skipping 13 matching lines @@
                          title:l10n_util::GetNSStringWithFixup(
                                    IDS_IOS_KEYBOARD_REOPEN_CLOSED_TAB)
                         action:^{
                           [weakSelf reopenClosedTab];
                         }],
     [UIKeyCommand
         cr_keyCommandWithInput:@"n"
                  modifierFlags:UIKeyModifierCommand
                          title:nil
                         action:^{
-                          base::scoped_nsobject<TabSwitcherController>
-                              strongSelf([weakSelf retain]);
+                          TabSwitcherController* strongSelf = weakSelf;
                           if (!strongSelf)
                             return;
                           if ([strongSelf currentPanelIndex] ==
                               kLocalTabsOffTheRecordPanelIndex) {
                             [strongSelf openNewTabInPanelAtIndex:
                                             kLocalTabsOffTheRecordPanelIndex];
                           } else {
                             [strongSelf openNewTabInPanelAtIndex:
                                             kLocalTabsOnTheRecordPanelIndex];
                           }
@@ skipping 86 matching lines @@
     default:
       [super chromeExecuteCommand:sender];
       break;
   }
 }
 
 #pragma mark - Private
 
 - (void)updateWindowBackgroundColor {
   DCHECK(!_initialWindowBackgroundColor);
-  _initialWindowBackgroundColor.reset(
-      [self.view.window.backgroundColor retain]);
+  _initialWindowBackgroundColor = self.view.window.backgroundColor;
   self.view.window.backgroundColor = [[MDCPalette greyPalette] tint900];
 }
 
 - (void)restoreWindowBackgroundColor {
   self.view.window.backgroundColor = _initialWindowBackgroundColor;
-  _initialWindowBackgroundColor.reset();
+  _initialWindowBackgroundColor = nil;
 }
 
 - (UIView*)snapshotViewForView:(UIView*)inputView
                      withModel:(TabModel*)tabModel
                         option:(SnapshotViewOption)option {
   if (inputView) {
     if (option == SnapshotViewOption::SNAPSHOT_VIEW) {
       UIView* view = [inputView snapshotViewAfterScreenUpdates:NO];
       if (view)
         return view;
     }
     // If the view has just been created, it has not been rendered by Core
     // Animation and the snapshot view can't be generated. In that case we
     // trigger a client side rendering of the view and use the rendered image
     // as the backing store of a view layer.
     UIGraphicsBeginImageContextWithOptions(inputView.bounds.size,
                                            inputView.opaque, 0);
     [inputView.layer renderInContext:UIGraphicsGetCurrentContext()];
     UIImage* screenshot = UIGraphicsGetImageFromCurrentImageContext();
     UIGraphicsEndImageContext();
-    UIView* view = [[[UIView alloc] initWithFrame:CGRectZero] autorelease];
+    UIView* view = [[UIView alloc] initWithFrame:CGRectZero];
     [view layer].contents = static_cast<id>(screenshot.CGImage);
     return view;
   } else {
     // When the input view is nil, we can't generate a snapshot so a placeholder
     // is returned.
     UIColor* backgroundColor = [tabModel isOffTheRecord]
                                    ? [[MDCPalette greyPalette] tint700]
                                    : [[MDCPalette greyPalette] tint100];
-    UIView* placeholdView =
-        [[[UIView alloc] initWithFrame:CGRectZero] autorelease];
+    UIView* placeholdView = [[UIView alloc] initWithFrame:CGRectZero];
     placeholdView.backgroundColor = backgroundColor;
     return placeholdView;
   }
 }
 
 - (TabSwitcherTransitionContextContent*)transitionContextContentForTabModel:
     (TabModel*)tabModel {
   if ([tabModel isOffTheRecord])
     return self.transitionContext.incognitoContent;
   else
@@ skipping 88 matching lines @@
 
   // Compute initial and final toolbar screenshot frames.
   const CGRect initialToolbarFrame = toolbarController.view.frame;
   CGRect initialToolbarScreenshotFrame = CGRectMake(
       0, 0, initialToolbarFrame.size.width, initialToolbarFrame.size.height);
 
   const CGFloat cellTopBarHeight = tabSwitcherLocalSessionCellTopBarHeight();
   CGRect finalToolbarScreenshotFrame =
       CGRectMake(0, 0, selectedCellFrame.size.width, cellTopBarHeight);
 
-  base::scoped_nsobject<UIImageView> tabScreenshotImageView(
-      [[UIImageView alloc] initWithFrame:CGRectZero]);
+  UIImageView* tabScreenshotImageView =
+      [[UIImageView alloc] initWithFrame:CGRectZero];
 
-  base::WeakNSObject<UIImageView> weakTabScreenshotImageView(
-      tabScreenshotImageView.get());
+  __weak UIImageView* weakTabScreenshotImageView = tabScreenshotImageView;
 
   if ([self initialTabModelAndTabIDMatchesTabModel:tabModel
                                              tabID:selectedTab.tabId]) {
-    tabScreenshotImageView.get().image =
-        self.transitionContext.tabSnapshotImage;
+    tabScreenshotImageView.image = self.transitionContext.tabSnapshotImage;
   } else {
     // If transitioning to a different tab than the one animated in
     // from, a new snapshot should be generated instead of using the transition
     // context
-    tabScreenshotImageView.get().image =
+    tabScreenshotImageView.image =
         [self updateScreenshotForCellIfNeeded:selectedCell tabModel:tabModel];
     [selectedTab retrieveSnapshot:^(UIImage* snapshot) {
       [weakTabScreenshotImageView setImage:snapshot];
     }];
   }
 
-  const CGSize tabScreenshotImageSize = tabScreenshotImageView.get().image.size;
+  const CGSize tabScreenshotImageSize = tabScreenshotImageView.image.size;
 
   CGRect initialTabScreenshotFrame = CGRectZero;
   const CGSize toolbarSize = toolbarController.view.bounds.size;
   CGSize initialTabTargetSize =
       CGSizeMake(initialTabFrame.size.width,
                  initialTabFrame.size.height - toolbarSize.height);
   CGSize revisedTargetSize = CGSizeZero;
   CalculateProjection(tabScreenshotImageSize, initialTabTargetSize,
                       ProjectionMode::kAspectFill, revisedTargetSize,
                       initialTabScreenshotFrame);
@@ skipping 37 matching lines @@
     std::swap(initialToolbarScreenshotFrame, finalToolbarScreenshotFrame);
   } else {
     [tabStripPlaceholderView foldWithCompletion:^{
       [tabStripPlaceholderView removeFromSuperview];
     }];
   }
 
   tabStripPlaceholderView.frame = tabStripInitialFrame;
 
   // Create and setup placeholder view and subviews.
-  base::scoped_nsobject<UIView> placeholderView(
-      [[UIView alloc] initWithFrame:initialTabFrame]);
+  UIView* placeholderView = [[UIView alloc] initWithFrame:initialTabFrame];
   [placeholderView setClipsToBounds:YES];
   [placeholderView setUserInteractionEnabled:NO];
 
-  tabScreenshotImageView.get().frame = initialTabScreenshotFrame;
-  tabScreenshotImageView.get().contentMode = UIViewContentModeScaleToFill;
-  tabScreenshotImageView.get().autoresizingMask = UIViewAutoresizingNone;
+  tabScreenshotImageView.frame = initialTabScreenshotFrame;
+  tabScreenshotImageView.contentMode = UIViewContentModeScaleToFill;
+  tabScreenshotImageView.autoresizingMask = UIViewAutoresizingNone;
   [placeholderView addSubview:tabScreenshotImageView];
 
   // Try using a snapshot view for dismissal animation because it's faster and
   // the collection view has already been rendered. Use a client rendering
   // otherwise.
   SnapshotViewOption snapshotOption = SnapshotViewOption::SNAPSHOT_VIEW;
   if (transitionType == TransitionType::TRANSITION_PRESENT)
     snapshotOption = SnapshotViewOption::CLIENT_RENDERING;
 
   UIView* finalToolbarScreenshotImageView =
       [self snapshotViewForView:selectedCell.topBar
                       withModel:tabModel
                          option:snapshotOption];
   finalToolbarScreenshotImageView.autoresizingMask = UIViewAutoresizingNone;
   finalToolbarScreenshotImageView.frame = initialToolbarScreenshotFrame;
   [placeholderView addSubview:finalToolbarScreenshotImageView];
 
   UIView* toolbarScreenshotImageView =
       transitionContextContent.toolbarSnapshotView;
   toolbarScreenshotImageView.autoresizingMask = UIViewAutoresizingNone;
   toolbarScreenshotImageView.frame = initialToolbarScreenshotFrame;
   [placeholderView addSubview:toolbarScreenshotImageView];
 
-  base::scoped_nsobject<UIImageView> toolbarShadowImageView(
-      [[UIImageView alloc] initWithFrame:shadowInitialFrame]);
+  UIImageView* toolbarShadowImageView =
+      [[UIImageView alloc] initWithFrame:shadowInitialFrame];
   [toolbarShadowImageView setAutoresizingMask:UIViewAutoresizingNone];
   [toolbarShadowImageView setImage:NativeImage(IDR_IOS_TOOLBAR_SHADOW)];
   [placeholderView addSubview:toolbarShadowImageView];
 
   [self.view addSubview:placeholderView];
 
   [selectedCell setHidden:YES];
   toolbarScreenshotImageView.alpha =
       (transitionType == TransitionType::TRANSITION_DISMISS) ? 0 : 1.0;
 
-  base::WeakNSObject<TabSwitcherController> weakSelf(self);
+  __weak TabSwitcherController* weakSelf = self;
   void (^completionBlock)(BOOL) = ^(BOOL finished) {
-    base::scoped_nsobject<TabSwitcherController> strongSelf([weakSelf retain]);
+    TabSwitcherController* strongSelf = weakSelf;
 
     [tabStripPlaceholderView removeFromSuperview];
     [toolbarScreenshotImageView removeFromSuperview];
     [selectedCell setHidden:NO];
     [placeholderView removeFromSuperview];
 
     if (transitionType == TransitionType::TRANSITION_DISMISS) {
       [strongSelf restoreWindowBackgroundColor];
       if (finished) {
         [strongSelf setTransitionContext:nil];
       }
     }
     [[[strongSelf delegate] tabSwitcherTransitionToolbarOwner]
         reparentToolbarController];
     [[strongSelf view] setUserInteractionEnabled:YES];
     completion();
   };
 
   ProceduralBlock animationBlock = ^{
     toolbarScreenshotImageView.alpha =
         transitionType == TransitionType::TRANSITION_DISMISS ? 1.0 : 0;
     tabStripPlaceholderView.frame = tabStripFinalFrame;
-    toolbarShadowImageView.get().frame = shadowFinalFrame;
-    placeholderView.get().frame = finalTabFrame;
+    toolbarShadowImageView.frame = shadowFinalFrame;
+    placeholderView.frame = finalTabFrame;
     toolbarScreenshotImageView.frame = finalToolbarScreenshotFrame;
     finalToolbarScreenshotImageView.frame = finalToolbarScreenshotFrame;
-    tabScreenshotImageView.get().frame = finalTabScreenshotFrame;
+    tabScreenshotImageView.frame = finalTabScreenshotFrame;
   };
 
   [UIView animateWithDuration:animated ? kTransitionAnimationDuration : 0
                         delay:0
                       options:UIViewAnimationCurveEaseInOut
                    animations:animationBlock
                    completion:completionBlock];
 }
 
 - (BOOL)initialTabModelAndTabIDMatchesTabModel:(nonnull TabModel*)tabModel
@@ skipping 63 matching lines @@
       (selectedTabModel == [_tabSwitcherModel otrTabModel])
           ? kLocalTabsOffTheRecordPanelIndex
           : kLocalTabsOnTheRecordPanelIndex;
   [_tabSwitcherView selectPanelAtIndex:selectedPanel];
 }
 
 - (TabSwitcherPanelController*)panelControllerForTabModel:(TabModel*)tabModel {
   DCHECK(tabModel == [_tabSwitcherModel mainTabModel] ||
          tabModel == [_tabSwitcherModel otrTabModel]);
   if (tabModel == [_tabSwitcherModel mainTabModel])
-    return _onTheRecordSession.get();
+    return _onTheRecordSession;
   if (tabModel == [_tabSwitcherModel otrTabModel])
-    return _offTheRecordSession.get();
+    return _offTheRecordSession;
   return nil;
 }
 
 - (void)tabSwitcherDismissWithModel:(TabModel*)model {
   [self tabSwitcherDismissWithModel:model animated:YES];
 }
 
 - (void)tabSwitcherDismissWithModel:(TabModel*)model animated:(BOOL)animated {
   [self tabSwitcherDismissWithModel:model
                            animated:animated
@@ skipping 137 matching lines @@
   // with the indexes in |_controllersOfDistantSessions|.
   for (NSNumber* objCIndex in [removedIndexes reverseObjectEnumerator]) {
     int index = [objCIndex intValue];
     [_tabSwitcherView removePanelViewAtIndex:index + offset];
     [_controllersOfDistantSessions removeObjectAtIndex:index];
   }
 
   for (NSNumber* objCIndex in insertedIndexes) {
     int index = [objCIndex intValue];
     std::string tag = [_tabSwitcherModel tagOfDistantSessionAtIndex:index];
-    base::scoped_nsobject<TabSwitcherPanelController> panelController(
+    TabSwitcherPanelController* panelController =
         [[TabSwitcherPanelController alloc] initWithModel:_tabSwitcherModel
                                  forDistantSessionWithTag:tag
-                                             browserState:_browserState]);
+                                             browserState:_browserState];
     [panelController setDelegate:self];
     [_tabSwitcherView addPanelView:[panelController view]
                            atIndex:index + offset];
-    [_controllersOfDistantSessions insertObject:panelController.get()
-                                        atIndex:index];
+    [_controllersOfDistantSessions insertObject:panelController atIndex:index];
   }
 
   // Update the header view.
   // The header view's content is created using the panel's content.
   [[_tabSwitcherView headerView] reloadData];
 }
 
 - (void)distantSessionMayNeedUpdate:(std::string const&)tag {
-  for (TabSwitcherPanelController* panel in _controllersOfDistantSessions
-           .get()) {
+  for (TabSwitcherPanelController* panel in _controllersOfDistantSessions) {
     DCHECK([panel isKindOfClass:[TabSwitcherPanelController class]]);
     if ([panel sessionTag] == tag) {
       [panel updateCollectionViewIfNeeded];
       return;
     }
   }
 }
 
 - (void)localSessionMayNeedUpdate:(TabSwitcherSessionType)type {
   if (type == TabSwitcherSessionType::REGULAR_SESSION) {
@@ skipping 18 matching lines @@
   } else {
     _shouldAddPromoPanelHeaderCell = YES;
   }
   [self addPromoPanelForSignInPanelType:newPanelType];
 }
 
 - (void)addPromoPanelForSignInPanelType:(TabSwitcherSignInPanelsType)panelType {
   _signInPanelType = panelType;
   if (panelType != TabSwitcherSignInPanelsType::NO_PANEL) {
     TabSwitcherPanelOverlayView* panelView =
-        [[[TabSwitcherPanelOverlayView alloc] initWithFrame:CGRectZero
-                                               browserState:_browserState]
-            autorelease];
+        [[TabSwitcherPanelOverlayView alloc] initWithFrame:CGRectZero
+                                              browserState:_browserState];
     [panelView setOverlayType:PanelOverlayTypeFromSignInPanelsType(panelType)];
     [_tabSwitcherView addPanelView:panelView atIndex:kSignInPromoPanelIndex];
   }
 }
 
 - (CGSize)sizeForItemAtIndex:(NSUInteger)index
                    inSession:(TabSwitcherSessionType)session {
   switch (session) {
     case TabSwitcherSessionType::OFF_THE_RECORD_SESSION:
       return [[_offTheRecordSession view] cellSize];
@@ skipping 46 matching lines @@
     if (![_tabSwitcherModel distantSessionCount]) {
       // Display promo panel cell if there is no distant sessions.
       return [TabSwitcherSessionCellData otherDevicesSessionCellData];
     } else {
       index -= kHeaderDistantSessionIndexOffset;
 
       sync_sessions::SyncedSession::DeviceType deviceType =
           sync_sessions::SyncedSession::TYPE_UNSET;
       NSString* cellTitle = nil;
 
-      if (index < _controllersOfDistantSessions.get().count) {
+      if (index < _controllersOfDistantSessions.count) {
         TabSwitcherPanelController* panel =
             [_controllersOfDistantSessions objectAtIndex:index];
         const synced_sessions::DistantSession* distantSession =
             [panel distantSession];
         deviceType = distantSession->device_type;
         cellTitle = base::SysUTF8ToNSString(distantSession->name);
       }
       TabSwitcherSessionCellType cellType;
       switch (deviceType) {
         case sync_sessions::SyncedSession::TYPE_PHONE:
           cellType = kPhoneRemoteSessionCell;
           break;
         case sync_sessions::SyncedSession::TYPE_TABLET:
           cellType = kTabletRemoteSessionCell;
           break;
         default:
           cellType = kLaptopRemoteSessionCell;
           break;
       }
       TabSwitcherSessionCellData* sessionData =
-          [[[TabSwitcherSessionCellData alloc] initWithSessionCellType:cellType]
-              autorelease];
+          [[TabSwitcherSessionCellData alloc] initWithSessionCellType:cellType];
       sessionData.title = cellTitle;
       return sessionData;
     }
   }
 }
 
 - (NSInteger)tabSwitcherHeaderViewSelectedPanelIndex {
   return [_tabSwitcherView currentPanelIndex];
 }
 
 #pragma mark - TabSwitcherViewDelegate
 
 - (void)openNewTabInPanelAtIndex:(NSInteger)panelIndex {
   CHECK(panelIndex >= 0);
   DCHECK([self isPanelIndexForLocalSession:panelIndex]);
   const NSInteger tag = (panelIndex == kLocalTabsOnTheRecordPanelIndex)
                             ? IDC_NEW_TAB
                             : IDC_NEW_INCOGNITO_TAB;
   if (tag == IDC_NEW_INCOGNITO_TAB) {
     base::RecordAction(
         base::UserMetricsAction("MobileTabSwitcherCreateIncognitoTab"));
   } else {
     base::RecordAction(
         base::UserMetricsAction("MobileTabSwitcherCreateNonIncognitoTab"));
   }
   // Create and execute command to create the tab.
-  base::scoped_nsobject<GenericChromeCommand> command(
-      [[GenericChromeCommand alloc] initWithTag:tag]);
+  GenericChromeCommand* command =
+      [[GenericChromeCommand alloc] initWithTag:tag];
   [self chromeExecuteCommand:command];
 }
 
 - (ios_internal::NewTabButtonStyle)buttonStyleForPanelAtIndex:
     (NSInteger)panelIndex {
   CHECK(panelIndex >= 0);
   switch (panelIndex) {
     case kLocalTabsOnTheRecordPanelIndex:
       if ([_onTheRecordSession shouldShowNewTabButton]) {
         return ios_internal::NewTabButtonStyle::BLUE;
@@ skipping 79 matching lines @@
         base::UserMetricsAction("MobileTabSwitcherCloseNonIncognitoTab"));
   }
 }
 
 - (void)tabSwitcherPanelControllerDidUpdateOverlayViewVisibility:
     (TabSwitcherPanelController*)tabSwitcherPanelController {
   [_tabSwitcherView updateOverlayButtonState];
 }
 
 @end