[ObjC ARC] Converts ios/chrome/browser/browsing_data:browsing_data_internal to ARC.

ios/chrome/browser/browsing_data/browsing_data_removal_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/browsing_data/browsing_data_removal_controller.h"
 
 #import <WebKit/WebKit.h>
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/containers/hash_tables.h"
-#import "base/ios/weak_nsobject.h"
 #include "base/logging.h"
 #import "base/mac/bind_objc_block.h"
 #include "base/memory/ref_counted.h"
 #include "components/open_from_clipboard/clipboard_recent_content.h"
 #include "components/signin/ios/browser/account_consistency_service.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/browsing_data/browsing_data_remover_helper.h"
 #include "ios/chrome/browser/browsing_data/ios_chrome_browsing_data_remover.h"
 #include "ios/chrome/browser/callback_counter.h"
 #include "ios/chrome/browser/sessions/session_util.h"
 #include "ios/chrome/browser/signin/account_consistency_service_factory.h"
 #import "ios/chrome/browser/snapshots/snapshots_util.h"
 #import "ios/chrome/browser/ui/browser_view_controller.h"
 #include "ios/public/provider/chrome/browser/chrome_browser_provider.h"
 #import "ios/public/provider/chrome/browser/native_app_launcher/native_app_metadata.h"
 #import "ios/public/provider/chrome/browser/native_app_launcher/native_app_whitelist_manager.h"
 #include "ios/web/public/web_thread.h"
 #import "ios/web/public/web_view_creation_util.h"
 #import "ios/web/web_state/ui/wk_web_view_configuration_provider.h"
 #include "net/cookies/cookie_store.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/channel_id_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 // Empty callback used by DeleteAllCreatedBetweenAsync below.
 void DoNothing(int n) {}
 }
 
 @interface BrowsingDataRemovalController ()
 // Removes data used by the Google App Launcher.
 - (void)removeGALData;
 // Removes browsing data that is created by web views associated with
 // |browserState|. |mask| is obtained from
@@ skipping 54 matching lines @@
 // Called when a removal operation for |browserState| finishes.
 - (void)decrementPendingRemovalCountForBrowserState:
     (ios::ChromeBrowserState*)browserState;
 @end
 
 @implementation BrowsingDataRemovalController {
   // Wrapper around IOSChromeBrowsingDataRemover that serializes removal
   // operations.
   std::unique_ptr<BrowsingDataRemoverHelper> _browsingDataRemoverHelper;
   // The delegate.
-  base::WeakNSProtocol<id<BrowsingDataRemovalControllerDelegate>> _delegate;
+  __weak id<BrowsingDataRemovalControllerDelegate> _delegate;

[rohitrao (ping after 24h), 2017/06/05 14:37:10]

Should this just become a property instead?

   // A map that tracks the number of pending removals for a given
   // ChromeBrowserState.
   base::hash_map<ios::ChromeBrowserState*, int> _pendingRemovalCount;
 }
 
 - (instancetype)initWithDelegate:
     (id<BrowsingDataRemovalControllerDelegate>)delegate {
   if ((self = [super init])) {
     DCHECK(delegate);
     _browsingDataRemoverHelper.reset(new BrowsingDataRemoverHelper());
-    _delegate.reset(delegate);
+    _delegate = delegate;
   }
   return self;
 }
 
 - (instancetype)init {
   NOTREACHED();
   return nil;
 }
 
 - (void)removeBrowsingDataFromBrowserState:
@@ skipping 15 matching lines @@
             ios::AccountConsistencyServiceFactory::GetForBrowserState(
                 browserState)) {
       accountConsistencyService->OnBrowsingDataRemoved();
     }
     if (completionHandler) {
       completionHandler();
     }
   };
 
   scoped_refptr<CallbackCounter> callbackCounter =
-      new CallbackCounter(base::BindBlock(browsingDataCleared));
+      new CallbackCounter(base::BindBlockArc(browsingDataCleared));
   ProceduralBlock decrementCallbackCounterCount = ^{
     callbackCounter->DecrementCount();
   };
 
   callbackCounter->IncrementCount();
   base::Time beginDeleteTime =
       browsing_data::CalculateBeginDeleteTime(timePeriod);
   [self removeIOSSpecificBrowsingDataFromBrowserState:browserState
                                                  mask:mask
                                           deleteBegin:beginDeleteTime
                                     completionHandler:
                                         decrementCallbackCounterCount];
 
   if (mask & IOSChromeBrowsingDataRemover::REMOVE_DOWNLOADS) {
     DCHECK_EQ(browsing_data::TimePeriod::ALL_TIME, timePeriod)
         << "Partial clearing not supported";
     callbackCounter->IncrementCount();
     [_delegate
         removeExternalFilesForBrowserState:browserState
                          completionHandler:decrementCallbackCounterCount];
   }
 
   if (!browserState->IsOffTheRecord()) {
     callbackCounter->IncrementCount();
     _browsingDataRemoverHelper->Remove(browserState, mask, timePeriod,
-                                       base::BindBlock(^{
+                                       base::BindBlockArc(^{
                                          callbackCounter->DecrementCount();
                                        }));
   }
 }
 
 - (void)removeIOSSpecificIncognitoBrowsingDataFromBrowserState:
             (ios::ChromeBrowserState*)browserState
                                                           mask:(int)mask
                                              completionHandler:
                                                  (ProceduralBlock)
@@ skipping 71 matching lines @@
                                        completionHandler:
                                            (ProceduralBlock)completionHandler {
   // TODO(crbug.com/480654): Remove this check once browsing data partitioning
   // between BrowserStates is achieved.
   if (browserState->IsOffTheRecord()) {
     if (completionHandler) {
       dispatch_async(dispatch_get_main_queue(), completionHandler);
     }
     return;
   }
-  scoped_refptr<CallbackCounter> callbackCounter =
-      new CallbackCounter(base::BindBlock(completionHandler ? completionHandler
-                                                            : ^{
-                                                              }));
+  scoped_refptr<CallbackCounter> callbackCounter = new CallbackCounter(
+      base::BindBlockArc(completionHandler ? completionHandler
+                                           : ^{
+                                             }));
 
   // Note: Before adding any method below, make sure that it can finish clearing
   // browsing data even when |browserState| is destroyed after this method call.
 
   callbackCounter->IncrementCount();
   [self removeWKWebViewCreatedBrowsingDataFromBrowserState:browserState
                                                       mask:mask
                                                deleteBegin:deleteBegin
                                          completionHandler:^{
                                            callbackCounter->DecrementCount();
                                          }];
 }
 
 - (void)
 removeWKWebViewCreatedBrowsingDataFromBrowserState:
     (ios::ChromeBrowserState*)browserState
                                               mask:(int)mask
                                        deleteBegin:(base::Time)deleteBegin
                                  completionHandler:
                                      (ProceduralBlock)completionHandler {
-  scoped_refptr<CallbackCounter> callbackCounter =
-      new CallbackCounter(base::BindBlock(completionHandler ? completionHandler
-                                                            : ^{
-                                                              }));
+  scoped_refptr<CallbackCounter> callbackCounter = new CallbackCounter(
+      base::BindBlockArc(completionHandler ? completionHandler
+                                           : ^{
+                                             }));
   ProceduralBlock decrementCallbackCounterCount = ^{
     callbackCounter->DecrementCount();
   };
 
   // Converts browsing data types from
   // IOSChromeBrowsingDataRemover::RemoveDataMask to
   // WKWebsiteDataStore strings.
-  base::scoped_nsobject<NSMutableSet> dataTypesToRemove(
-      [[NSMutableSet alloc] init]);
+  NSMutableSet* dataTypesToRemove = [[NSMutableSet alloc] init];
   if (mask & IOSChromeBrowsingDataRemover::REMOVE_CACHE_STORAGE) {
     [dataTypesToRemove addObject:WKWebsiteDataTypeDiskCache];
     [dataTypesToRemove addObject:WKWebsiteDataTypeMemoryCache];
   }
   if (mask & IOSChromeBrowsingDataRemover::REMOVE_APPCACHE) {
     [dataTypesToRemove addObject:WKWebsiteDataTypeOfflineWebApplicationCache];
   }
   WKWebView* markerWKWebView = nil;
   if (mask & IOSChromeBrowsingDataRemover::REMOVE_COOKIES) {
     // TODO(crbug.com/661630): This approach of creating a WKWebView to clear
@@ skipping 76 matching lines @@
   if (mask & IOSChromeBrowsingDataRemover::REMOVE_HISTORY) {
     session_util::DeleteLastSession(browserState);
   }
 
   // Cookies and server bound certificates should have the same lifetime.
   DCHECK_EQ((mask & IOSChromeBrowsingDataRemover::REMOVE_COOKIES) != 0,
             (mask & IOSChromeBrowsingDataRemover::REMOVE_CHANNEL_IDS) != 0);
   if (mask & IOSChromeBrowsingDataRemover::REMOVE_COOKIES) {
     scoped_refptr<net::URLRequestContextGetter> contextGetter =
         browserState->GetRequestContext();
-    base::Closure callback = base::BindBlock(^{
+    base::Closure callback = base::BindBlockArc(^{
     });
     web::WebThread::PostTask(
-        web::WebThread::IO, FROM_HERE, base::BindBlock(^{
+        web::WebThread::IO, FROM_HERE, base::BindBlockArc(^{
           net::URLRequestContext* requestContext =
               contextGetter->GetURLRequestContext();
           net::ChannelIDService* channelIdService =
               requestContext->channel_id_service();
           DCHECK(channelIdService);
           DCHECK(channelIdService->GetChannelIDStore());
           channelIdService->GetChannelIDStore()->DeleteAll(callback);
           DCHECK(requestContext->cookie_store());
           requestContext->cookie_store()->DeleteAllCreatedBetweenAsync(
               base::Time(), base::Time(), base::Bind(&DoNothing));
@@ skipping 18 matching lines @@
 
 - (BOOL)hasPendingRemovalOperations:(ios::ChromeBrowserState*)browserState {
   return _pendingRemovalCount[browserState] != 0;
 }
 
 - (void)browserStateDestroyed:(ios::ChromeBrowserState*)browserState {
   _pendingRemovalCount.erase(browserState);
 }
 
 @end