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

ios/chrome/browser/ui/settings/sync_settings_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/sync_settings_collection_view_controller.h"
 
 #include <memory>
 
 #include "base/auto_reset.h"
 #include "base/mac/foundation_util.h"
-#import "base/mac/scoped_nsobject.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/google/core/browser/google_util.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #import "components/signin/ios/browser/oauth2_token_service_observer_bridge.h"
 #include "components/strings/grit/components_strings.h"
 #include "components/sync/base/model_type.h"
 #include "ios/chrome/browser/application_context.h"
 #include "ios/chrome/browser/chrome_url_constants.h"
 #include "ios/chrome/browser/experimental_flags.h"
@@ skipping 23 matching lines @@
 #import "ios/chrome/browser/ui/settings/sync_encryption_passphrase_collection_view_controller.h"
 #import "ios/chrome/browser/ui/sync/sync_util.h"
 #import "ios/chrome/browser/ui/uikit_ui_util.h"
 #include "ios/chrome/grit/ios_strings.h"
 #import "ios/public/provider/chrome/browser/chrome_browser_provider.h"
 #import "ios/public/provider/chrome/browser/signin/chrome_identity.h"
 #import "ios/public/provider/chrome/browser/signin/chrome_identity_service.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 #include "url/gurl.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 // The a11y identifier of the view controller's view.
 NSString* const kSettingsSyncId = @"kSettingsSyncId";
 // Notification when a switch account operation will start.
 NSString* const kSwitchAccountWillStartNotification =
     @"kSwitchAccountWillStartNotification";
 // Notification when a switch account operation did finish.
 NSString* const kSwitchAccountDidFinishNotification =
     @"kSwitchAccountDidFinishNotification";
 // Used to tag and retrieve ItemTypeSyncableDataType cell tags.
 const NSInteger kTagShift = 1000;
@@ skipping 23 matching lines @@
 
 @interface SyncSettingsCollectionViewController ()<
     ChromeIdentityServiceObserver,
     OAuth2TokenServiceObserverBridgeDelegate,
     SettingsControllerProtocol,
     SyncObserverModelBridge> {
   ios::ChromeBrowserState* _browserState;  // Weak.
   SyncSetupService* _syncSetupService;     // Weak.
   std::unique_ptr<SyncObserverBridge> _syncObserver;
   std::unique_ptr<OAuth2TokenServiceObserverBridge> _tokenServiceObserver;
-  base::scoped_nsobject<AuthenticationFlow> _authenticationFlow;
+  AuthenticationFlow* _authenticationFlow;
   // Whether switching sync account is allowed on the screen.
   BOOL _allowSwitchSyncAccount;
   // Whether an authentication operation is in progress (e.g switch accounts).
   BOOL _authenticationOperationInProgress;
   // Whether Sync State changes should be currently ignored.
   BOOL _ignoreSyncStateChanges;
 
   // Cache for Identity items avatar images.
-  base::scoped_nsobject<ResizedAvatarCache> _avatarCache;
+  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.
 - (void)stopBrowserStateServiceObservers;
 // Pops the view if user is signed out and not authentication operation is in
 // progress. Returns YES if the view was popped.
 - (BOOL)popViewIfSignedOut;
 
 // Returns a switch item for sync, set to on if |isOn| is YES.
 - (CollectionViewItem*)syncSwitchItem:(BOOL)isOn;
@@ skipping 76 matching lines @@
     _browserState = browserState;
     _syncSetupService =
         SyncSetupServiceFactory::GetForBrowserState(_browserState);
     self.title = l10n_util::GetNSString(IDS_IOS_SYNC_SETTING_TITLE);
     browser_sync::ProfileSyncService* syncService =
         IOSChromeProfileSyncServiceFactory::GetForBrowserState(_browserState);
     _syncObserver.reset(new SyncObserverBridge(self, syncService));
     _tokenServiceObserver.reset(new OAuth2TokenServiceObserverBridge(
         OAuth2TokenServiceFactory::GetForBrowserState(_browserState), self));
     self.collectionViewAccessibilityIdentifier = kSettingsSyncId;
-    _avatarCache.reset([[ResizedAvatarCache alloc] init]);
+    _avatarCache = [[ResizedAvatarCache alloc] init];
     _identityServiceObserver.reset(
         new ChromeIdentityServiceObserverBridge(self));
     [self loadModel];
   }
   return self;
 }
 
 - (void)stopBrowserStateServiceObservers {
   _syncObserver.reset();
   _tokenServiceObserver.reset();
@@ skipping 38 matching lines @@
 
   // Sync Section.
   BOOL syncEnabled = _syncSetupService->IsSyncEnabled();
   [model addSectionWithIdentifier:SectionIdentifierEnableSync];
   [model addItem:[self syncSwitchItem:syncEnabled]
       toSectionWithIdentifier:SectionIdentifierEnableSync];
 
   // Sync to Section.
   if ([self hasAccountsSection]) {
     NSMutableDictionary<NSString*, CollectionViewItem*>* mutableIdentityMap =
-        [[[NSMutableDictionary alloc] init] autorelease];
+        [[NSMutableDictionary alloc] init];
     // Accounts section. Cells enabled if sync is on.
     [model addSectionWithIdentifier:SectionIdentifierSyncAccounts];
-    CollectionViewTextItem* syncToHeader = [[[CollectionViewTextItem alloc]
-        initWithType:ItemTypeHeader] autorelease];
+    CollectionViewTextItem* syncToHeader =
+        [[CollectionViewTextItem alloc] initWithType:ItemTypeHeader];
     syncToHeader.text = l10n_util::GetNSString(IDS_IOS_SYNC_TO_TITLE);
     syncToHeader.textColor = [[MDCPalette greyPalette] tint500];
     [model setHeader:syncToHeader
         forSectionWithIdentifier:SectionIdentifierSyncAccounts];
     ProfileOAuth2TokenService* oauth2_service =
         OAuth2TokenServiceFactory::GetForBrowserState(_browserState);
     AccountTrackerService* accountTracker =
         ios::AccountTrackerServiceFactory::GetForBrowserState(_browserState);
 
     for (const std::string& account_id : oauth2_service->GetAccounts()) {
       AccountInfo account = accountTracker->GetAccountInfo(account_id);
       ChromeIdentity* identity = ios::GetChromeBrowserProvider()
                                      ->GetChromeIdentityService()
                                      ->GetIdentityWithGaiaID(account.gaia);
       CollectionViewItem* accountItem = [self accountItem:identity];
       [model addItem:accountItem
           toSectionWithIdentifier:SectionIdentifierSyncAccounts];
       [mutableIdentityMap setObject:accountItem forKey:identity.gaiaID];
     }
-    _identityMap.reset([mutableIdentityMap retain]);
+    _identityMap = mutableIdentityMap;
   }
 
   // Data Types to sync. Enabled if sync is on.
   [model addSectionWithIdentifier:SectionIdentifierSyncServices];
-  CollectionViewTextItem* syncServicesHeader = [
-      [[CollectionViewTextItem alloc] initWithType:ItemTypeHeader] autorelease];
+  CollectionViewTextItem* syncServicesHeader =
+      [[CollectionViewTextItem alloc] initWithType:ItemTypeHeader];
   syncServicesHeader.text =
       l10n_util::GetNSString(IDS_IOS_SYNC_DATA_TYPES_TITLE);
   syncServicesHeader.textColor = [[MDCPalette greyPalette] tint500];
   [model setHeader:syncServicesHeader
       forSectionWithIdentifier:SectionIdentifierSyncServices];
   BOOL syncEverythingEnabled = _syncSetupService->IsSyncingAllDataTypes();
   [model addItem:[self syncEverythingSwitchItem:syncEverythingEnabled]
       toSectionWithIdentifier:SectionIdentifierSyncServices];
   // Specific Data Types to sync. Enabled if Sync Everything is off.
   for (int i = 0; i < SyncSetupService::kNumberOfSyncableDatatypes; ++i) {
@@ skipping 18 matching lines @@
       switchItemWithType:ItemTypeSyncSwitch
                    title:l10n_util::GetNSString(IDS_IOS_SYNC_SETTING_TITLE)
                 subTitle:l10n_util::GetNSString(
                              IDS_IOS_SIGN_IN_TO_CHROME_SETTING_SUBTITLE)];
   syncSwitchItem.on = isOn;
   return syncSwitchItem;
 }
 
 - (CollectionViewItem*)syncErrorItem {
   DCHECK([self shouldDisplaySyncError]);
-  CollectionViewAccountItem* syncErrorItem = [[[CollectionViewAccountItem alloc]
-      initWithType:ItemTypeSyncError] autorelease];
+  CollectionViewAccountItem* syncErrorItem =
+      [[CollectionViewAccountItem alloc] initWithType:ItemTypeSyncError];
   syncErrorItem.text = l10n_util::GetNSString(IDS_IOS_SYNC_ERROR_TITLE);
   syncErrorItem.image = [UIImage imageNamed:@"settings_error"];
   syncErrorItem.detailText =
       ios_internal::sync::GetSyncErrorMessageForBrowserState(_browserState);
   return syncErrorItem;
 }
 
 - (CollectionViewItem*)accountItem:(ChromeIdentity*)identity {
   CollectionViewAccountItem* identityAccountItem =
-      [[[CollectionViewAccountItem alloc] initWithType:ItemTypeAccount]
-          autorelease];
+      [[CollectionViewAccountItem alloc] initWithType:ItemTypeAccount];
   [self updateAccountItem:identityAccountItem withIdentity:identity];
 
   identityAccountItem.enabled = _syncSetupService->IsSyncEnabled();
   ChromeIdentity* authenticatedIdentity =
       AuthenticationServiceFactory::GetForBrowserState(_browserState)
           ->GetAuthenticatedIdentity();
   if (identity == authenticatedIdentity) {
     identityAccountItem.accessoryType = MDCCollectionViewCellAccessoryCheckmark;
   }
   return identityAccountItem;
@@ skipping 20 matching lines @@
                                    [self titleIdForSyncableDataType:dataType])
                       subTitle:nil];
   syncDataTypeItem.dataType = dataType;
   syncDataTypeItem.on = isOn;
   syncDataTypeItem.enabled = [self shouldSyncableItemsBeEnabled];
   return syncDataTypeItem;
 }
 
 - (CollectionViewItem*)encryptionCellItem {
   TextAndErrorItem* encryptionCellItem =
-      [[[TextAndErrorItem alloc] initWithType:ItemTypeEncryption] autorelease];
+      [[TextAndErrorItem alloc] initWithType:ItemTypeEncryption];
   encryptionCellItem.text =
       l10n_util::GetNSString(IDS_IOS_SYNC_ENCRYPTION_TITLE);
   encryptionCellItem.accessoryType =
       MDCCollectionViewCellAccessoryDisclosureIndicator;
   encryptionCellItem.shouldDisplayError = [self shouldDisplayEncryptionError];
   encryptionCellItem.enabled = [self shouldEncryptionItemBeEnabled];
   return encryptionCellItem;
 }
 
 - (CollectionViewItem*)manageSyncedDataItem {
   CollectionViewTextItem* manageSyncedDataItem =
-      [[[CollectionViewTextItem alloc] initWithType:ItemTypeManageSyncedData]
-          autorelease];
+      [[CollectionViewTextItem alloc] initWithType:ItemTypeManageSyncedData];
   manageSyncedDataItem.text =
       l10n_util::GetNSString(IDS_IOS_SYNC_RESET_GOOGLE_DASHBOARD_NO_LINK);
   manageSyncedDataItem.accessibilityTraits |= UIAccessibilityTraitButton;
   return manageSyncedDataItem;
 }
 
 #pragma mark Item Constructors
 
 - (SyncSwitchItem*)switchItemWithType:(NSInteger)type
                                 title:(NSString*)title
                              subTitle:(NSString*)detailText {
-  SyncSwitchItem* switchItem =
-      [[[SyncSwitchItem alloc] initWithType:type] autorelease];
+  SyncSwitchItem* switchItem = [[SyncSwitchItem alloc] initWithType:type];
   switchItem.text = title;
   switchItem.detailText = detailText;
   return switchItem;
 }
 
 #pragma mark - UICollectionViewDataSource
 
 - (UICollectionViewCell*)collectionView:(UICollectionView*)collectionView
                  cellForItemAtIndexPath:(NSIndexPath*)indexPath {
   UICollectionViewCell* cell =
@@ skipping 63 matching lines @@
       }
       break;
     }
     case ItemTypeEncryption:
       [self showEncryption];
       break;
     case ItemTypeManageSyncedData: {
       GURL learnMoreUrl = google_util::AppendGoogleLocaleParam(
           GURL(kSyncGoogleDashboardURL),
           GetApplicationContext()->GetApplicationLocale());
-      base::scoped_nsobject<OpenUrlCommand> command(
-          [[OpenUrlCommand alloc] initWithURLFromChrome:learnMoreUrl]);
+      OpenUrlCommand* command =
+          [[OpenUrlCommand alloc] initWithURLFromChrome:learnMoreUrl];
       [command setTag:IDC_CLOSE_SETTINGS_AND_OPEN_URL];
       [self chromeExecuteCommand:command];
       break;
     }
     default:
       break;
   }
 }
 
 #pragma mark MDCCollectionViewStylingDelegate
@@ skipping 73 matching lines @@
   if (_syncSetupService->GetSyncServiceState() ==
       SyncSetupService::kSyncServiceUnrecoverableError) {
     ChromeIdentity* authenticatedIdentity =
         AuthenticationServiceFactory::GetForBrowserState(_browserState)
             ->GetAuthenticatedIdentity();
     [self startSwitchAccountForIdentity:authenticatedIdentity
                        postSignInAction:POST_SIGNIN_ACTION_START_SYNC];
     return;
   }
 
-  base::scoped_nsobject<GenericChromeCommand> command(
-      [ios_internal::sync::GetSyncCommandForBrowserState(_browserState)
-          retain]);
+  GenericChromeCommand* command =
+      ios_internal::sync::GetSyncCommandForBrowserState(_browserState);
   [self chromeExecuteCommand:command];
 }
 
 - (void)startSwitchAccountForIdentity:(ChromeIdentity*)identity
                      postSignInAction:(PostSignInAction)postSignInAction {
   if (!_syncSetupService->IsSyncEnabled())
     return;
 
   _authenticationOperationInProgress = YES;
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kSwitchAccountWillStartNotification
                     object:self];
   [self preventUserInteraction];
   DCHECK(!_authenticationFlow);
-  _authenticationFlow.reset([[AuthenticationFlow alloc]
+  _authenticationFlow = [[AuthenticationFlow alloc]
           initWithBrowserState:_browserState
                       identity:identity
                shouldClearData:SHOULD_CLEAR_DATA_USER_CHOICE
               postSignInAction:postSignInAction
-      presentingViewController:self]);
+      presentingViewController:self];
 
-  base::WeakNSObject<SyncSettingsCollectionViewController> weakSelf(self);
+  __weak SyncSettingsCollectionViewController* weakSelf = self;
   [_authenticationFlow startSignInWithCompletion:^(BOOL success) {
     [weakSelf didSwitchAccountWithSuccess:success];
   }];
 }
 
 - (void)didSwitchAccountWithSuccess:(BOOL)success {
-  _authenticationFlow.reset();
+  _authenticationFlow = nil;
   [self allowUserInteraction];
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kSwitchAccountDidFinishNotification
                     object:self];
   _authenticationOperationInProgress = NO;
   if (![self popViewIfSignedOut]) {
     // Only reload the view if it wasn't popped.
     [self reloadData];
   }
 }
@@ skipping 48 matching lines @@
 }
 
 - (void)showEncryption {
   browser_sync::ProfileSyncService* syncService =
       IOSChromeProfileSyncServiceFactory::GetForBrowserState(_browserState);
   if (!syncService->IsEngineInitialized() ||
       !_syncSetupService->IsSyncEnabled() ||
       [self shouldDisableSettingsOnSyncError])
     return;
 
-  base::scoped_nsobject<UIViewController> controllerToPush;
+  UIViewController* controllerToPush;
   // If there was a sync error, prompt the user to enter the passphrase.
   // Otherwise, show the full encryption options.
   if (syncService->IsPassphraseRequired()) {
-    controllerToPush.reset(
-        [[SyncEncryptionPassphraseCollectionViewController alloc]
-            initWithBrowserState:_browserState]);
+    controllerToPush = [[SyncEncryptionPassphraseCollectionViewController alloc]
+        initWithBrowserState:_browserState];
   } else {
-    controllerToPush.reset([[SyncEncryptionCollectionViewController alloc]
-        initWithBrowserState:_browserState]);
+    controllerToPush = [[SyncEncryptionCollectionViewController alloc]
+        initWithBrowserState:_browserState];
   }
   [self.navigationController pushViewController:controllerToPush animated:YES];
 }
 
 #pragma mark Updates
 
 - (void)updateCollectionView {
-  base::WeakNSObject<SyncSettingsCollectionViewController> weakSelf(self);
+  __weak SyncSettingsCollectionViewController* weakSelf = self;
   [self.collectionView performBatchUpdates:^{
     [weakSelf updateCollectionViewInternal];
   }
                                 completion:nil];
 }
 
 - (void)updateCollectionViewInternal {
   NSIndexPath* indexPath = [self.collectionViewModel
       indexPathForItemType:ItemTypeSyncSwitch
          sectionIdentifier:SectionIdentifierEnableSync];
 
   SyncSwitchItem* syncItem = base::mac::ObjCCastStrict<SyncSwitchItem>(
       [self.collectionViewModel itemAtIndexPath:indexPath]);
   syncItem.on = _syncSetupService->IsSyncEnabled();
   [self reconfigureCellsForItems:@[ syncItem ]];
 
   // Update Sync Accounts section.
   if ([self hasAccountsSection]) {
     NSInteger section = [self.collectionViewModel
         sectionForSectionIdentifier:SectionIdentifierSyncAccounts];
     NSInteger itemsCount =
         [self.collectionViewModel numberOfItemsInSection:section];
-    NSMutableArray* accountsToReconfigure =
-        [[[NSMutableArray alloc] init] autorelease];
+    NSMutableArray* accountsToReconfigure = [[NSMutableArray alloc] init];
     for (NSInteger item = 0; item < itemsCount; ++item) {
       NSIndexPath* indexPath = [self.collectionViewModel
           indexPathForItemType:ItemTypeAccount
              sectionIdentifier:SectionIdentifierSyncAccounts
                        atIndex:item];
       CollectionViewAccountItem* accountItem =
           base::mac::ObjCCastStrict<CollectionViewAccountItem>(
               [self.collectionViewModel itemAtIndexPath:indexPath]);
       accountItem.enabled = _syncSetupService->IsSyncEnabled();
       [accountsToReconfigure addObject:accountItem];
@@ skipping 10 matching lines @@
           [self.collectionViewModel itemAtIndexPath:indexPath]);
   syncEverythingItem.on = _syncSetupService->IsSyncingAllDataTypes();
   syncEverythingItem.enabled = [self shouldSyncEverythingItemBeEnabled];
   [self reconfigureCellsForItems:@[ syncEverythingItem ]];
 
   NSInteger section = [self.collectionViewModel
       sectionForSectionIdentifier:SectionIdentifierSyncServices];
   NSInteger itemsCount =
       [self.collectionViewModel numberOfItemsInSection:section];
   // Syncable data types cells are offset by the Sync Everything cell.
-  NSMutableArray* switchsToReconfigure =
-      [[[NSMutableArray alloc] init] autorelease];
+  NSMutableArray* switchsToReconfigure = [[NSMutableArray alloc] init];
   for (NSInteger item = 1; item < itemsCount; ++item) {
     NSUInteger index = item - 1;
     NSIndexPath* indexPath = [self.collectionViewModel
         indexPathForItemType:ItemTypeSyncableDataType
            sectionIdentifier:SectionIdentifierSyncServices
                      atIndex:index];
     SyncSwitchItem* syncSwitchItem = base::mac::ObjCCastStrict<SyncSwitchItem>(
         [self.collectionViewModel itemAtIndexPath:indexPath]);
     SyncSetupService::SyncableDatatype dataType =
         (SyncSetupService::SyncableDatatype)syncSwitchItem.dataType;
@@ skipping 187 matching lines @@
   }
   [self updateAccountItem:item withIdentity:identity];
   [self reconfigureCellsForItems:@[ item ]];
 }
 
 - (void)onChromeIdentityServiceWillBeDestroyed {
   _identityServiceObserver.reset();
 }
 
 @end