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

ios/chrome/browser/ui/settings/clear_browsing_data_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/clear_browsing_data_collection_view_controller.h"
 
 #include <memory>
 #include <string>
 
 #include "base/ios/ios_util.h"
-#import "base/ios/weak_nsobject.h"
 #include "base/logging.h"
 #import "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
-#import "base/mac/scoped_nsobject.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/sys_string_conversions.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/browsing_data/core/browsing_data_utils.h"
 #include "components/browsing_data/core/counters/browsing_data_counter.h"
 #include "components/browsing_data/core/history_notice_utils.h"
 #include "components/browsing_data/core/pref_names.h"
 #include "components/google/core/browser/google_util.h"
@@ skipping 28 matching lines @@
 #import "ios/chrome/browser/ui/uikit_ui_util.h"
 #include "ios/chrome/common/channel_info.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/images/branded_image_provider.h"
 #import "ios/third_party/material_components_ios/src/components/Palettes/src/MaterialPalettes.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
+
 NSString* const kClearBrowsingDataCollectionViewId =
     @"kClearBrowsingDataCollectionViewId";
 NSString* const kClearBrowsingHistoryCellId = @"kClearBrowsingHistoryCellId";
 NSString* const kClearCookiesCellId = @"kClearCookiesCellId";
 NSString* const kClearCacheCellId = @"kClearCacheCellId";
 NSString* const kClearSavedPasswordsCellId = @"kClearSavedPasswordsCellId";
 NSString* const kClearAutofillCellId = @"kClearAutofillCellId";
 
 namespace {
 
@@ skipping 126 matching lines @@
       _timePeriod = static_cast<browsing_data::TimePeriod>(prefValue);
     } else {
       _timePeriod = browsing_data::TimePeriod::ALL_TIME;
     }
 
     self.title = l10n_util::GetNSString(IDS_IOS_CLEAR_BROWSING_DATA_TITLE);
     self.collectionViewAccessibilityIdentifier =
         kClearBrowsingDataCollectionViewId;
 
     if (experimental_flags::IsNewClearBrowsingDataUIEnabled()) {
-      base::WeakNSObject<ClearBrowsingDataCollectionViewController> weakSelf(
-          self);
+      __weak ClearBrowsingDataCollectionViewController* weakSelf = self;
       void (^dataClearedCallback)(
           const IOSChromeBrowsingDataRemover::NotificationDetails&) =
           ^(const IOSChromeBrowsingDataRemover::NotificationDetails& details) {
-            base::scoped_nsobject<ClearBrowsingDataCollectionViewController>
-                strongSelf([weakSelf retain]);
+            ClearBrowsingDataCollectionViewController* strongSelf = weakSelf;
             [strongSelf restartCounters:details.removal_mask];
           };
       _callbackSubscription =
           IOSChromeBrowsingDataRemover::RegisterOnBrowsingDataRemovedCallback(
-              base::BindBlock(dataClearedCallback));
+              base::BindBlockArc(dataClearedCallback));
     }
 
     [self loadModel];
     [self restartCounters:IOSChromeBrowsingDataRemover::REMOVE_ALL];
   }
   return self;
 }
 
 - (void)viewDidLoad {
   [super viewDidLoad];
 
   SigninManager* signinManager =
       ios::SigninManagerFactory::GetForBrowserState(_browserState);
   if (!signinManager->IsAuthenticated()) {
     return;
   }
 
   browser_sync::ProfileSyncService* syncService =
       IOSChromeProfileSyncServiceFactory::GetForBrowserState(_browserState);
   history::WebHistoryService* historyService =
       ios::WebHistoryServiceFactory::GetForBrowserState(_browserState);
 
-  base::WeakNSObject<ClearBrowsingDataCollectionViewController> weakSelf(self);
+  __weak ClearBrowsingDataCollectionViewController* weakSelf = self;
   browsing_data::ShouldShowNoticeAboutOtherFormsOfBrowsingHistory(
-      syncService, historyService, base::BindBlock(^(bool shouldShowNotice) {
-        base::scoped_nsobject<ClearBrowsingDataCollectionViewController>
-            strongSelf([weakSelf retain]);
+      syncService, historyService, base::BindBlockArc(^(bool shouldShowNotice) {
+        ClearBrowsingDataCollectionViewController* strongSelf = weakSelf;
         [strongSelf setShouldShowNoticeAboutOtherFormsOfBrowsingHistory:
                         shouldShowNotice];
       }));
 
   browsing_data::ShouldPopupDialogAboutOtherFormsOfBrowsingHistory(
       syncService, historyService, GetChannel(),
-      base::BindBlock(^(bool shouldShowPopup) {
-        base::scoped_nsobject<ClearBrowsingDataCollectionViewController>
-            strongSelf([weakSelf retain]);
+      base::BindBlockArc(^(bool shouldShowPopup) {
+        ClearBrowsingDataCollectionViewController* strongSelf = weakSelf;
         [strongSelf setShouldPopupDialogAboutOtherFormsOfBrowsingHistory:
                         shouldShowPopup];
       }));
 }
 
 #pragma mark CollectionViewController
 
 - (void)loadModel {
   [super loadModel];
   CollectionViewModel* model = self.collectionViewModel;
@@ skipping 53 matching lines @@
   ClearDataItem* autofillItem =
       [self clearDataItemWithType:ItemTypeDataTypeAutofill
                           titleID:IDS_IOS_CLEAR_AUTOFILL
                              mask:IOSChromeBrowsingDataRemover::REMOVE_FORM_DATA
                          prefName:browsing_data::prefs::kDeleteFormData];
   [model addItem:autofillItem
       toSectionWithIdentifier:SectionIdentifierDataTypes];
 
   // Clear Browsing Data button.
   [model addSectionWithIdentifier:SectionIdentifierClearBrowsingDataButton];
-  CollectionViewTextItem* clearButtonItem = [[[CollectionViewTextItem alloc]
-      initWithType:ItemTypeClearBrowsingDataButton] autorelease];
+  CollectionViewTextItem* clearButtonItem = [[CollectionViewTextItem alloc]
+      initWithType:ItemTypeClearBrowsingDataButton];
   clearButtonItem.text = l10n_util::GetNSString(IDS_IOS_CLEAR_BUTTON);
   clearButtonItem.accessibilityTraits |= UIAccessibilityTraitButton;
   clearButtonItem.textColor = [[MDCPalette cr_redPalette] tint500];
   [model addItem:clearButtonItem
       toSectionWithIdentifier:SectionIdentifierClearBrowsingDataButton];
 
   // Google Account footer.
   SigninManager* signinManager =
       ios::SigninManagerFactory::GetForBrowserState(_browserState);
   if (signinManager->IsAuthenticated()) {
@@ skipping 21 matching lines @@
   }
 }
 
 #pragma mark Items
 
 - (ClearDataItem*)clearDataItemWithType:(ItemType)itemType
                                 titleID:(int)titleMessageID
                                    mask:(int)mask
                                prefName:(const char*)prefName {
   PrefService* prefs = _browserState->GetPrefs();
-  ClearDataItem* clearDataItem =
-      [[[ClearDataItem alloc] initWithType:itemType] autorelease];
+  ClearDataItem* clearDataItem = [[ClearDataItem alloc] initWithType:itemType];
   clearDataItem.text = l10n_util::GetNSString(titleMessageID);
   if (prefs->GetBoolean(prefName)) {
     clearDataItem.accessoryType = MDCCollectionViewCellAccessoryCheckmark;
   }
   clearDataItem.dataTypeMask = mask;
   clearDataItem.prefName = prefName;
   clearDataItem.accessibilityIdentifier =
       [self getAccessibilityIdentifierFromItemType:itemType];
 
-  base::WeakNSObject<ClearBrowsingDataCollectionViewController> weakSelf(self);
+  __weak ClearBrowsingDataCollectionViewController* weakSelf = self;
   void (^updateUICallback)(const browsing_data::BrowsingDataCounter::Result&) =
       ^(const browsing_data::BrowsingDataCounter::Result& result) {
-        base::scoped_nsobject<ClearBrowsingDataCollectionViewController>
-            strongSelf([weakSelf retain]);
+        ClearBrowsingDataCollectionViewController* strongSelf = weakSelf;
         NSString* counterText = [strongSelf getCounterTextFromResult:result];
         [strongSelf updateCounter:itemType detailText:counterText];
       };
 
   [clearDataItem setCounter:BrowsingDataCounterWrapper::CreateCounterWrapper(
                                 prefName, _browserState, prefs,
-                                base::BindBlock(updateUICallback))];
+                                base::BindBlockArc(updateUICallback))];
   return clearDataItem;
 }
 
 - (void)updateCounter:(NSInteger)itemType detailText:(NSString*)detailText {
   NSIndexPath* indexPath = [self.collectionViewModel
       indexPathForItemType:itemType
          sectionIdentifier:SectionIdentifierDataTypes];
 
   CollectionViewModel* model = self.collectionViewModel;
   if (!model) {
@@ skipping 12 matching lines @@
   [self.collectionView.collectionViewLayout invalidateLayout];
 }
 
 - (CollectionViewItem*)footerForGoogleAccountSectionItem {
   return _shouldShowNoticeAboutOtherFormsOfBrowsingHistory
              ? [self footerGoogleAccountAndMyActivityItem]
              : [self footerGoogleAccountItem];
 }
 
 - (CollectionViewItem*)footerGoogleAccountItem {
-  CollectionViewFooterItem* footerItem = [[[CollectionViewFooterItem alloc]
-      initWithType:ItemTypeFooterGoogleAccount] autorelease];
+  CollectionViewFooterItem* footerItem = [[CollectionViewFooterItem alloc]
+      initWithType:ItemTypeFooterGoogleAccount];
   footerItem.text =
       l10n_util::GetNSString(IDS_IOS_CLEAR_BROWSING_DATA_FOOTER_ACCOUNT);
   UIImage* image = ios::GetChromeBrowserProvider()
                        ->GetBrandedImageProvider()
                        ->GetClearBrowsingDataAccountActivityImage();
   footerItem.image = image;
   return footerItem;
 }
 
 - (CollectionViewItem*)footerGoogleAccountAndMyActivityItem {
@@ skipping 27 matching lines @@
                      IDS_IOS_CLEAR_BROWSING_DATA_FOOTER_CLEAR_SYNC_AND_SAVED_SITE_DATA
                      URL:kClearBrowsingDataLearnMoreURL
                    image:image];
 }
 
 - (CollectionViewItem*)footerItemWithType:(ItemType)itemType
                                   titleID:(int)titleMessageID
                                       URL:(const char[])URL
                                     image:(UIImage*)image {
   CollectionViewFooterItem* footerItem =
-      [[[CollectionViewFooterItem alloc] initWithType:itemType] autorelease];
+      [[CollectionViewFooterItem alloc] initWithType:itemType];
   footerItem.text = l10n_util::GetNSString(titleMessageID);
   footerItem.linkURL = google_util::AppendGoogleLocaleParam(
       GURL(URL), GetApplicationContext()->GetApplicationLocale());
   footerItem.linkDelegate = self;
   footerItem.image = image;
   return footerItem;
 }
 
 - (CollectionViewItem*)timeRangeItem {
-  CollectionViewDetailItem* timeRangeItem = [[[CollectionViewDetailItem alloc]
-      initWithType:ItemTypeTimeRange] autorelease];
+  CollectionViewDetailItem* timeRangeItem =
+      [[CollectionViewDetailItem alloc] initWithType:ItemTypeTimeRange];
   timeRangeItem.text = l10n_util::GetNSString(
       IDS_IOS_CLEAR_BROWSING_DATA_TIME_RANGE_SELECTOR_TITLE);
   NSString* detailText = [TimeRangeSelectorCollectionViewController
       timePeriodLabelForPrefs:_browserState->GetPrefs()];
   DCHECK(detailText);
   timeRangeItem.detailText = detailText;
   timeRangeItem.accessoryType =
       MDCCollectionViewCellAccessoryDisclosureIndicator;
   timeRangeItem.accessibilityTraits |= UIAccessibilityTraitButton;
   return timeRangeItem;
 }
 
 #pragma mark UICollectionViewDelegate
 
 - (void)collectionView:(UICollectionView*)collectionView
     didSelectItemAtIndexPath:(NSIndexPath*)indexPath {
   [super collectionView:collectionView didSelectItemAtIndexPath:indexPath];
   NSInteger itemType =
       [self.collectionViewModel itemTypeForIndexPath:indexPath];
 
   switch (itemType) {
     case ItemTypeTimeRange: {
-      base::scoped_nsobject<UIViewController> controller(
+      UIViewController* controller =
           [[TimeRangeSelectorCollectionViewController alloc]
               initWithPrefs:_browserState->GetPrefs()
-                   delegate:self]);
+                   delegate:self];
       [self.navigationController pushViewController:controller animated:YES];
       break;
     }
     case ItemTypeDataTypeBrowsingHistory:
     case ItemTypeDataTypeCookiesSiteData:
     case ItemTypeDataTypeCache:
     case ItemTypeDataTypeSavedPasswords:
     case ItemTypeDataTypeAutofill: {
       // Toggle the checkmark.
       // TODO(crbug.com/631486): Custom checkmark animation to be implemented.
@@ skipping 79 matching lines @@
   for (ClearDataItem* dataTypeItem in dataTypeItems) {
     DCHECK([dataTypeItem isKindOfClass:[ClearDataItem class]]);
     if (dataTypeItem.accessoryType == MDCCollectionViewCellAccessoryCheckmark) {
       dataTypeMaskToRemove |= dataTypeItem.dataTypeMask;
     }
   }
   if (dataTypeMaskToRemove == 0) {
     // Nothing to clear (no data types selected).
     return YES;
   }
-  base::WeakNSObject<ClearBrowsingDataCollectionViewController> weakSelf(self);
+  __weak ClearBrowsingDataCollectionViewController* weakSelf = self;
   UIAlertController* alertController = [UIAlertController
       alertControllerWithTitle:nil
                        message:nil
                 preferredStyle:UIAlertControllerStyleActionSheet];
 
   UIAlertAction* clearDataAction = [UIAlertAction
       actionWithTitle:l10n_util::GetNSString(IDS_IOS_CLEAR_BUTTON)
                 style:UIAlertActionStyleDestructive
               handler:^(UIAlertAction* action) {
                 [weakSelf clearDataForDataTypes:dataTypeMaskToRemove];
               }];
   clearDataAction.accessibilityLabel =
       l10n_util::GetNSString(IDS_IOS_CONFIRM_CLEAR_BUTTON);
   UIAlertAction* cancelAction =
       [UIAlertAction actionWithTitle:l10n_util::GetNSString(IDS_CANCEL)
                                style:UIAlertActionStyleCancel
                              handler:nil];
   [alertController addAction:clearDataAction];
   [alertController addAction:cancelAction];
   [self presentViewController:alertController animated:YES completion:nil];
   return YES;
 }
 
 - (void)clearDataForDataTypes:(int)dataTypeMask {
   DCHECK(dataTypeMask);
-  base::scoped_nsobject<ClearBrowsingDataCommand> command(
+  ClearBrowsingDataCommand* command =
       [[ClearBrowsingDataCommand alloc] initWithBrowserState:_browserState
                                                         mask:dataTypeMask
-                                                  timePeriod:_timePeriod]);
+                                                  timePeriod:_timePeriod];
   [self chromeExecuteCommand:command];
 
   if (!!(dataTypeMask && IOSChromeBrowsingDataRemover::REMOVE_HISTORY)) {
     [self showBrowsingHistoryRemovedDialog];
   }
 }
 
 - (void)showBrowsingHistoryRemovedDialog {
   PrefService* prefs = _browserState->GetPrefs();
   int noticeShownTimes = prefs->GetInteger(
@@ skipping 20 matching lines @@
   NSString* title =
       l10n_util::GetNSString(IDS_IOS_CLEAR_BROWSING_DATA_HISTORY_NOTICE_TITLE);
   NSString* message = l10n_util::GetNSString(
       IDS_IOS_CLEAR_BROWSING_DATA_HISTORY_NOTICE_DESCRIPTION);
 
   UIAlertController* alertController =
       [UIAlertController alertControllerWithTitle:title
                                           message:message
                                    preferredStyle:UIAlertControllerStyleAlert];
 
-  base::WeakNSObject<ClearBrowsingDataCollectionViewController> weakSelf(self);
+  __weak ClearBrowsingDataCollectionViewController* weakSelf = self;
   UIAlertAction* openMyActivityAction = [UIAlertAction
       actionWithTitle:
           l10n_util::GetNSString(
               IDS_IOS_CLEAR_BROWSING_DATA_HISTORY_NOTICE_OPEN_HISTORY_BUTTON)
                 style:UIAlertActionStyleDefault
               handler:^(UIAlertAction* action) {
                 [weakSelf openMyActivityLink];
               }];
 
   UIAlertAction* okAction = [UIAlertAction
       actionWithTitle:l10n_util::GetNSString(
                           IDS_IOS_CLEAR_BROWSING_DATA_HISTORY_NOTICE_OK_BUTTON)
                 style:UIAlertActionStyleCancel
               handler:nil];
   [alertController addAction:openMyActivityAction];
   [alertController addAction:okAction];
   [self presentViewController:alertController animated:YES completion:nil];
 }
 
 - (void)openMyActivityLink {
-  base::scoped_nsobject<OpenUrlCommand> openMyActivityCommand(
-      [[OpenUrlCommand alloc] initWithURLFromChrome:GURL(kGoogleMyAccountURL)]);
-  openMyActivityCommand.get().tag = IDC_CLOSE_SETTINGS_AND_OPEN_URL;
+  OpenUrlCommand* openMyActivityCommand =
+      [[OpenUrlCommand alloc] initWithURLFromChrome:GURL(kGoogleMyAccountURL)];
+  openMyActivityCommand.tag = IDC_CLOSE_SETTINGS_AND_OPEN_URL;
   [self chromeExecuteCommand:openMyActivityCommand];
 }
 
 - (NSString*)getAccessibilityIdentifierFromItemType:(NSInteger)itemType {
   switch (itemType) {
     case ItemTypeDataTypeBrowsingHistory:
       return kClearBrowsingHistoryCellId;
     case ItemTypeDataTypeCookiesSiteData:
       return kClearCookiesCellId;
     case ItemTypeDataTypeCache:
@@ skipping 58 matching lines @@
             &result)
             ->Value();
 
     // Three cases: Nonzero result for the entire cache, nonzero result for
     // a subset of cache (i.e. a finite time interval), and almost zero (less
     // than 1 MB). There is no exact information that the cache is empty so that
     // falls into the almost zero case, which is displayed as less than 1 MB.
     // Because of this, the lowest unit that can be used is MB.
     static const int kBytesInAMegabyte = 1 << 20;
     if (cacheSizeBytes >= kBytesInAMegabyte) {
-      base::scoped_nsobject<NSByteCountFormatter> formatter(
-          [[NSByteCountFormatter alloc] init]);
-      formatter.get().allowedUnits = NSByteCountFormatterUseAll &
-                                     (~NSByteCountFormatterUseBytes) &
-                                     (~NSByteCountFormatterUseKB);
-      formatter.get().countStyle = NSByteCountFormatterCountStyleMemory;
+      NSByteCountFormatter* formatter = [[NSByteCountFormatter alloc] init];
+      formatter.allowedUnits = NSByteCountFormatterUseAll &
+                               (~NSByteCountFormatterUseBytes) &
+                               (~NSByteCountFormatterUseKB);
+      formatter.countStyle = NSByteCountFormatterCountStyleMemory;
       NSString* formattedSize = [formatter stringFromByteCount:cacheSizeBytes];
       return (_timePeriod == browsing_data::TimePeriod::ALL_TIME)
                  ? formattedSize
                  : l10n_util::GetNSStringF(
                        IDS_DEL_CACHE_COUNTER_UPPER_ESTIMATE,
                        base::SysNSStringToUTF16(formattedSize));
     }
     return l10n_util::GetNSString(IDS_DEL_CACHE_COUNTER_ALMOST_EMPTY);
   }
   return base::SysUTF16ToNSString(
@@ skipping 76 matching lines @@
 
 #pragma mark TimeRangeSelectorCollectionViewControllerDelegate
 
 - (void)timeRangeSelectorViewController:
             (TimeRangeSelectorCollectionViewController*)collectionViewController
                     didSelectTimePeriod:(browsing_data::TimePeriod)timePeriod {
   _timePeriod = timePeriod;
 }
 
 @end