[ObjC ARC] Converts ios/chrome/app:app_internal to ARC.

ios/chrome/app/main_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/app/main_controller.h"
 
 #include <memory>
 #include <string>
 
 #import <CoreSpotlight/CoreSpotlight.h>
 #import <objc/objc.h>
 #import <objc/runtime.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/files/file_path.h"
 #include "base/ios/block_types.h"
 #import "base/mac/bind_objc_block.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/foundation_util.h"
-#include "base/mac/objc_property_releaser.h"
-#import "base/mac/scoped_nsobject.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/time/time.h"
 #include "components/component_updater/component_updater_service.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_service.h"
 #include "components/prefs/pref_change_registrar.h"
@@ skipping 108 matching lines @@
 #include "ios/web/net/web_http_protocol_handler_delegate.h"
 #import "ios/web/public/navigation_manager.h"
 #include "ios/web/public/web_capabilities.h"
 #include "ios/web/public/web_state/web_state.h"
 #import "ios/web/public/web_view_creation_util.h"
 #include "ios/web/public/webui/web_ui_ios_controller_factory.h"
 #include "mojo/edk/embedder/embedder.h"
 #import "net/base/mac/url_conversions.h"
 #include "net/url_request/url_request_context.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 
 // Preference key used to store which profile is current.
 NSString* kIncognitoCurrentKey = @"IncognitoActive";
 
 // Constants for deferred initialization of preferences observer.
 NSString* const kPrefObserverInit = @"PrefObserverInit";
 
 // Constants for deferring notifying the AuthenticationService of a new cold
 // start.
@@ skipping 74 matching lines @@
 
   // Weak; owned by the ChromeBrowserProvider.
   ios::ChromeBrowserStateManager* _browserStateManager;
 
   // The object that drives the Chrome startup/shutdown logic.
   std::unique_ptr<IOSChromeMain> _chromeMain;
 
   // The ChromeBrowserState associated with the main (non-OTR) browsing mode.
   ios::ChromeBrowserState* _mainBrowserState;  // Weak.
 
-  // Coordinators used to run the Chrome UI; there will be one of these active
-  // at any given time, usually |_mainCoordinator|.
-  // Main coordinator, backing object for the property of the same name, which
-  // lazily initializes on access.
-  base::scoped_nsobject<MainCoordinator> _mainCoordinator;
-
   // Wrangler to handle BVC and tab model creation, access, and related logic.
   // Implements faetures exposed from this object through the
   // BrowserViewInformation protocol.
-  base::scoped_nsobject<BrowserViewWrangler> _browserViewWrangler;
+  BrowserViewWrangler* _browserViewWrangler;
 
   // Parameters received at startup time when the app is launched from another
   // app.
-  base::scoped_nsobject<AppStartupParameters> _startupParameters;
+  AppStartupParameters* _startupParameters;
 
   // Navigation View controller for the settings.
-  base::scoped_nsobject<SettingsNavigationController>
-      _settingsNavigationController;
+  SettingsNavigationController* _settingsNavigationController;
 
   // View controller for switching tabs.
-  base::scoped_nsobject<UIViewController<TabSwitcher>> _tabSwitcherController;
+  UIViewController<TabSwitcher>* _tabSwitcherController;
 
   // Controller to display the re-authentication flow.
-  base::scoped_nsobject<SigninInteractionController>
-      _signinInteractionController;
+  SigninInteractionController* _signinInteractionController;
 
   // YES while animating the dismissal of stack view.
   BOOL _dismissingStackView;
 
   // If not NONE, the current BVC should be switched to this BVC on completion
   // of stack view dismissal.
   StackViewDismissalMode _modeToDisplayOnStackViewDismissal;
 
   // If YES, the tab switcher is currently active.
   BOOL _tabSwitcherIsActive;
 
   // True if the current session began from a cold start. False if the app has
   // entered the background at least once since start up.
   BOOL _isColdStart;
 
   // Keeps track of the restore state during startup.
-  base::scoped_nsobject<CrashRestoreHelper> _restoreHelper;
+  CrashRestoreHelper* _restoreHelper;
 
   // An object to record metrics related to the user's first action.
   std::unique_ptr<FirstUserActionRecorder> _firstUserActionRecorder;
 
   // RequestTrackerFactory to customize the behavior of the network stack.
   std::unique_ptr<web::RequestTrackerFactoryImpl> _requestTrackerFactory;
 
   // Configuration for the HTTP protocol handler.
   std::unique_ptr<web::WebHTTPProtocolHandlerDelegate>
       _httpProtocolHandlerDelegate;
@@ skipping 14 matching lines @@
   BOOL _isProcessingTabSwitcherCommand;
   BOOL _isProcessingVoiceSearchCommand;
 
   // Bridge to listen to pref changes.
   std::unique_ptr<PrefObserverBridge> _localStatePrefObserverBridge;
 
   // Registrar for pref changes notifications to the local state.
   PrefChangeRegistrar _localStatePrefChangeRegistrar;
 
   // Clears browsing data from ChromeBrowserStates.
-  base::scoped_nsobject<BrowsingDataRemovalController>
-      _browsingDataRemovalController;
+  BrowsingDataRemovalController* _browsingDataRemovalController;
 
   // The class in charge of showing/hiding the memory debugger when the
   // appropriate pref changes.
-  base::scoped_nsobject<MemoryDebuggerManager> _memoryDebuggerManager;
-
-  base::mac::ObjCPropertyReleaser _propertyReleaser_MainController;
+  MemoryDebuggerManager* _memoryDebuggerManager;
 
   // Responsible for indexing chrome links (such as bookmarks, most likely...)
   // in system Spotlight index.
-  base::scoped_nsobject<SpotlightManager> _spotlightManager;
+  SpotlightManager* _spotlightManager;
 
   // Cached launchOptions from -didFinishLaunchingWithOptions.
-  base::scoped_nsobject<NSDictionary> _launchOptions;
+  NSDictionary* _launchOptions;
 
   // View controller for displaying the history panel.
-  base::scoped_nsobject<UIViewController> _historyPanelViewController;
+  UIViewController* _historyPanelViewController;
 
   // Variable backing metricsMediator property.
-  base::WeakNSObject<MetricsMediator> _metricsMediator;
+  __weak MetricsMediator* _metricsMediator;
 
   // Hander for the startup tasks, deferred or not.
-  base::scoped_nsobject<StartupTasks> _startupTasks;
+  StartupTasks* _startupTasks;
 }
 
 // Pointer to the main view controller, always owned by the main window.
-@property(nonatomic, readonly) MainViewController* mainViewController;
+@property(weak, nonatomic, readonly) MainViewController* mainViewController;
 
 // The main coordinator, lazily created the first time it is accessed. Manages
 // the MainViewController. This property should not be accessed before the
 // browser has started up to the FOREGROUND stage.
 @property(nonatomic, readonly) MainCoordinator* mainCoordinator;
 
 // A property to track whether the QR Scanner should be started upon tab
 // switcher dismissal. It can only be YES if the QR Scanner experiment is
 // enabled.
 @property(nonatomic, readwrite) BOOL startQRScannerAfterTabSwitcherDismissal;
@@ skipping 162 matching lines @@
 // Initializes the application to INITIALIZATION_STAGE_BACKGROUND, which is
 // needed by background handlers.
 - (void)startUpBrowserBackgroundInitialization;
 // Initializes the application to INITIALIZATION_STAGE_FOREGROUND, which is
 // needed when application runs in foreground.
 - (void)startUpBrowserForegroundInitialization;
 @end
 
 @implementation MainController
 
+@synthesize mainCoordinator = _mainCoordinator;
 @synthesize appState = _appState;
 @synthesize appLaunchTime = _appLaunchTime;
 @synthesize browserInitializationStage = _browserInitializationStage;
 @synthesize window = _window;
 @synthesize isPresentingFirstRunUI = _isPresentingFirstRunUI;
 @synthesize isColdStart = _isColdStart;
 @synthesize startVoiceSearchAfterTabSwitcherDismissal =
     _startVoiceSearchAfterTabSwitcherDismissal;
 @synthesize startQRScannerAfterTabSwitcherDismissal =
     _startQRScannerAfterTabSwitcherDismissal;
 @synthesize startFocusOmniboxAfterTabSwitcherDismissal =
     _startFocusOmniboxAfterTabSwitcherDismissal;
+@synthesize launchOptions = _launchOptions;
+@synthesize startupParameters = _startupParameters;
+@synthesize metricsMediator = _metricsMediator;
+@synthesize settingsNavigationController = _settingsNavigationController;
 
 #pragma mark - Application lifecycle
 
 - (instancetype)init {
   if ((self = [super init])) {
-    _propertyReleaser_MainController.Init(self, [MainController class]);
-    _startupTasks.reset([[StartupTasks alloc] init]);
+    _startupTasks = [[StartupTasks alloc] init];
   }
   return self;
 }
 
 - (void)dealloc {
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   net::HTTPProtocolHandlerDelegate::SetInstance(nullptr);
   net::RequestTracker::SetRequestTrackerFactory(nullptr);
   [NSObject cancelPreviousPerformRequestsWithTarget:self];
-  [super dealloc];
 }
 
 // This function starts up to only what is needed at each stage of the
 // initialization. It is possible to continue initialization later.
 - (void)startUpBrowserToStage:(BrowserInitializationStageType)stage {
   if (_browserInitializationStage < INITIALIZATION_STAGE_BASIC &&
       stage >= INITIALIZATION_STAGE_BASIC) {
     [self startUpBrowserBasicInitialization];
     _browserInitializationStage = INITIALIZATION_STAGE_BASIC;
   }
@@ skipping 101 matching lines @@
   _browserStateManager =
       GetApplicationContext()->GetChromeBrowserStateManager();
   ios::ChromeBrowserState* chromeBrowserState =
       _browserStateManager->GetLastUsedBrowserState();
 
   // The CrashRestoreHelper must clean up the old browser state information
   // before the tabModels can be created.  |_restoreHelper| must be kept alive
   // until the BVC receives the browser state and tab model.
   BOOL postCrashLaunch = [self mustShowRestoreInfobar];
   if (postCrashLaunch) {
-    _restoreHelper.reset(
-        [[CrashRestoreHelper alloc] initWithBrowserState:chromeBrowserState]);
+    _restoreHelper =
+        [[CrashRestoreHelper alloc] initWithBrowserState:chromeBrowserState];
     [_restoreHelper moveAsideSessionInformation];
   }
 
   // Initialize and set the main browser state.
   [self initializeBrowserState:chromeBrowserState];
   _mainBrowserState = chromeBrowserState;
   [_browserViewWrangler shutdown];
-  _browserViewWrangler.reset([[BrowserViewWrangler alloc]
-      initWithBrowserState:_mainBrowserState
-          tabModelObserver:self]);
+  _browserViewWrangler =
+      [[BrowserViewWrangler alloc] initWithBrowserState:_mainBrowserState
+                                       tabModelObserver:self];
   // Ensure the main tab model is created.
   ignore_result([_browserViewWrangler mainTabModel]);
 
-  _spotlightManager.reset([[SpotlightManager
-      spotlightManagerWithBrowserState:_mainBrowserState] retain]);
+  _spotlightManager =
+      [SpotlightManager spotlightManagerWithBrowserState:_mainBrowserState];
 
   ShareExtensionService* service =
       ShareExtensionServiceFactory::GetForBrowserState(_mainBrowserState);
   service->Initialize();
 
   // Before bringing up the UI, make sure the launch mode is correct, and
   // check for previous crashes.
   BOOL startInIncognito = [standardDefaults boolForKey:kIncognitoCurrentKey];
   BOOL switchFromIncognito = startInIncognito && ![self canLaunchInIncognito];
 
@@ skipping 14 matching lines @@
   [MetricsMediator logLaunchMetricsWithStartupInformation:self
                                    browserViewInformation:_browserViewWrangler];
 
   [self scheduleLowPriorityStartupTasks];
 
   [_browserViewWrangler updateDeviceSharingManager];
 
   [self openTabFromLaunchOptions:_launchOptions
               startupInformation:self
                         appState:self.appState];
-  _launchOptions.reset();
+  _launchOptions = nil;
 
   mojo::edk::Init();
 
   if (!_startupParameters) {
     // The startup parameters may create new tabs or navigations. If the restore
     // infobar is displayed now, it may be dismissed immediately and the user
     // will never be able to restore the session.
     [_restoreHelper showRestoreIfNeeded:[self currentTabModel]];
-    _restoreHelper.reset();
+    _restoreHelper = nil;
   }
 
   [self scheduleTasksRequiringBVCWithBrowserState];
 
   // Now that everything is properly set up, run the tests.
   tests_hook::RunTestsIfPresent();
 }
 
 - (void)initializeBrowserState:(ios::ChromeBrowserState*)browserState {
   DCHECK(!browserState->IsOffTheRecord());
   search_engines::UpdateSearchEnginesIfNeeded(
       browserState->GetPrefs(),
       ios::TemplateURLServiceFactory::GetForBrowserState(browserState));
 
   if ([TouchToSearchPermissionsMediator isTouchToSearchAvailableOnDevice]) {
-    base::scoped_nsobject<TouchToSearchPermissionsMediator>
-        touchToSearchPermissions([[TouchToSearchPermissionsMediator alloc]
-            initWithBrowserState:browserState]);
+    TouchToSearchPermissionsMediator* touchToSearchPermissions =
+        [[TouchToSearchPermissionsMediator alloc]
+            initWithBrowserState:browserState];
     if (experimental_flags::IsForceResetContextualSearchEnabled()) {
       [touchToSearchPermissions setPreferenceState:TouchToSearch::UNDECIDED];
     }
     ContextualSearch::RecordPreferenceState(
         [touchToSearchPermissions preferenceState]);
   }
 }
 
 - (void)handleFirstRunUIWillFinish {
   DCHECK(_isPresentingFirstRunUI);
   _isPresentingFirstRunUI = NO;
   [[NSNotificationCenter defaultCenter]
       removeObserver:self
                 name:kChromeFirstRunUIWillFinishNotification
               object:nil];
 
   [self markEulaAsAccepted];
 
-  if (_startupParameters.get()) {
+  if (_startupParameters) {
     [self dismissModalsAndOpenSelectedTabInMode:ApplicationMode::NORMAL
                                         withURL:[_startupParameters externalURL]
                                      transition:ui::PAGE_TRANSITION_LINK
                                      completion:nil];
-    _startupParameters.reset();
+    _startupParameters = nil;
   }
 }
 
 - (void)handleFirstRunUIDidFinish {
   [[NSNotificationCenter defaultCenter]
       removeObserver:self
                 name:kChromeFirstRunUIDidFinishNotification
               object:nil];
 
   // As soon as First Run has finished, give OmniboxGeolocationController an
@@ skipping 36 matching lines @@
   }
 
   // Always set the new otr tab model on iPad with tab switcher enabled.
   // Notify the _tabSwitcherController with the new otrBVC.
   if (IsIPadIdiom() || _tabSwitcherIsActive)
     [_tabSwitcherController setOtrTabModel:self.otrTabModel];
 }
 
 - (BrowsingDataRemovalController*)browsingDataRemovalController {
   if (!_browsingDataRemovalController) {
-    _browsingDataRemovalController.reset(
-        [[BrowsingDataRemovalController alloc] initWithDelegate:self]);
+    _browsingDataRemovalController =
+        [[BrowsingDataRemovalController alloc] initWithDelegate:self];
   }
   return _browsingDataRemovalController;
 }
 
 - (void)setWebUsageEnabled:(BOOL)enabled {
   DCHECK([NSThread isMainThread]);
   if (enabled) {
     [self activateBVCAndMakeCurrentBVCPrimary];
   } else {
     [self.mainBVC setActive:NO];
     [self.otrBVC setActive:NO];
   }
 }
 
 - (void)activateBVCAndMakeCurrentBVCPrimary {
   // If there are pending removal operations, the activation will be deferred
   // until the callback for |removeBrowsingDataFromBrowserState:| is received.
   if (![self.browsingDataRemovalController
           hasPendingRemovalOperations:self.currentBrowserState]) {
     [self.mainBVC setActive:YES];
     [self.otrBVC setActive:YES];
 
     [self.currentBVC setPrimary:YES];
   }
 }
 
-#pragma mark - BrowserLauncher implementation.
-
-- (NSDictionary*)launchOptions {
-  return _launchOptions;
-}
-
-- (void)setLaunchOptions:(NSDictionary*)launchOptions {
-  _launchOptions.reset([launchOptions retain]);
-}
-
 #pragma mark - Property implementation.
 
 - (id<BrowserViewInformation>)browserViewInformation {
   return _browserViewWrangler;
 }
 
-- (AppStartupParameters*)startupParameters {
-  return _startupParameters;
-}
-
-- (void)setStartupParameters:(AppStartupParameters*)startupParameters {
-  _startupParameters.reset([startupParameters retain]);
-}
-
 - (MainViewController*)mainViewController {
   return self.mainCoordinator.mainViewController;
 }
 
 - (MainCoordinator*)mainCoordinator {
   if (_browserInitializationStage == INITIALIZATION_STAGE_BASIC) {
     NOTREACHED() << "mainCoordinator accessed too early in initialization.";
     return nil;
   }
   if (!_mainCoordinator) {
     // Lazily create the main coordinator.
-    _mainCoordinator.reset(
-        [[MainCoordinator alloc] initWithWindow:self.window]);
+    _mainCoordinator = [[MainCoordinator alloc] initWithWindow:self.window];
   }
   return _mainCoordinator;
 }
 
 - (BOOL)isFirstLaunchAfterUpgrade {
   return [[PreviousSessionInfo sharedInstance] isFirstSessionAfterUpgrade];
 }
 
-- (MetricsMediator*)metricsMediator {
-  return _metricsMediator;
-}
-
-- (void)setMetricsMediator:(MetricsMediator*)metricsMediator {
-  _metricsMediator.reset(metricsMediator);
-}
-
-- (SettingsNavigationController*)settingsNavigationController {
-  return _settingsNavigationController;
-}
-
-- (void)setSettingsNavigationController:
-    (SettingsNavigationController*)settingsNavigationController {
-  _settingsNavigationController.reset([settingsNavigationController retain]);
-}
-
 #pragma mark - StartupInformation implementation.
 
 - (FirstUserActionRecorder*)firstUserActionRecorder {
   return _firstUserActionRecorder.get();
 }
 
 - (void)resetFirstUserActionRecorder {
   _firstUserActionRecorder.reset();
 }
 
 - (void)expireFirstUserActionRecorderAfterDelay:(NSTimeInterval)delay {
   [self performSelector:@selector(expireFirstUserActionRecorder)
              withObject:nil
              afterDelay:delay];
 }
 
 - (void)activateFirstUserActionRecorderWithBackgroundTime:
     (NSTimeInterval)backgroundTime {
   base::TimeDelta delta = base::TimeDelta::FromSeconds(backgroundTime);
   _firstUserActionRecorder.reset(new FirstUserActionRecorder(delta));
 }
 
 - (void)stopChromeMain {
   [_spotlightManager shutdown];
-  _spotlightManager.reset();
+  _spotlightManager = nil;
 
   [_browserViewWrangler shutdown];
-  _browserViewWrangler.reset();
+  _browserViewWrangler = nil;
 
   _chromeMain.reset();
 }
 
 - (BOOL)isTabSwitcherActive {
   return _tabSwitcherIsActive;
 }
 
 #pragma mark - BrowserViewInformation implementation.
 
@@ skipping 179 matching lines @@
   if (![self mustShowRestoreInfobar]) {
     [self scheduleSnapshotPurge];
   }
 }
 
 - (void)scheduleMemoryDebuggingTools {
   if (experimental_flags::IsMemoryDebuggingEnabled()) {
     [[DeferredInitializationRunner sharedInstance]
         enqueueBlockNamed:kMemoryDebuggingToolsStartup
                     block:^{
-                      _memoryDebuggerManager.reset(
-                          [[MemoryDebuggerManager alloc]
-                              initWithView:self.window
-                                     prefs:GetApplicationContext()
-                                               ->GetLocalState()]);
+                      _memoryDebuggerManager = [[MemoryDebuggerManager alloc]
+                          initWithView:self.window
+                                 prefs:GetApplicationContext()
+                                           ->GetLocalState()];
                     }];
   }
 }
 
 - (void)startFreeMemoryMonitoring {
   base::PostTaskWithTraits(
       FROM_HERE, {base::MayBlock(), base::TaskPriority::BACKGROUND},
       base::BindOnce(&ios_internal::AsynchronousFreeMemoryMonitor));
 }
 
@@ skipping 114 matching lines @@
   }
   if (_tabSwitcherIsActive)
     [self dismissTabSwitcherWithoutAnimationInModel:self.mainTabModel];
   if (firstRun || [self shouldOpenNTPTabOnActivationOfTabModel:tabModel]) {
     [self.currentBVC newTab:nil];
   }
 
   if (firstRun) {
     [self showFirstRunUI];
     // Do not ever show the 'restore' infobar during first run.
-    _restoreHelper.reset();
+    _restoreHelper = nil;
   }
 }
 
 - (void)showFirstRunUI {
   // Register for notification when First Run is completed.
   // Some initializations are held back until First Run modal dialog
   // is dismissed.
   [[NSNotificationCenter defaultCenter]
       addObserver:self
          selector:@selector(handleFirstRunUIWillFinish)
              name:kChromeFirstRunUIWillFinishNotification
            object:nil];
   [[NSNotificationCenter defaultCenter]
       addObserver:self
          selector:@selector(handleFirstRunUIDidFinish)
              name:kChromeFirstRunUIDidFinishNotification
            object:nil];
 
-  base::scoped_nsobject<WelcomeToChromeViewController> welcomeToChrome(
+  WelcomeToChromeViewController* welcomeToChrome =
       [[WelcomeToChromeViewController alloc]
           initWithBrowserState:_mainBrowserState
-                      tabModel:self.mainTabModel]);
-  base::scoped_nsobject<UINavigationController> navController(
+                      tabModel:self.mainTabModel];
+  UINavigationController* navController =
       [[OrientationLimitingNavigationController alloc]
-          initWithRootViewController:welcomeToChrome]);
+          initWithRootViewController:welcomeToChrome];
   [navController setModalTransitionStyle:UIModalTransitionStyleCrossDissolve];
   CGRect appFrame = [[UIScreen mainScreen] bounds];
   [[navController view] setFrame:appFrame];
   _isPresentingFirstRunUI = YES;
   [self.mainBVC presentViewController:navController animated:NO completion:nil];
 }
 
 - (void)crashIfRequested {
   if (experimental_flags::IsStartupCrashEnabled()) {
     // Flush out the value cached for
@@ skipping 45 matching lines @@
 
       break;
     }
   }
 }
 
 - (void)showPromo:(UIViewController*)promo {
   // Make sure we have the BVC here with a valid profile.
   DCHECK([self.currentBVC browserState]);
 
-  base::scoped_nsobject<OrientationLimitingNavigationController> navController(
+  OrientationLimitingNavigationController* navController =
       [[OrientationLimitingNavigationController alloc]
-          initWithRootViewController:promo]);
+          initWithRootViewController:promo];
 
   // Avoid presenting the promo if the current device orientation is not
   // supported. The promo will be presented at a later moment, when the device
   // orientation is supported.
   UIInterfaceOrientation orientation =
       [UIApplication sharedApplication].statusBarOrientation;
   NSUInteger supportedOrientationsMask =
       [navController supportedInterfaceOrientations];
   if (!((1 << orientation) & supportedOrientationsMask))
     return;
@@ skipping 18 matching lines @@
       break;
     case IDC_NEW_INCOGNITO_TAB:
       [self createNewTabInBVC:self.otrBVC sender:sender];
       break;
     case IDC_OPEN_URL:
       [self openUrl:base::mac::ObjCCast<OpenUrlCommand>(sender)];
       break;
     case IDC_OPTIONS:
       [self showSettings];
       break;
-    case IDC_REPORT_AN_ISSUE:
+    case IDC_REPORT_AN_ISSUE: {
       dispatch_async(dispatch_get_main_queue(), ^{
         [self showReportAnIssue];
       });
-      break;
+    } break;
     case IDC_SHOW_SIGNIN_IOS: {
       ShowSigninCommand* command =
           base::mac::ObjCCastStrict<ShowSigninCommand>(sender);
       if (command.operation == AUTHENTICATION_OPERATION_DISMISS) {
         [self dismissSigninInteractionController];
       } else {
         [self showSigninWithOperation:command.operation
                              identity:command.identity
                           accessPoint:command.accessPoint
                           promoAction:command.promoAction
@@ skipping 10 matching lines @@
       break;
     case IDC_SHOW_SYNC_PASSPHRASE_SETTINGS:
       [self showSyncEncryptionPassphrase];
       break;
     case IDC_SHOW_SAVE_PASSWORDS_SETTINGS:
       [self showSavePasswordsSettings];
       break;
     case IDC_SHOW_HISTORY:
       [self showHistory];
       break;
-    case IDC_TOGGLE_TAB_SWITCHER:
+    case IDC_TOGGLE_TAB_SWITCHER: {
       DCHECK(!_tabSwitcherIsActive);
       if (!_isProcessingVoiceSearchCommand) {
         [self showTabSwitcher];
         _isProcessingTabSwitcherCommand = YES;
         dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
                                      kExpectedTransitionDurationInNanoSeconds),
                        dispatch_get_main_queue(), ^{
                          _isProcessingTabSwitcherCommand = NO;
                        });
       }
-      break;
+    } break;
+
     case IDC_PRELOAD_VOICE_SEARCH:
       [self.currentBVC chromeExecuteCommand:sender];
       break;
-    case IDC_VOICE_SEARCH:
+    case IDC_VOICE_SEARCH: {
       if (!_isProcessingTabSwitcherCommand) {
         [self startVoiceSearch];
         _isProcessingVoiceSearchCommand = YES;
         dispatch_after(dispatch_time(DISPATCH_TIME_NOW,
                                      kExpectedTransitionDurationInNanoSeconds),
                        dispatch_get_main_queue(), ^{
                          _isProcessingVoiceSearchCommand = NO;
                        });
       }
-      break;
+    } break;
+
     case IDC_CLEAR_BROWSING_DATA_IOS: {
       // Clear both the main browser state and the associated incognito
       // browser state.
       ClearBrowsingDataCommand* command =
           base::mac::ObjCCastStrict<ClearBrowsingDataCommand>(sender);
       ios::ChromeBrowserState* browserState =
           [command browserState]->GetOriginalChromeBrowserState();
       int mask = [command mask];
       browsing_data::TimePeriod timePeriod = [command timePeriod];
       [self removeBrowsingDataFromBrowserState:browserState
@@ skipping 159 matching lines @@
 #pragma mark - Tab closure handlers
 
 - (void)lastIncognitoTabClosed {
   DCHECK(_mainBrowserState->HasOffTheRecordChromeBrowserState());
   [self clearIOSSpecificIncognitoData];
 
   // OffTheRecordProfileIOData cannot be deleted before all the requests are
   // deleted. All of the request trackers associated with the closed OTR tabs
   // will have posted CancelRequest calls to the IO thread by now; this just
   // waits for those calls to run before calling |deleteIncognitoBrowserState|.
-  web::RequestTrackerImpl::RunAfterRequestsCancel(base::BindBlock(^{
+  web::RequestTrackerImpl::RunAfterRequestsCancel(base::BindBlockArc(^{
     [self deleteIncognitoBrowserState];
   }));
 
   // a) The first condition can happen when the last incognito tab is closed
   // from the tab switcher.
   // b) The second condition can happen if some other code (like JS) triggers
   // closure of tabs from the otr tab model when it's not current.
   // Nothing to do here. The next user action (like clicking on an existing
   // regular tab or creating a new incognito tab from the settings menu) will
   // take care of the logic to mode switch.
@@ skipping 71 matching lines @@
   BrowserViewController* currentBVC = self.currentBVC;
   Tab* currentTab = [[currentBVC tabModel] currentTab];
 
   // In order to generate the transition between the current browser view
   // controller and the tab switcher controller it's possible that multiple
   // screenshots of the same tab are taken. Since taking a screenshot is
   // expensive we activate snapshot coalescing in the scope of this function
   // which will cache the first snapshot for the tab and reuse it instead of
   // regenerating a new one each time.
   [currentTab setSnapshotCoalescingEnabled:YES];
-  base::ScopedClosureRunner runner(base::BindBlock(^{
+  base::ScopedClosureRunner runner(base::BindBlockArc(^{
     [currentTab setSnapshotCoalescingEnabled:NO];
   }));
 
   [currentBVC prepareToEnterTabSwitcher:nil];
 
-  if (!_tabSwitcherController.get()) {
+  if (!_tabSwitcherController) {
     if (IsIPadIdiom()) {
-      _tabSwitcherController.reset([[TabSwitcherController alloc]
+      _tabSwitcherController = [[TabSwitcherController alloc]
           initWithBrowserState:_mainBrowserState
                   mainTabModel:self.mainTabModel
                    otrTabModel:self.otrTabModel
-                activeTabModel:self.currentTabModel]);
+                activeTabModel:self.currentTabModel];
     } else {
-      _tabSwitcherController.reset([[StackViewController alloc]
+      _tabSwitcherController = [[StackViewController alloc]
           initWithMainTabModel:self.mainTabModel
                    otrTabModel:self.otrTabModel
-                activeTabModel:self.currentTabModel]);
+                activeTabModel:self.currentTabModel];
     }
   } else {
     // The StackViewController is kept in memory to avoid the performance hit of
     // loading from the nib on next showing, but clears out its card models to
     // release memory.  The tab models are required to rebuild the card stacks.
     [_tabSwitcherController
         restoreInternalStateWithMainTabModel:self.mainTabModel
                                  otrTabModel:self.otrTabModel
                               activeTabModel:self.currentTabModel];
   }
@@ skipping 88 matching lines @@
   // Prevent wayward touches from wreaking havoc while the stack view is being
   // dismissed.
   [[_tabSwitcherController view] setUserInteractionEnabled:NO];
   BrowserViewController* targetBVC =
       (tabModel == self.mainTabModel) ? self.mainBVC : self.otrBVC;
   self.currentBVC = targetBVC;
 }
 
 - (void)finishDismissingStackView {
   DCHECK_EQ(self.mainViewController.activeViewController,
-            _tabSwitcherController.get());
+            _tabSwitcherController);
 
   if (_modeToDisplayOnStackViewDismissal == StackViewDismissalMode::NORMAL) {
     self.currentBVC = self.mainBVC;
   } else if (_modeToDisplayOnStackViewDismissal ==
              StackViewDismissalMode::INCOGNITO) {
     self.currentBVC = self.otrBVC;
   }
 
   _modeToDisplayOnStackViewDismissal = StackViewDismissalMode::NONE;
 
@@ skipping 52 matching lines @@
       removeBrowsingDataFromBrowserState:browserState
                                     mask:mask
                               timePeriod:timePeriod
                        completionHandler:browsingDataRemoved];
 }
 
 #pragma mark - Navigation Controllers
 
 - (void)presentSignedInAccountsViewControllerForBrowserState:
     (ios::ChromeBrowserState*)browserState {
-  base::scoped_nsobject<UIViewController> accountsViewController(
-      [[SignedInAccountsViewController alloc]
-          initWithBrowserState:browserState]);
+  UIViewController* accountsViewController = [
+      [SignedInAccountsViewController alloc] initWithBrowserState:browserState];
   [[self topPresentedViewController]
       presentViewController:accountsViewController
                    animated:YES
                  completion:nil];
 }
 
 - (void)showSettings {
   if (_settingsNavigationController)
     return;
   [[DeferredInitializationRunner sharedInstance]
       runBlockIfNecessary:kPrefObserverInit];
   DCHECK(_localStatePrefObserverBridge);
-  _settingsNavigationController.reset([SettingsNavigationController
+  _settingsNavigationController = [SettingsNavigationController
       newSettingsMainControllerWithMainBrowserState:_mainBrowserState
                                 currentBrowserState:self.currentBrowserState
-                                           delegate:self]);
+                                           delegate:self];
   [[self topPresentedViewController]
       presentViewController:_settingsNavigationController
                    animated:YES
                  completion:nil];
 }
 
 - (void)showAccountsSettings {
   if (_settingsNavigationController)
     return;
   if ([self currentBrowserState]->IsOffTheRecord()) {
     NOTREACHED();
     return;
   }
-  _settingsNavigationController.reset([SettingsNavigationController
+  _settingsNavigationController = [SettingsNavigationController
       newAccountsController:self.currentBrowserState
-                   delegate:self]);
+                   delegate:self];
   [[self topPresentedViewController]
       presentViewController:_settingsNavigationController
                    animated:YES
                  completion:nil];
 }
 
 - (void)showSyncSettings {
   if (_settingsNavigationController)
     return;
-  _settingsNavigationController.reset([SettingsNavigationController
-           newSyncController:_mainBrowserState
-      allowSwitchSyncAccount:YES
-                    delegate:self]);
+  _settingsNavigationController =
+      [SettingsNavigationController newSyncController:_mainBrowserState
+                               allowSwitchSyncAccount:YES
+                                             delegate:self];
   [[self topPresentedViewController]
       presentViewController:_settingsNavigationController
                    animated:YES
                  completion:nil];
 }
 
 - (void)showSavePasswordsSettings {
   if (_settingsNavigationController)
     return;
-  _settingsNavigationController.reset([SettingsNavigationController
-      newSavePasswordsController:_mainBrowserState
-                        delegate:self]);
+  _settingsNavigationController =
+      [SettingsNavigationController newSavePasswordsController:_mainBrowserState
+                                                      delegate:self];
   [[self topPresentedViewController]
       presentViewController:_settingsNavigationController
                    animated:YES
                  completion:nil];
 }
 
 - (void)showAutofillSettings {
   if (_settingsNavigationController)
     return;
-  _settingsNavigationController.reset([SettingsNavigationController
-      newAutofillController:_mainBrowserState
-                   delegate:self]);
+  _settingsNavigationController =
+      [SettingsNavigationController newAutofillController:_mainBrowserState
+                                                 delegate:self];
   [[self topPresentedViewController]
       presentViewController:_settingsNavigationController
                    animated:YES
                  completion:nil];
 }
 
 - (void)showReportAnIssue {
   if (_settingsNavigationController)
     return;
-  _settingsNavigationController.reset([SettingsNavigationController
-      newUserFeedbackController:_mainBrowserState
-                       delegate:self
-             feedbackDataSource:self]);
+  _settingsNavigationController =
+      [SettingsNavigationController newUserFeedbackController:_mainBrowserState
+                                                     delegate:self
+                                           feedbackDataSource:self];
   [[self topPresentedViewController]
       presentViewController:_settingsNavigationController
                    animated:YES
                  completion:nil];
 }
 
 - (void)showSyncEncryptionPassphrase {
   if (_settingsNavigationController)
     return;
-  _settingsNavigationController.reset([SettingsNavigationController
+  _settingsNavigationController = [SettingsNavigationController
       newSyncEncryptionPassphraseController:_mainBrowserState
-                                   delegate:self]);
+                                   delegate:self];
   [[self topPresentedViewController]
       presentViewController:_settingsNavigationController
                    animated:YES
                  completion:nil];
 }
 
 - (void)showClearBrowsingDataSettingsController {
   if (_settingsNavigationController)
     return;
-  _settingsNavigationController.reset([SettingsNavigationController
+  _settingsNavigationController = [SettingsNavigationController
       newClearBrowsingDataController:_mainBrowserState
-                            delegate:self]);
+                            delegate:self];
   [[self topPresentedViewController]
       presentViewController:_settingsNavigationController
                    animated:YES
                  completion:nil];
 }
 
 - (void)showContextualSearchSettingsController {
   if (_settingsNavigationController)
     return;
-  _settingsNavigationController.reset([SettingsNavigationController
+  _settingsNavigationController = [SettingsNavigationController
       newContextualSearchController:_mainBrowserState
-                           delegate:self]);
+                           delegate:self];
   [[self topPresentedViewController]
       presentViewController:_settingsNavigationController
                    animated:YES
                  completion:nil];
 }
 
 - (void)showSigninWithOperation:(AuthenticationOperation)operation
                        identity:(ChromeIdentity*)identity
                     accessPoint:(signin_metrics::AccessPoint)accessPoint
                     promoAction:(signin_metrics::PromoAction)promoAction
                        callback:(ShowSigninCommandCompletionCallback)callback {
   DCHECK_NE(AUTHENTICATION_OPERATION_DISMISS, operation);
 
   if (_signinInteractionController) {
     // Avoid showing the sign in screen if there is already a sign-in operation
     // in progress.
     return;
   }
 
   BOOL areSettingsPresented = _settingsNavigationController != NULL;
-  _signinInteractionController.reset([[SigninInteractionController alloc]
+  _signinInteractionController = [[SigninInteractionController alloc]
           initWithBrowserState:_mainBrowserState
       presentingViewController:[self topPresentedViewController]
          isPresentedOnSettings:areSettingsPresented
                    accessPoint:accessPoint
-                   promoAction:promoAction]);
+                   promoAction:promoAction];
 
   signin_ui::CompletionCallback completion = ^(BOOL success) {
-    _signinInteractionController.reset();
+    _signinInteractionController = nil;
     if (callback)
       callback(success);
   };
 
   switch (operation) {
     case AUTHENTICATION_OPERATION_DISMISS:
       // Special case handled above.
       NOTREACHED();
       break;
     case AUTHENTICATION_OPERATION_REAUTHENTICATE:
@@ skipping 11 matching lines @@
 }
 
 - (void)showAddAccount {
   if (_signinInteractionController) {
     // Avoid showing the sign in screen if there is already a sign-in operation
     // in progress.
     return;
   }
 
   BOOL areSettingsPresented = _settingsNavigationController != NULL;
-  _signinInteractionController.reset([[SigninInteractionController alloc]
+  _signinInteractionController = [[SigninInteractionController alloc]
           initWithBrowserState:_mainBrowserState
       presentingViewController:[self topPresentedViewController]
          isPresentedOnSettings:areSettingsPresented
                    accessPoint:signin_metrics::AccessPoint::ACCESS_POINT_UNKNOWN
                    promoAction:signin_metrics::PromoAction::
-                                   PROMO_ACTION_NO_SIGNIN_PROMO]);
+                                   PROMO_ACTION_NO_SIGNIN_PROMO];
 
   [_signinInteractionController
       addAccountWithCompletion:^(BOOL success) {
-        _signinInteractionController.reset();
+        _signinInteractionController = nil;
       }
                 viewController:self.mainViewController];
 }
 
 - (void)showHistory {
-  _historyPanelViewController.reset([[HistoryPanelViewController
+  _historyPanelViewController = [HistoryPanelViewController
       controllerToPresentForBrowserState:_mainBrowserState
-                                  loader:self.currentBVC] retain]);
+                                  loader:self.currentBVC];
   [self.currentBVC presentViewController:_historyPanelViewController
                                 animated:YES
                               completion:nil];
 }
 
 - (void)dismissSigninInteractionController {
   // The sign-in interaction controller is destroyed as a result of calling
   // |cancelAndDismiss|. Destroying it here may lead to a missing call of the
   // |ShowSigninCommandCompletionCallback| passed when starting a show sign-in
   // operation.
   [_signinInteractionController cancelAndDismiss];
 }
 
 - (ShowSigninCommandCompletionCallback)successfulSigninCompletion:
     (ProceduralBlock)callback {
-  return [[^(BOOL successful) {
+  return [^(BOOL successful) {
     ios::ChromeBrowserState* browserState = [self currentBrowserState];
     if (browserState->IsOffTheRecord()) {
       NOTREACHED()
           << "Ignore call to |handleSignInFinished| when in incognito.";
       return;
     }
     DCHECK_EQ(self.mainBVC, self.currentBVC);
     SigninManager* signinManager =
         ios::SigninManagerFactory::GetForBrowserState(browserState);
     if (signinManager->IsAuthenticated())
       callback();
-  } copy] autorelease];
+  } copy];
 }
 
 - (void)showNativeAppsSettings {
   if (_settingsNavigationController)
     return;
-  _settingsNavigationController.reset([SettingsNavigationController
-      newNativeAppsController:_mainBrowserState
-                     delegate:self]);
+  _settingsNavigationController =
+      [SettingsNavigationController newNativeAppsController:_mainBrowserState
+                                                   delegate:self];
   [[self topPresentedViewController]
       presentViewController:_settingsNavigationController
                    animated:YES
                  completion:nil];
 }
 
 - (void)closeSettingsAnimated:(BOOL)animated
                    completion:(ProceduralBlock)completion {
   DCHECK(_settingsNavigationController);
   [_settingsNavigationController settingsWillBeDismissed];
   UIViewController* presentingViewController =
       [_settingsNavigationController presentingViewController];
   DCHECK(presentingViewController);
   [presentingViewController dismissViewControllerAnimated:animated
                                                completion:^{
                                                  if (completion)
                                                    completion();
                                                }];
-  _settingsNavigationController.reset();
+  _settingsNavigationController = nil;
 }
 
 #pragma mark - TabModelObserver
 
 // Called when the number of tabs changes. Triggers the switcher view when
 // the last tab is closed on a device that uses the switcher.
 - (void)tabModelDidChangeTabCount:(TabModel*)notifiedTabModel {
   TabModel* currentTabModel = [self currentTabModel];
   // Do nothing on initialization.
   if (!currentTabModel)
@@ skipping 105 matching lines @@
         [self.currentBVC focusOmnibox];
       });
     }
   }
 
   if (_restoreHelper) {
     // Now that all the operations on the tabs have been done, display the
     // restore infobar if needed.
     dispatch_async(dispatch_get_main_queue(), ^{
       [_restoreHelper showRestoreIfNeeded:[self currentTabModel]];
-      _restoreHelper.reset();
+      _restoreHelper = nil;
     });
   }
 
   return tab;
 }
 
 - (void)dismissModalDialogsWithCompletion:(ProceduralBlock)completion {
   // Immediately hide modals from the provider (alert views, action sheets,
   // popovers). They will be ultimately dismissed by their owners, but at least,
   // they are not visible.
@@ skipping 201 matching lines @@
 
 #pragma mark - TestingOnly
 
 @implementation MainController (TestingOnly)
 
 - (DeviceSharingManager*)deviceSharingManager {
   return [_browserViewWrangler deviceSharingManager];
 }
 
 - (UIViewController<TabSwitcher>*)tabSwitcherController {
-  return _tabSwitcherController.get();
+  return _tabSwitcherController;
 }
 
 - (void)setTabSwitcherController:(UIViewController<TabSwitcher>*)controller {
-  _tabSwitcherController.reset([controller retain]);
+  _tabSwitcherController = controller;
 }
 
 - (SigninInteractionController*)signinInteractionController {
-  return _signinInteractionController.get();
+  return _signinInteractionController;
 }
 
 - (UIViewController*)topPresentedViewController {
   return top_view_controller::TopPresentedViewControllerFrom(
       self.mainViewController);
 }
 
 - (void)setTabSwitcherActive:(BOOL)active {
   _tabSwitcherIsActive = active;
 }
 
 - (BOOL)dismissingTabSwitcher {
   return _dismissingStackView;
 }
 
 - (void)setStartupParametersWithURL:(const GURL&)launchURL {
   NSString* sourceApplication = @"Fake App";
-  _startupParameters.reset([[ChromeAppStartupParameters
+  _startupParameters = [ChromeAppStartupParameters
       newChromeAppStartupParametersWithURL:net::NSURLWithGURL(launchURL)
-                     fromSourceApplication:sourceApplication] retain]);
+                     fromSourceApplication:sourceApplication];
 }
 
 - (void)setUpAsForegrounded {
   _isColdStart = NO;
   _browserInitializationStage = INITIALIZATION_STAGE_FOREGROUND;
   // Create a BrowserViewWrangler with a null browser state. This will trigger
   // assertions if the BrowserViewWrangler is asked to create any BVC or
   // tabModel objects, but it will accept assignments to them.
   [_browserViewWrangler shutdown];
-  _browserViewWrangler.reset([[BrowserViewWrangler alloc]
-      initWithBrowserState:nullptr
-          tabModelObserver:self]);
+  _browserViewWrangler =
+      [[BrowserViewWrangler alloc] initWithBrowserState:nullptr
+                                       tabModelObserver:self];
   // This is a test utility method that bypasses the ususal setup steps, so
   // verify that the main coordinator hasn't been created yet, then start it
   // via lazy initialization.
   DCHECK(!_mainCoordinator);
   [self.mainCoordinator start];
 }
 
 - (void)setUpForTestingWithCompletionHandler:
     (ProceduralBlock)completionHandler {
   self.currentBVC = self.mainBVC;
 
   int removeAllMask = ~0;
   scoped_refptr<CallbackCounter> callbackCounter =
-      new CallbackCounter(base::BindBlock(^{
+      new CallbackCounter(base::BindBlockArc(^{
         [self setUpCurrentBVCForTesting];
         if (completionHandler) {
           completionHandler();
         }
       }));
   id decrementCallbackCounterCount = ^{
     callbackCounter->DecrementCount();
   };
 
   callbackCounter->IncrementCount();
   [self removeBrowsingDataFromBrowserState:_mainBrowserState
                                       mask:removeAllMask
                                 timePeriod:browsing_data::TimePeriod::ALL_TIME
                          completionHandler:decrementCallbackCounterCount];
 }
 
 @end