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

ios/chrome/browser/ui/settings/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/settings_collection_view_controller.h"
 
 #include <memory>
 
-#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/scoped_observer.h"
 #include "base/strings/sys_string_conversions.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/keyed_service/core/service_access_type.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/prefs/pref_service.h"
@@ skipping 46 matching lines @@
 #import "ios/chrome/browser/ui/settings/voicesearch_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/browser/voice/speech_input_locale_config.h"
 #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/signin/chrome_identity.h"
 #import "ios/public/provider/chrome/browser/signin/signin_resources_provider.h"
 #include "ios/public/provider/chrome/browser/voice/voice_search_prefs.h"
+#import "ios/third_party/material_components_ios/src/components/Buttons/src/MaterialButtons.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 kSettingsCollectionViewId = @"kSettingsCollectionViewId";
 NSString* const kSettingsSignInCellId = @"kSettingsSignInCellId";
 NSString* const kSettingsAccountCellId = @"kSettingsAccountCellId";
 NSString* const kSettingsSearchEngineCellId = @"Search Engine";
 NSString* const kSettingsVoiceSearchCellId = @"Voice Search Settings";
 
 @interface SettingsCollectionViewController (NotificationBridgeDelegate)
 // Notifies this controller that the sign in state has changed.
 - (void)onSignInStateChanged;
 @end
@@ skipping 46 matching lines @@
   ~SigninObserverBridge() override{};
 
   // SigninManagerBase::Observer implementation:
   void GoogleSigninSucceeded(const std::string& account_id,
                              const std::string& username,
                              const std::string& password) override;
   void GoogleSignedOut(const std::string& account_id,
                        const std::string& username) override;
 
  private:
-  base::WeakNSObject<SettingsCollectionViewController> owner_;
+  __weak SettingsCollectionViewController* owner_;
   ScopedObserver<SigninManager, SigninObserverBridge> observer_;
 };
 
 SigninObserverBridge::SigninObserverBridge(
     ios::ChromeBrowserState* browserState,
     SettingsCollectionViewController* owner)
     : owner_(owner), observer_(this) {
   DCHECK(owner_);
   SigninManager* sigin_manager =
       ios::SigninManagerFactory::GetForBrowserState(browserState);
@@ skipping 24 matching lines @@
                                                PrefObserverDelegate,
                                                SigninPromoViewConsumer> {
   // The main browser state that hold the settings. Never off the record.
   ios::ChromeBrowserState* _mainBrowserState;  // weak
 
   // The current browser state. It is either |_mainBrowserState|
   // or |_mainBrowserState->GetOffTheRecordChromeBrowserState()|.
   ios::ChromeBrowserState* _currentBrowserState;  // weak
   std::unique_ptr<SigninObserverBridge> _notificationBridge;
   std::unique_ptr<SyncObserverBridge> _syncObserverBridge;
-  base::scoped_nsobject<SigninInteractionController>
-      _signinInteractionController;
+  SigninInteractionController* _signinInteractionController;
   // Whether the impression of the Signin button has already been recorded.
   BOOL _hasRecordedSigninImpression;
   // PrefBackedBoolean for ShowMemoryDebugTools switch.
-  base::scoped_nsobject<PrefBackedBoolean> _showMemoryDebugToolsEnabled;
+  PrefBackedBoolean* _showMemoryDebugToolsEnabled;
   // The item related to the switch for the show suggestions setting.
-  base::scoped_nsobject<CollectionViewSwitchItem> _showMemoryDebugToolsItem;
+  CollectionViewSwitchItem* _showMemoryDebugToolsItem;
 
   // Mediator to configure the sign-in promo cell. Also used to received
   // identity update notifications.
-  base::scoped_nsobject<SigninPromoViewMediator> _signinPromoViewMediator;
+  SigninPromoViewMediator* _signinPromoViewMediator;
 
   // Cached resized profile image.
-  base::scoped_nsobject<UIImage> _resizedImage;
-  base::WeakNSObject<UIImage> _oldImage;
+  UIImage* _resizedImage;
+  __weak UIImage* _oldImage;
 
   // Identity object and observer used for Account Item refresh.
-  base::scoped_nsobject<ChromeIdentity> _identity;
+  ChromeIdentity* _identity;
   std::unique_ptr<ChromeIdentityServiceObserverBridge> _identityServiceObserver;
 
   // PrefMember for voice locale code.
   StringPrefMember _voiceLocaleCode;
   // Pref observer to track changes to prefs.
   std::unique_ptr<PrefObserverBridge> _prefObserverBridge;
   // TODO(crbug.com/662435): Refactor PrefObserverBridge so it owns the
   // PrefChangeRegistrar.
   // Registrar for pref changes notifications.
   PrefChangeRegistrar _prefChangeRegistrar;
 
   // Updatable Items.
-  base::scoped_nsobject<CollectionViewDetailItem> _voiceSearchDetailItem;
-  base::scoped_nsobject<CollectionViewDetailItem> _defaultSearchEngineItem;
-  base::scoped_nsobject<CollectionViewDetailItem> _savePasswordsDetailItem;
-  base::scoped_nsobject<CollectionViewDetailItem> _autoFillDetailItem;
+  CollectionViewDetailItem* _voiceSearchDetailItem;
+  CollectionViewDetailItem* _defaultSearchEngineItem;
+  CollectionViewDetailItem* _savePasswordsDetailItem;
+  CollectionViewDetailItem* _autoFillDetailItem;
 }
 
 // Stops observing browser state services. This is required during the shutdown
 // phase to avoid observing services for a profile that is being killed.
 - (void)stopBrowserStateServiceObservers;
 
 @end
 
 @implementation SettingsCollectionViewController
 
@@ skipping 12 matching lines @@
     _currentBrowserState = currentBrowserState;
     self.title = l10n_util::GetNSStringWithFixup(IDS_IOS_SETTINGS_TITLE);
     self.collectionViewAccessibilityIdentifier = kSettingsCollectionViewId;
     _notificationBridge.reset(
         new SigninObserverBridge(_mainBrowserState, self));
     syncer::SyncService* syncService =
         IOSChromeProfileSyncServiceFactory::GetForBrowserState(
             _mainBrowserState);
     _syncObserverBridge.reset(new SyncObserverBridge(self, syncService));
 
-    _showMemoryDebugToolsEnabled.reset([[PrefBackedBoolean alloc]
+    _showMemoryDebugToolsEnabled = [[PrefBackedBoolean alloc]
         initWithPrefService:GetApplicationContext()->GetLocalState()
-                   prefName:prefs::kShowMemoryDebuggingTools]);
+                   prefName:prefs::kShowMemoryDebuggingTools];
     [_showMemoryDebugToolsEnabled setObserver:self];
 
     AuthenticationService* authService =
         AuthenticationServiceFactory::GetForBrowserState(_mainBrowserState);
-    _identity.reset([authService->GetAuthenticatedIdentity() retain]);
+    _identity = authService->GetAuthenticatedIdentity();
     _identityServiceObserver.reset(
         new ChromeIdentityServiceObserverBridge(self));
 
     PrefService* prefService = _mainBrowserState->GetPrefs();
 
     _voiceLocaleCode.Init(prefs::kVoiceSearchLocale, prefService);
 
     _prefChangeRegistrar.Init(prefService);
     _prefObserverBridge.reset(new PrefObserverBridge(self));
     // Register to observe any changes on Perf backed values displayed by the
     // screen.
     _prefObserverBridge->ObserveChangesForPreference(prefs::kVoiceSearchLocale,
                                                      &_prefChangeRegistrar);
     _prefObserverBridge->ObserveChangesForPreference(
         password_manager::prefs::kPasswordManagerSavingEnabled,
         &_prefChangeRegistrar);
     _prefObserverBridge->ObserveChangesForPreference(
         autofill::prefs::kAutofillEnabled, &_prefChangeRegistrar);
 
     [self loadModel];
   }
   return self;
 }
 
 - (void)dealloc {
   [self stopBrowserStateServiceObservers];
-  [super dealloc];
 }
 
 - (void)stopBrowserStateServiceObservers {
   _syncObserverBridge.reset();
   _notificationBridge.reset();
   _identityServiceObserver.reset();
   [_showMemoryDebugToolsEnabled setObserver:nil];
 }
 
 - (SigninInteractionController*)signinInteractionController {
@@ skipping 23 matching lines @@
       AuthenticationServiceFactory::GetForBrowserState(_mainBrowserState);
   if (!authService->IsAuthenticated()) {
     if (!_hasRecordedSigninImpression) {
       // Once the Settings are open, this button impression will at most be
       // recorded once until they are closed.
       base::RecordAction(
           base::UserMetricsAction("Signin_Impression_FromSettings"));
       _hasRecordedSigninImpression = YES;
     }
     if (experimental_flags::IsSigninPromoEnabled()) {
-      _signinPromoViewMediator.reset([[SigninPromoViewMediator alloc] init]);
-      _signinPromoViewMediator.get().consumer = self;
+      _signinPromoViewMediator = [[SigninPromoViewMediator alloc] init];
+      _signinPromoViewMediator.consumer = self;
     }
     [model addItem:[self signInTextItem]
         toSectionWithIdentifier:SectionIdentifierSignIn];
   } else {
-    _signinPromoViewMediator.reset(nil);
+    _signinPromoViewMediator = nil;
     [model addItem:[self accountCellItem]
         toSectionWithIdentifier:SectionIdentifierSignIn];
   }
 
   // Basics section
   [model addSectionWithIdentifier:SectionIdentifierBasics];
-  CollectionViewTextItem* basicsHeader = [
-      [[CollectionViewTextItem alloc] initWithType:ItemTypeHeader] autorelease];
+  CollectionViewTextItem* basicsHeader =
+      [[CollectionViewTextItem alloc] initWithType:ItemTypeHeader];
   basicsHeader.text = l10n_util::GetNSString(IDS_IOS_OPTIONS_GENERAL_TAB_LABEL);
   basicsHeader.textColor = [[MDCPalette greyPalette] tint500];
   [model setHeader:basicsHeader
       forSectionWithIdentifier:SectionIdentifierBasics];
   [model addItem:[self searchEngineDetailItem]
       toSectionWithIdentifier:SectionIdentifierBasics];
   [model addItem:[self savePasswordsDetailItem]
       toSectionWithIdentifier:SectionIdentifierBasics];
   [model addItem:[self autoFillDetailItem]
       toSectionWithIdentifier:SectionIdentifierBasics];
   if (experimental_flags::IsNativeAppLauncherEnabled()) {
     [model addItem:[self nativeAppsDetailItem]
         toSectionWithIdentifier:SectionIdentifierBasics];
   }
 
   // Advanced Section
   [model addSectionWithIdentifier:SectionIdentifierAdvanced];
-  CollectionViewTextItem* advancedHeader = [
-      [[CollectionViewTextItem alloc] initWithType:ItemTypeHeader] autorelease];
+  CollectionViewTextItem* advancedHeader =
+      [[CollectionViewTextItem alloc] initWithType:ItemTypeHeader];
   advancedHeader.text =
       l10n_util::GetNSString(IDS_IOS_OPTIONS_ADVANCED_TAB_LABEL);
   advancedHeader.textColor = [[MDCPalette greyPalette] tint500];
   [model setHeader:advancedHeader
       forSectionWithIdentifier:SectionIdentifierAdvanced];
   [model addItem:[self voiceSearchDetailItem]
       toSectionWithIdentifier:SectionIdentifierAdvanced];
   [model addItem:[self privacyDetailItem]
       toSectionWithIdentifier:SectionIdentifierAdvanced];
   [model addItem:[self contentSettingsDetailItem]
       toSectionWithIdentifier:SectionIdentifierAdvanced];
   [model addItem:[self bandwidthManagementDetailItem]
       toSectionWithIdentifier:SectionIdentifierAdvanced];
 
   // Info Section
   [model addSectionWithIdentifier:SectionIdentifierInfo];
   [model addItem:[self aboutChromeDetailItem]
       toSectionWithIdentifier:SectionIdentifierInfo];
 
   // Debug Section
   if ([self hasDebugSection]) {
     [model addSectionWithIdentifier:SectionIdentifierDebug];
-    CollectionViewTextItem* debugHeader = [[[CollectionViewTextItem alloc]
-        initWithType:ItemTypeHeader] autorelease];
+    CollectionViewTextItem* debugHeader =
+        [[CollectionViewTextItem alloc] initWithType:ItemTypeHeader];
     debugHeader.text = @"Debug";
     debugHeader.textColor = [[MDCPalette greyPalette] tint500];
     [model setHeader:debugHeader
         forSectionWithIdentifier:SectionIdentifierDebug];
   }
 
   if (experimental_flags::IsMemoryDebuggingEnabled()) {
-    _showMemoryDebugToolsItem.reset([[self showMemoryDebugSwitchItem] retain]);
+    _showMemoryDebugToolsItem = [self showMemoryDebugSwitchItem];
     [model addItem:_showMemoryDebugToolsItem
         toSectionWithIdentifier:SectionIdentifierDebug];
   }
 
 #if CHROMIUM_BUILD && !defined(NDEBUG)
   [model addItem:[self viewSourceSwitchItem]
       toSectionWithIdentifier:SectionIdentifierDebug];
   [model addItem:[self logJavascriptConsoleSwitchItem]
       toSectionWithIdentifier:SectionIdentifierDebug];
   [model addItem:[self showAutofillTypePredictionsSwitchItem]
       toSectionWithIdentifier:SectionIdentifierDebug];
   [model addItem:[self materialCatalogDetailItem]
       toSectionWithIdentifier:SectionIdentifierDebug];
 #endif  // CHROMIUM_BUILD && !defined(NDEBUG)
 }
 
 #pragma mark - Model Items
 
 - (CollectionViewItem*)signInTextItem {
   if (experimental_flags::IsSigninPromoEnabled()) {
-    DCHECK(_signinPromoViewMediator.get());
-    SigninPromoItem* signinPromoItem = [
-        [[SigninPromoItem alloc] initWithType:ItemTypeSigninPromo] autorelease];
+    DCHECK(_signinPromoViewMediator);
+    SigninPromoItem* signinPromoItem =
+        [[SigninPromoItem alloc] initWithType:ItemTypeSigninPromo];
     signinPromoItem.configurator =
         [_signinPromoViewMediator createConfigurator];
     return signinPromoItem;
   }
-  AccountSignInItem* signInTextItem = [[[AccountSignInItem alloc]
-      initWithType:ItemTypeSignInButton] autorelease];
+  AccountSignInItem* signInTextItem =
+      [[AccountSignInItem alloc] initWithType:ItemTypeSignInButton];
   signInTextItem.accessibilityIdentifier = kSettingsSignInCellId;
   UIImage* image = CircularImageFromImage(ios::GetChromeBrowserProvider()
                                               ->GetSigninResourcesProvider()
                                               ->GetDefaultAvatar(),
                                           kAccountProfilePhotoDimension);
   signInTextItem.image = image;
   return signInTextItem;
 }
 
 - (CollectionViewItem*)accountCellItem {
   CollectionViewAccountItem* identityAccountItem =
-      [[[CollectionViewAccountItem alloc] initWithType:ItemTypeAccount]
-          autorelease];
+      [[CollectionViewAccountItem alloc] initWithType:ItemTypeAccount];
   identityAccountItem.accessoryType =
       MDCCollectionViewCellAccessoryDisclosureIndicator;
   identityAccountItem.accessibilityIdentifier = kSettingsAccountCellId;
   [self updateIdentityAccountItem:identityAccountItem];
   return identityAccountItem;
 }
 
 - (CollectionViewItem*)searchEngineDetailItem {
   NSString* defaultSearchEngineName =
       base::SysUTF16ToNSString(GetDefaultSearchEngineName(
           ios::TemplateURLServiceFactory::GetForBrowserState(
               _mainBrowserState)));
 
-  _defaultSearchEngineItem.reset(
-      [[self detailItemWithType:ItemTypeSearchEngine
-                           text:l10n_util::GetNSString(
-                                    IDS_IOS_SEARCH_ENGINE_SETTING_TITLE)
-                     detailText:defaultSearchEngineName] retain]);
-  _defaultSearchEngineItem.get().accessibilityIdentifier =
+  _defaultSearchEngineItem =
+      [self detailItemWithType:ItemTypeSearchEngine
+                          text:l10n_util::GetNSString(
+                                   IDS_IOS_SEARCH_ENGINE_SETTING_TITLE)
+                    detailText:defaultSearchEngineName];
+  _defaultSearchEngineItem.accessibilityIdentifier =
       kSettingsSearchEngineCellId;
   return _defaultSearchEngineItem;
 }
 
 - (CollectionViewItem*)savePasswordsDetailItem {
   BOOL savePasswordsEnabled = _mainBrowserState->GetPrefs()->GetBoolean(
       password_manager::prefs::kPasswordManagerSavingEnabled);
   NSString* passwordsDetail = savePasswordsEnabled
                                   ? l10n_util::GetNSString(IDS_IOS_SETTING_ON)
                                   : l10n_util::GetNSString(IDS_IOS_SETTING_OFF);
 
-  _savePasswordsDetailItem.reset(
-      [[self detailItemWithType:ItemTypeSavedPasswords
-                           text:l10n_util::GetNSString(IDS_IOS_SAVE_PASSWORDS)
-                     detailText:passwordsDetail] retain]);
+  _savePasswordsDetailItem =
+      [self detailItemWithType:ItemTypeSavedPasswords
+                          text:l10n_util::GetNSString(IDS_IOS_SAVE_PASSWORDS)
+                    detailText:passwordsDetail];
 
   return _savePasswordsDetailItem;
 }
 
 - (CollectionViewItem*)autoFillDetailItem {
   BOOL autofillEnabled = _mainBrowserState->GetPrefs()->GetBoolean(
       autofill::prefs::kAutofillEnabled);
   NSString* autofillDetail = autofillEnabled
                                  ? l10n_util::GetNSString(IDS_IOS_SETTING_ON)
                                  : l10n_util::GetNSString(IDS_IOS_SETTING_OFF);
-  _autoFillDetailItem.reset(
-      [[self detailItemWithType:ItemTypeAutofill
-                           text:l10n_util::GetNSString(IDS_IOS_AUTOFILL)
-                     detailText:autofillDetail] retain]);
+  _autoFillDetailItem =
+      [self detailItemWithType:ItemTypeAutofill
+                          text:l10n_util::GetNSString(IDS_IOS_AUTOFILL)
+                    detailText:autofillDetail];
 
   return _autoFillDetailItem;
 }
 
 - (CollectionViewItem*)nativeAppsDetailItem {
   return [self
       detailItemWithType:ItemTypeNativeApps
                     text:l10n_util::GetNSString(IDS_IOS_GOOGLE_APPS_SM_SETTINGS)
               detailText:nil];
 }
 
 - (CollectionViewItem*)voiceSearchDetailItem {
   voice::SpeechInputLocaleConfig* localeConfig =
       voice::SpeechInputLocaleConfig::GetInstance();
   voice::SpeechInputLocale locale =
       _voiceLocaleCode.GetValue().length()
           ? localeConfig->GetLocaleForCode(_voiceLocaleCode.GetValue())
           : localeConfig->GetDefaultLocale();
   NSString* languageName = base::SysUTF16ToNSString(locale.display_name);
-  _voiceSearchDetailItem.reset(
-      [[self detailItemWithType:ItemTypeVoiceSearch
-                           text:l10n_util::GetNSString(
-                                    IDS_IOS_VOICE_SEARCH_SETTING_TITLE)
-                     detailText:languageName] retain]);
-  _voiceSearchDetailItem.get().accessibilityIdentifier =
-      kSettingsVoiceSearchCellId;
+  _voiceSearchDetailItem =
+      [self detailItemWithType:ItemTypeVoiceSearch
+                          text:l10n_util::GetNSString(
+                                   IDS_IOS_VOICE_SEARCH_SETTING_TITLE)
+                    detailText:languageName];
+  _voiceSearchDetailItem.accessibilityIdentifier = kSettingsVoiceSearchCellId;
   return _voiceSearchDetailItem;
 }
 
 - (CollectionViewItem*)privacyDetailItem {
   return
       [self detailItemWithType:ItemTypePrivacy
                           text:l10n_util::GetNSString(
                                    IDS_OPTIONS_ADVANCED_SECTION_TITLE_PRIVACY)
                     detailText:nil];
 }
@@ skipping 55 matching lines @@
 #endif  // CHROMIUM_BUILD && !defined(NDEBUG)
 
 #pragma mark Item Updaters
 
 - (void)updateSearchCell {
   NSString* defaultSearchEngineName =
       base::SysUTF16ToNSString(GetDefaultSearchEngineName(
           ios::TemplateURLServiceFactory::GetForBrowserState(
               _mainBrowserState)));
 
-  _defaultSearchEngineItem.get().detailText = defaultSearchEngineName;
+  _defaultSearchEngineItem.detailText = defaultSearchEngineName;
   [self reconfigureCellsForItems:@[ _defaultSearchEngineItem ]];
 }
 
 #pragma mark Item Constructors
 
 - (CollectionViewDetailItem*)detailItemWithType:(NSInteger)type
                                            text:(NSString*)text
                                      detailText:(NSString*)detailText {
   CollectionViewDetailItem* detailItem =
-      [[[CollectionViewDetailItem alloc] initWithType:type] autorelease];
+      [[CollectionViewDetailItem alloc] initWithType:type];
   detailItem.text = text;
   detailItem.detailText = detailText;
   detailItem.accessoryType = MDCCollectionViewCellAccessoryDisclosureIndicator;
   detailItem.accessibilityTraits |= UIAccessibilityTraitButton;
 
   return detailItem;
 }
 
 - (CollectionViewSwitchItem*)switchItemWithType:(NSInteger)type
                                           title:(NSString*)title
                                 withDefaultsKey:(NSString*)key {
   CollectionViewSwitchItem* switchItem =
-      [[[CollectionViewSwitchItem alloc] initWithType:type] autorelease];
+      [[CollectionViewSwitchItem alloc] initWithType:type];
   switchItem.text = title;
   if (key) {
     NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
     switchItem.on = [defaults boolForKey:key];
   }
 
   return switchItem;
 }
 
 #pragma mark - UICollectionViewDataSource
@@ skipping 104 matching lines @@
   id object = [self.collectionViewModel itemAtIndexPath:indexPath];
   if ([object respondsToSelector:@selector(isEnabled)] &&
       ![object performSelector:@selector(isEnabled)]) {
     // Don't perform any action if the cell isn't enabled.
     return;
   }
 
   NSInteger itemType =
       [self.collectionViewModel itemTypeForIndexPath:indexPath];
 
-  base::scoped_nsobject<UIViewController> controller;
+  UIViewController* controller;
 
   switch (itemType) {
     case ItemTypeSignInButton:
       [self showSignInWithIdentity:nil];
       break;
     case ItemTypeAccount:
-      controller.reset([[AccountsCollectionViewController alloc]
+      controller = [[AccountsCollectionViewController alloc]
                initWithBrowserState:_mainBrowserState
-          closeSettingsOnAddAccount:NO]);
+          closeSettingsOnAddAccount:NO];
       break;
     case ItemTypeSearchEngine:
-      controller.reset([[SearchEngineSettingsCollectionViewController alloc]
-          initWithBrowserState:_mainBrowserState]);
+      controller = [[SearchEngineSettingsCollectionViewController alloc]
+          initWithBrowserState:_mainBrowserState];
       break;
     case ItemTypeSavedPasswords: {
-      controller.reset([[SavePasswordsCollectionViewController alloc]
-          initWithBrowserState:_mainBrowserState]);
+      controller = [[SavePasswordsCollectionViewController alloc]
+          initWithBrowserState:_mainBrowserState];
       break;
     }
     case ItemTypeAutofill:
-      controller.reset([[AutofillCollectionViewController alloc]
-          initWithBrowserState:_mainBrowserState]);
+      controller = [[AutofillCollectionViewController alloc]
+          initWithBrowserState:_mainBrowserState];
       break;
     case ItemTypeNativeApps:
-      controller.reset([[NativeAppsCollectionViewController alloc]
+      controller = [[NativeAppsCollectionViewController alloc]
           initWithURLRequestContextGetter:_currentBrowserState
-                                              ->GetRequestContext()]);
+                                              ->GetRequestContext()];
       break;
     case ItemTypeVoiceSearch:
-      controller.reset([[VoicesearchCollectionViewController alloc]
-          initWithPrefs:_mainBrowserState->GetPrefs()]);
+      controller = [[VoicesearchCollectionViewController alloc]
+          initWithPrefs:_mainBrowserState->GetPrefs()];
       break;
     case ItemTypePrivacy:
-      controller.reset([[PrivacyCollectionViewController alloc]
-          initWithBrowserState:_mainBrowserState]);
+      controller = [[PrivacyCollectionViewController alloc]
+          initWithBrowserState:_mainBrowserState];
       break;
     case ItemTypeContentSettings:
-      controller.reset([[ContentSettingsCollectionViewController alloc]
-          initWithBrowserState:_mainBrowserState]);
+      controller = [[ContentSettingsCollectionViewController alloc]
+          initWithBrowserState:_mainBrowserState];
       break;
     case ItemTypeBandwidth:
-      controller.reset([[BandwidthManagementCollectionViewController alloc]
-          initWithBrowserState:_mainBrowserState]);
+      controller = [[BandwidthManagementCollectionViewController alloc]
+          initWithBrowserState:_mainBrowserState];
       break;
     case ItemTypeAboutChrome:
-      controller.reset([[AboutChromeCollectionViewController alloc] init]);
+      controller = [[AboutChromeCollectionViewController alloc] init];
       break;
     case ItemTypeMemoryDebugging:
     case ItemTypeViewSource:
     case ItemTypeLogJavascript:
     case ItemTypeShowAutofillTypePredictions:
       // Taps on these don't do anything. They have a switch as accessory view
       // and only the switch is tappable.
       break;
     case ItemTypeCellCatalog:
-      controller.reset([[MaterialCellCatalogViewController alloc] init]);
+      controller = [[MaterialCellCatalogViewController alloc] init];
       break;
     default:
       break;
   }
 
   if (controller) {
     [self.navigationController pushViewController:controller animated:YES];
   }
 }
 
@@ skipping 118 matching lines @@
   }
   return NO;
 #endif  // CHROMIUM_BUILD && !defined(NDEBUG)
 }
 
 // Updates the identity cell.
 - (void)updateIdentityAccountItem:
     (CollectionViewAccountItem*)identityAccountItem {
   AuthenticationService* authService =
       AuthenticationServiceFactory::GetForBrowserState(_mainBrowserState);
-  _identity.reset([authService->GetAuthenticatedIdentity() retain]);
+  _identity = authService->GetAuthenticatedIdentity();
   if (!_identity) {
     // This could occur during the sign out process. Just ignore as the account
     // cell will be replaced by the "Sign in" button.
     return;
   }
   identityAccountItem.image = [self userAccountImage];
   identityAccountItem.text = [_identity userFullName];
 
   SyncSetupService* syncSetupService =
       SyncSetupServiceFactory::GetForBrowserState(_mainBrowserState);
@@ skipping 36 matching lines @@
     [self updateIdentityAccountItem:identityAccountItem];
     [self reconfigureCellsForItems:@[ identityAccountItem ]];
   }
 }
 
 #pragma mark Sign in
 
 - (void)showSignInWithIdentity:(ChromeIdentity*)identity {
   base::RecordAction(base::UserMetricsAction("Signin_Signin_FromSettings"));
   DCHECK(!_signinInteractionController);
-  _signinInteractionController.reset([[SigninInteractionController alloc]
+  _signinInteractionController = [[SigninInteractionController alloc]
           initWithBrowserState:_mainBrowserState
       presentingViewController:self.navigationController
          isPresentedOnSettings:YES
                    accessPoint:signin_metrics::AccessPoint::
-                                   ACCESS_POINT_SETTINGS]);
+                                   ACCESS_POINT_SETTINGS];
 
-  base::WeakNSObject<SettingsCollectionViewController> weakSelf(self);
+  __weak SettingsCollectionViewController* weakSelf = self;
   [_signinInteractionController
       signInWithViewController:self
                       identity:identity
                     completion:^(BOOL success) {
                       [weakSelf didFinishSignin:success];
                     }];
 }
 
 - (void)didFinishSignin:(BOOL)signedIn {
-  _signinInteractionController.reset();
+  _signinInteractionController = nil;
 }
 
 - (void)signinPromoPrimaryAction:(id)unused {
-  ChromeIdentity* identity = _signinPromoViewMediator.get().defaultIdentity;
+  ChromeIdentity* identity = _signinPromoViewMediator.defaultIdentity;
   if (identity) {
     base::RecordAction(
         base::UserMetricsAction("Signin_SigninWithDefault_FromSettings"));
   } else {
     base::RecordAction(
         base::UserMetricsAction("Signin_SigninNewAccount_FromSettings"));
   }
   [self showSignInWithIdentity:identity];
 }
 
 - (void)signinPromoSecondaryAction:(id)unused {
-  DCHECK(_signinPromoViewMediator.get().defaultIdentity);
+  DCHECK(_signinPromoViewMediator.defaultIdentity);
   base::RecordAction(
       base::UserMetricsAction("Signin_SigninNotDefault_FromSettings"));
   [self showSignInWithIdentity:nil];
 }
 
 #pragma mark NotificationBridgeDelegate
 
 - (void)onSignInStateChanged {
   // Sign in state changes are rare. Just reload the entire collection when this
   // happens.
@@ skipping 26 matching lines @@
                 ->GetDefaultAvatar();
     // No cached image, trigger a fetch, which will notify all observers
     // (including the corresponding AccountViewBase).
     ios::GetChromeBrowserProvider()
         ->GetChromeIdentityService()
         ->GetAvatarForIdentity(_identity, ^(UIImage*){
                                });
   }
 
   // If the currently used image has already been resized, use it.
-  if (_resizedImage && _oldImage.get() == image)
+  if (_resizedImage && _oldImage == image)
     return _resizedImage;
 
-  _oldImage.reset(image);
+  _oldImage = image;
 
   // Resize the profile image.
   CGFloat dimension = kAccountProfilePhotoDimension;
   if (image.size.width != dimension || image.size.height != dimension) {
     image = ResizeImage(image, CGSizeMake(dimension, dimension),
                         ProjectionMode::kAspectFit);
   }
-  _resizedImage.reset([image retain]);
+  _resizedImage = image;
   return _resizedImage;
 }
 
 #pragma mark ChromeIdentityServiceObserver
 
 - (void)onProfileUpdate:(ChromeIdentity*)identity {
   if (identity == _identity) {
     [self reloadAccountCell];
   }
 }
 
 - (void)onChromeIdentityServiceWillBeDestroyed {
   _identityServiceObserver.reset();
 }
 
 #pragma mark - BooleanObserver
 
 - (void)booleanDidChange:(id<ObservableBoolean>)observableBoolean {
-  DCHECK_EQ(observableBoolean, _showMemoryDebugToolsEnabled.get());
+  DCHECK_EQ(observableBoolean, _showMemoryDebugToolsEnabled);
   // Update the Item.
-  _showMemoryDebugToolsItem.get().on = [_showMemoryDebugToolsEnabled value];
+  _showMemoryDebugToolsItem.on = [_showMemoryDebugToolsEnabled value];
 
   // Update the Cell.
   [self reconfigureCellsForItems:@[ _showMemoryDebugToolsItem ]];
 }
 
 #pragma mark - PrefObserverDelegate
 
 - (void)onPreferenceChanged:(const std::string&)preferenceName {
   if (preferenceName == prefs::kVoiceSearchLocale) {
     voice::SpeechInputLocaleConfig* localeConfig =
         voice::SpeechInputLocaleConfig::GetInstance();
     voice::SpeechInputLocale locale =
         _voiceLocaleCode.GetValue().length()
             ? localeConfig->GetLocaleForCode(_voiceLocaleCode.GetValue())
             : localeConfig->GetDefaultLocale();
     NSString* languageName = base::SysUTF16ToNSString(locale.display_name);
-    _voiceSearchDetailItem.get().detailText = languageName;
+    _voiceSearchDetailItem.detailText = languageName;
     [self reconfigureCellsForItems:@[ _voiceSearchDetailItem ]];
   }
 
   if (preferenceName ==
       password_manager::prefs::kPasswordManagerSavingEnabled) {
     BOOL savePasswordsEnabled =
         _mainBrowserState->GetPrefs()->GetBoolean(preferenceName);
     NSString* passwordsDetail =
         savePasswordsEnabled ? l10n_util::GetNSString(IDS_IOS_SETTING_ON)
                              : l10n_util::GetNSString(IDS_IOS_SETTING_OFF);
 
-    _savePasswordsDetailItem.get().detailText = passwordsDetail;
+    _savePasswordsDetailItem.detailText = passwordsDetail;
     [self reconfigureCellsForItems:@[ _savePasswordsDetailItem ]];
   }
 
   if (preferenceName == autofill::prefs::kAutofillEnabled) {
     BOOL autofillEnabled =
         _mainBrowserState->GetPrefs()->GetBoolean(preferenceName);
     NSString* autofillDetail =
         autofillEnabled ? l10n_util::GetNSString(IDS_IOS_SETTING_ON)
                         : l10n_util::GetNSString(IDS_IOS_SETTING_OFF);
-    _autoFillDetailItem.get().detailText = autofillDetail;
+    _autoFillDetailItem.detailText = autofillDetail;
     [self reconfigureCellsForItems:@[ _autoFillDetailItem ]];
   }
 }
 
 #pragma mark - SigninPromoViewConsumer
 
 - (void)configureSigninPromoViewWithNewIdentity:(BOOL)newIdentity
                                    configurator:(SigninPromoViewConfigurator*)
                                                     configurator {
   if (![self.collectionViewModel hasItemForItemType:ItemTypeSigninPromo
                                   sectionIdentifier:SectionIdentifierSignIn]) {
     return;
   }
   NSIndexPath* signinPromoCellIndexPath =
       [self.collectionViewModel indexPathForItemType:ItemTypeSigninPromo
                                    sectionIdentifier:SectionIdentifierSignIn];
   DCHECK(signinPromoCellIndexPath.item != NSNotFound);
   SigninPromoItem* signinPromoItem = base::mac::ObjCCast<SigninPromoItem>(
       [self.collectionViewModel itemAtIndexPath:signinPromoCellIndexPath]);
   if (signinPromoItem) {
     signinPromoItem.configurator = configurator;
     [self reconfigureCellsForItems:@[ signinPromoItem ]];
     if (newIdentity)
       [self.collectionViewLayout invalidateLayout];
   }
 }
 
 @end