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

ios/chrome/browser/ui/settings/accounts_collection_view_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/settings/accounts_collection_view_controller.h"
 
-#import "base/ios/weak_nsobject.h"
 #import "base/mac/foundation_util.h"
-#import "base/mac/scoped_nsobject.h"
 #include "base/metrics/user_metrics.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #import "components/signin/ios/browser/oauth2_token_service_observer_bridge.h"
 #include "components/strings/grit/components_strings.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
@@ skipping 27 matching lines @@
 #include "ios/chrome/grit/ios_chromium_strings.h"
 #include "ios/chrome/grit/ios_strings.h"
 #import "ios/public/provider/chrome/browser/chrome_browser_provider.h"
 #import "ios/public/provider/chrome/browser/images/branded_image_provider.h"
 #import "ios/public/provider/chrome/browser/signin/chrome_identity.h"
 #import "ios/public/provider/chrome/browser/signin/chrome_identity_browser_opener.h"
 #import "ios/public/provider/chrome/browser/signin/chrome_identity_service.h"
 #import "net/base/mac/url_conversions.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 NSString* const kSettingsAccountsId = @"kSettingsAccountsId";
 NSString* const kSettingsHeaderId = @"kSettingsHeaderId";
 NSString* const kSettingsAccountsSignoutCellId =
     @"kSettingsAccountsSignoutCellId";
 NSString* const kSettingsAccountsSyncCellId = @"kSettingsAccountsSyncCellId";
 
 namespace {
 
 typedef NS_ENUM(NSInteger, SectionIdentifier) {
   SectionIdentifierAccounts = kSectionIdentifierEnumZero,
@@ skipping 14 matching lines @@
 
 @interface AccountsCollectionViewController ()<
     ChromeIdentityServiceObserver,
     ChromeIdentityBrowserOpener,
     OAuth2TokenServiceObserverBridgeDelegate,
     SyncObserverModelBridge> {
   ios::ChromeBrowserState* _browserState;  // weak
   BOOL _closeSettingsOnAddAccount;
   std::unique_ptr<SyncObserverBridge> _syncObserver;
   std::unique_ptr<OAuth2TokenServiceObserverBridge> _tokenServiceObserver;
-  base::scoped_nsobject<SigninInteractionController>
-      _signinInteractionController;
+  SigninInteractionController* _signinInteractionController;
   // Modal alert for sign out.
-  base::scoped_nsobject<AlertCoordinator> _alertCoordinator;
+  AlertCoordinator* _alertCoordinator;
   // Whether an authentication operation is in progress (e.g switch accounts,
   // sign out).
   BOOL _authenticationOperationInProgress;
   // Whether the view controller is currently being dismissed and new dismiss
   // requests should be ignored.
   BOOL _isBeingDismissed;
-  base::WeakNSObject<UIViewController> _settingsDetails;
-  base::scoped_nsobject<ResizedAvatarCache> _avatarCache;
+  __weak UIViewController* _settingsDetails;
+  ResizedAvatarCache* _avatarCache;
   std::unique_ptr<ChromeIdentityServiceObserverBridge> _identityServiceObserver;
 
   // Enable lookup of item corresponding to a given identity GAIA ID string.
-  base::scoped_nsobject<NSDictionary<NSString*, CollectionViewItem*>>
-      _identityMap;
+  NSDictionary<NSString*, CollectionViewItem*>* _identityMap;
 }
 
 // Stops observing browser state services. This is required during the shutdown
 // phase to avoid observing services for a browser state that is being killed.
 - (void)stopBrowserStateServiceObservers;
 
 @end
 
 @implementation AccountsCollectionViewController
 
@@ skipping 14 matching lines @@
         addObserver:self
            selector:@selector(willStartSwitchAccount)
                name:kSwitchAccountWillStartNotification
              object:nil];
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(didFinishSwitchAccount)
                name:kSwitchAccountDidFinishNotification
              object:nil];
     self.collectionViewAccessibilityIdentifier = kSettingsAccountsId;
-    _avatarCache.reset([[ResizedAvatarCache alloc] init]);
+    _avatarCache = [[ResizedAvatarCache alloc] init];
     _identityServiceObserver.reset(
         new ChromeIdentityServiceObserverBridge(self));
     [self loadModel];
   }
 
   return self;
 }
 
 - (void)dealloc {
   [[NSNotificationCenter defaultCenter] removeObserver:self];
-  [super dealloc];
 }
 
 - (void)stopBrowserStateServiceObservers {
   _tokenServiceObserver.reset();
   _syncObserver.reset();
 }
 
 #pragma mark - SettingsControllerProtocol
 
 - (void)settingsWillBeDismissed {
@@ skipping 28 matching lines @@
   self.title = title;
 
   [super loadModel];
 
   if (![self authService]->IsAuthenticated())
     return;
 
   CollectionViewModel* model = self.collectionViewModel;
 
   NSMutableDictionary<NSString*, CollectionViewItem*>* mutableIdentityMap =
-      [[[NSMutableDictionary alloc] init] autorelease];
+      [[NSMutableDictionary alloc] init];
 
   // Account cells.
   ProfileOAuth2TokenService* oauth2_service =
       OAuth2TokenServiceFactory::GetForBrowserState(_browserState);
   AccountTrackerService* accountTracker =
       ios::AccountTrackerServiceFactory::GetForBrowserState(_browserState);
   [model addSectionWithIdentifier:SectionIdentifierAccounts];
   [model setHeader:[self header]
       forSectionWithIdentifier:SectionIdentifierAccounts];
   for (const std::string& account_id : oauth2_service->GetAccounts()) {
     AccountInfo account = accountTracker->GetAccountInfo(account_id);
     ChromeIdentity* identity = ios::GetChromeBrowserProvider()
                                    ->GetChromeIdentityService()
                                    ->GetIdentityWithGaiaID(account.gaia);
     CollectionViewItem* item = [self accountItem:identity];
     [model addItem:item toSectionWithIdentifier:SectionIdentifierAccounts];
 
     [mutableIdentityMap setObject:item forKey:identity.gaiaID];
   }
-  _identityMap.reset([mutableIdentityMap retain]);
+  _identityMap = mutableIdentityMap;
 
   [model addItem:[self addAccountItem]
       toSectionWithIdentifier:SectionIdentifierAccounts];
 
   // Sync and Google Activity section.
   [model addSectionWithIdentifier:SectionIdentifierSync];
   [model addItem:[self syncItem] toSectionWithIdentifier:SectionIdentifierSync];
   [model addItem:[self googleActivityControlsItem]
       toSectionWithIdentifier:SectionIdentifierSync];
 
   // Sign out section.
   [model addSectionWithIdentifier:SectionIdentifierSignOut];
   [model addItem:[self signOutItem]
       toSectionWithIdentifier:SectionIdentifierSignOut];
 }
 
 #pragma mark - Model objects
 
 - (CollectionViewItem*)header {
-  CollectionViewTextItem* header = [
-      [[CollectionViewTextItem alloc] initWithType:ItemTypeHeader] autorelease];
+  CollectionViewTextItem* header =
+      [[CollectionViewTextItem alloc] initWithType:ItemTypeHeader];
   header.text = l10n_util::GetNSString(IDS_IOS_OPTIONS_ACCOUNTS_DESCRIPTION);
   header.accessibilityIdentifier = kSettingsHeaderId;
   header.textColor = [[MDCPalette greyPalette] tint500];
   return header;
 }
 
 - (CollectionViewItem*)accountItem:(ChromeIdentity*)identity {
-  CollectionViewAccountItem* item = [[[CollectionViewAccountItem alloc]
-      initWithType:ItemTypeAccount] autorelease];
+  CollectionViewAccountItem* item =
+      [[CollectionViewAccountItem alloc] initWithType:ItemTypeAccount];
   [self updateAccountItem:item withIdentity:identity];
   return item;
 }
 
 - (void)updateAccountItem:(CollectionViewAccountItem*)item
              withIdentity:(ChromeIdentity*)identity {
   item.image = [_avatarCache resizedAvatarForIdentity:identity];
   item.text = identity.userEmail;
   item.chromeIdentity = identity;
   item.accessoryType = MDCCollectionViewCellAccessoryDisclosureIndicator;
 }
 
 - (CollectionViewItem*)addAccountItem {
-  CollectionViewAccountItem* item = [[[CollectionViewAccountItem alloc]
-      initWithType:ItemTypeAddAccount] autorelease];
+  CollectionViewAccountItem* item =
+      [[CollectionViewAccountItem alloc] initWithType:ItemTypeAddAccount];
   item.text =
       l10n_util::GetNSString(IDS_IOS_OPTIONS_ACCOUNTS_ADD_ACCOUNT_BUTTON);
   item.image = [UIImage imageNamed:@"settings_accounts_add_account"];
   return item;
 }
 
 - (CollectionViewItem*)syncItem {
   AccountControlItem* item =
-      [[[AccountControlItem alloc] initWithType:ItemTypeSync] autorelease];
+      [[AccountControlItem alloc] initWithType:ItemTypeSync];
   item.text = l10n_util::GetNSString(IDS_IOS_OPTIONS_ACCOUNTS_SYNC_TITLE);
   item.accessibilityIdentifier = kSettingsAccountsSyncCellId;
   [self updateSyncItem:item];
   item.accessoryType = MDCCollectionViewCellAccessoryDisclosureIndicator;
   return item;
 }
 
 - (void)updateSyncItem:(AccountControlItem*)syncItem {
   SyncSetupService* syncSetupService =
       SyncSetupServiceFactory::GetForBrowserState(_browserState);
@@ skipping 21 matching lines @@
         syncSetupService->IsSyncEnabled()
             ? l10n_util::GetNSStringF(
                   IDS_IOS_SIGN_IN_TO_CHROME_SETTING_SYNCING,
                   base::SysNSStringToUTF16([identity userEmail]))
             : l10n_util::GetNSString(IDS_IOS_OPTIONS_ACCOUNTS_SYNC_IS_OFF);
     syncItem.shouldDisplayError = NO;
   }
 }
 
 - (CollectionViewItem*)googleActivityControlsItem {
-  AccountControlItem* item = [[[AccountControlItem alloc]
-      initWithType:ItemTypeGoogleActivityControls] autorelease];
+  AccountControlItem* item =
+      [[AccountControlItem alloc] initWithType:ItemTypeGoogleActivityControls];
   item.text = l10n_util::GetNSString(IDS_IOS_OPTIONS_ACCOUNTS_GOOGLE_TITLE);
   item.detailText =
       l10n_util::GetNSString(IDS_IOS_OPTIONS_ACCOUNTS_GOOGLE_DESCRIPTION);
   item.image = ios::GetChromeBrowserProvider()
                    ->GetBrandedImageProvider()
                    ->GetAccountsListActivityControlsImage();
   item.accessoryType = MDCCollectionViewCellAccessoryDisclosureIndicator;
   return item;
 }
 
 - (CollectionViewItem*)signOutItem {
-  CollectionViewTextItem* item = [[[CollectionViewTextItem alloc]
-      initWithType:ItemTypeSignOut] autorelease];
+  CollectionViewTextItem* item =
+      [[CollectionViewTextItem alloc] initWithType:ItemTypeSignOut];
   item.text = l10n_util::GetNSString(IDS_IOS_OPTIONS_ACCOUNTS_SIGNOUT);
   item.accessibilityTraits |= UIAccessibilityTraitButton;
   item.accessibilityIdentifier = kSettingsAccountsSignoutCellId;
   return item;
 }
 
 #pragma mark - UICollectionViewDelegate
 
 - (void)collectionView:(UICollectionView*)collectionView
     didSelectItemAtIndexPath:(NSIndexPath*)indexPath {
@@ skipping 67 matching lines @@
   }
 }
 
 #pragma mark - OAuth2TokenServiceObserverBridgeDelegate
 
 - (void)onEndBatchChanges {
   [self reloadData];
   [self popViewIfSignedOut];
   if (![self authService]->IsAuthenticated() && _settingsDetails) {
     [_settingsDetails dismissViewControllerAnimated:YES completion:nil];
-    _settingsDetails.reset();
+    _settingsDetails = nil;
   }
 }
 
 #pragma mark - Sync and Activity Controls
 
 - (void)showSyncSettings {
   if ([_alertCoordinator isVisible])
     return;
 
   if ([self authService]->ShowMDMErrorDialogForIdentity(
           [self authService]->GetAuthenticatedIdentity())) {
     // If there is an MDM error for the synced identity, show it instead.
     return;
   }
 
-  base::scoped_nsobject<UIViewController> controllerToPush(
+  UIViewController* controllerToPush =
       [[SyncSettingsCollectionViewController alloc]
             initWithBrowserState:_browserState
-          allowSwitchSyncAccount:YES]);
+          allowSwitchSyncAccount:YES];
   [self.navigationController pushViewController:controllerToPush animated:YES];
 }
 
 - (void)showGoogleActivitySettings {
   if ([_alertCoordinator isVisible])
     return;
   base::RecordAction(base::UserMetricsAction(
       "Signin_AccountSettings_GoogleActivityControlsClicked"));
-  base::scoped_nsobject<UINavigationController> settingsDetails(
+  UINavigationController* settingsDetails =
       ios::GetChromeBrowserProvider()
           ->GetChromeIdentityService()
           ->NewWebAndAppSettingDetails(
-              [self authService]->GetAuthenticatedIdentity(), self));
+              [self authService]->GetAuthenticatedIdentity(), self);
   UIImage* closeIcon = [ChromeIcon closeIcon];
   SEL action = @selector(closeGoogleActivitySettings:);
-  [settingsDetails.get().topViewController navigationItem].leftBarButtonItem =
+  [settingsDetails.topViewController navigationItem].leftBarButtonItem =
       [ChromeIcon templateBarButtonItemWithImage:closeIcon
                                           target:self
                                           action:action];
   [self presentViewController:settingsDetails animated:YES completion:nil];
 
   // Keep a weak reference on the settings details, to be able to dismiss it
   // when the primary account is removed.
-  _settingsDetails.reset(settingsDetails);
+  _settingsDetails = settingsDetails;
 }
 
 - (void)closeGoogleActivitySettings:(id)sender {
   DCHECK(_settingsDetails);
   [self dismissViewControllerAnimated:YES completion:nil];
 }
 
 #pragma mark - Authentication operations
 
 - (void)showAddAccount {
   if ([_alertCoordinator isVisible])
     return;
   if (_signinInteractionController) {
     // Ignore this user action if there is already an add account operation
     // in-progress.
     return;
   }
-  _signinInteractionController.reset([[SigninInteractionController alloc]
+  _signinInteractionController = [[SigninInteractionController alloc]
           initWithBrowserState:_browserState
       presentingViewController:self.navigationController
          isPresentedOnSettings:YES
              signInAccessPoint:signin_metrics::AccessPoint::
-                                   ACCESS_POINT_SETTINGS]);
+                                   ACCESS_POINT_SETTINGS];
 
   // |_authenticationOperationInProgress| is reset when the signin interaction
   // controller is dismissed.
   _authenticationOperationInProgress = YES;
-  base::WeakNSObject<AccountsCollectionViewController> weakSelf(self);
+  __weak AccountsCollectionViewController* weakSelf = self;
   [_signinInteractionController addAccountWithCompletion:^(BOOL success) {
     [weakSelf handleDidAddAccount:success];
   }
                                           viewController:self];
 }
 
 - (void)handleDidAddAccount:(BOOL)success {
-  _signinInteractionController.reset();
+  _signinInteractionController = nil;
   [self handleAuthenticationOperationDidFinish];
   if (success && _closeSettingsOnAddAccount) {
-    base::scoped_nsobject<GenericChromeCommand> closeSettingsCommand(
-        [[GenericChromeCommand alloc] initWithTag:IDC_CLOSE_SETTINGS]);
+    GenericChromeCommand* closeSettingsCommand =
+        [[GenericChromeCommand alloc] initWithTag:IDC_CLOSE_SETTINGS];
     [self chromeExecuteCommand:closeSettingsCommand];
   }
 }
 
 - (void)showAccountDetails:(ChromeIdentity*)identity {
   if ([_alertCoordinator isVisible])
     return;
-  base::scoped_nsobject<UIViewController> accountDetails(
-      ios::GetChromeBrowserProvider()
-          ->GetChromeIdentityService()
-          ->NewAccountDetails(identity, self));
+  UIViewController* accountDetails = ios::GetChromeBrowserProvider()
+                                         ->GetChromeIdentityService()
+                                         ->NewAccountDetails(identity, self);
   if (!accountDetails) {
     // Failed to create a new account details. Ignored.
     return;
   }
   [self presentViewController:accountDetails animated:YES completion:nil];
 
   // Keep a weak reference on the account details, to be able to dismiss it
   // when the primary account is removed.
-  _settingsDetails.reset(accountDetails);
+  _settingsDetails = accountDetails;
 }
 
 - (void)showDisconnect {
   if (_authenticationOperationInProgress || [_alertCoordinator isVisible] ||
       self != [self.navigationController topViewController]) {
     // An action is already in progress, ignore user's request.
     return;
   }
 
   NSString* title;
   NSString* message;
   NSString* continueButtonTitle;
   if ([self authService]->IsAuthenticatedIdentityManaged()) {
     std::string hosted_domain =
         ios::SigninManagerFactory::GetForBrowserState(_browserState)
             ->GetAuthenticatedAccountInfo()
             .hosted_domain;
     title = l10n_util::GetNSString(IDS_IOS_MANAGED_DISCONNECT_DIALOG_TITLE);
     message = l10n_util::GetNSStringF(IDS_IOS_MANAGED_DISCONNECT_DIALOG_INFO,
                                       base::UTF8ToUTF16(hosted_domain));
     continueButtonTitle =
         l10n_util::GetNSString(IDS_IOS_MANAGED_DISCONNECT_DIALOG_ACCEPT);
   } else {
     title = l10n_util::GetNSString(IDS_IOS_DISCONNECT_DIALOG_TITLE);
     message = l10n_util::GetNSString(IDS_IOS_DISCONNECT_DIALOG_INFO_MOBILE);
     continueButtonTitle = l10n_util::GetNSString(
         IDS_IOS_DISCONNECT_DIALOG_CONTINUE_BUTTON_MOBILE);
   }
-  _alertCoordinator.reset([[AlertCoordinator alloc]
-      initWithBaseViewController:self
-                           title:title
-                         message:message]);
+  _alertCoordinator =
+      [[AlertCoordinator alloc] initWithBaseViewController:self
+                                                     title:title
+                                                   message:message];
 
   [_alertCoordinator addItemWithTitle:l10n_util::GetNSString(IDS_CANCEL)
                                action:nil
                                 style:UIAlertActionStyleCancel];
-  base::WeakNSObject<AccountsCollectionViewController> weakSelf(self);
+  __weak AccountsCollectionViewController* weakSelf = self;
   [_alertCoordinator addItemWithTitle:continueButtonTitle
                                action:^{
                                  [weakSelf handleDisconnect];
                                }
                                 style:UIAlertActionStyleDefault];
   [_alertCoordinator start];
 }
 
 - (void)handleDisconnect {
   AuthenticationService* authService = [self authService];
@@ skipping 57 matching lines @@
 
 - (void)didFinishSwitchAccount {
   [self handleAuthenticationOperationDidFinish];
 }
 
 #pragma mark - ChromeIdentityBrowserOpener
 
 - (void)openURL:(NSURL*)url
               view:(UIView*)view
     viewController:(UIViewController*)viewController {
-  base::scoped_nsobject<OpenUrlCommand> command(
-      [[OpenUrlCommand alloc] initWithURLFromChrome:net::GURLWithNSURL(url)]);
+  OpenUrlCommand* command =
+      [[OpenUrlCommand alloc] initWithURLFromChrome:net::GURLWithNSURL(url)];
   [command setTag:IDC_CLOSE_SETTINGS_AND_OPEN_URL];
   [self chromeExecuteCommand:command];
 }
 
 #pragma mark - ChromeIdentityServiceObserver
 
 - (void)onProfileUpdate:(ChromeIdentity*)identity {
   CollectionViewAccountItem* item =
       base::mac::ObjCCastStrict<CollectionViewAccountItem>(
           [_identityMap objectForKey:identity.gaiaID]);
   [self updateAccountItem:item withIdentity:identity];
   NSIndexPath* indexPath =
       [self.collectionViewModel indexPathForItem:item
                          inSectionWithIdentifier:SectionIdentifierAccounts];
   [self.collectionView reloadItemsAtIndexPaths:@[ indexPath ]];
 }
 
 - (void)onChromeIdentityServiceWillBeDestroyed {
   _identityServiceObserver.reset();
 }
 
 @end