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

ios/chrome/browser/ui/external_file_remover.mm

 // Copyright (c) 2012 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/external_file_remover.h"
 
 #include "base/logging.h"
 #import "base/mac/bind_objc_block.h"
 #include "components/sessions/core/tab_restore_service.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/sessions/ios_chrome_tab_restore_service_factory.h"
 #import "ios/chrome/browser/ui/browser_view_controller.h"
 #import "ios/chrome/browser/ui/external_file_controller.h"
 #include "ios/web/public/web_thread.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 ExternalFileRemover::ExternalFileRemover(BrowserViewController* bvc)
     : tabRestoreService_(NULL), bvc_(bvc), weak_ptr_factory_(this) {}
 
 ExternalFileRemover::~ExternalFileRemover() {
   if (tabRestoreService_)
     tabRestoreService_->RemoveObserver(this);
 }
 
 void ExternalFileRemover::TabRestoreServiceChanged(
     sessions::TabRestoreService* service) {
@@ skipping 35 matching lines @@
                                       const base::Closure& callback) {
   NSSet* referencedFiles = all_files ? nil : [bvc_ referencedExternalFiles];
   const NSInteger kMinimumAgeInDays = 30;
   NSInteger ageInDays = all_files ? 0 : kMinimumAgeInDays;
 
   base::Closure callback_wrapper = callback;
   if (callback_wrapper.is_null()) {
     callback_wrapper = base::Bind(&base::DoNothing);
   }
   web::WebThread::PostBlockingPoolTaskAndReply(
-      FROM_HERE, base::BindBlock(^{
+      FROM_HERE, base::BindBlockArc(^{
         [ExternalFileController removeFilesExcluding:referencedFiles
                                            olderThan:ageInDays];
       }),
       callback_wrapper);
 }
 
 void ExternalFileRemover::RemoveAfterDelay(const base::TimeDelta& delay,
                                            const base::Closure& callback) {
   bool remove_all_files = delay == base::TimeDelta::FromSeconds(0);
   // Creating a copy so it can be used from the block underneath.
   base::Closure callback_copy = callback;
   // Since a method on |this| is called from a block, this dance is necessary to
   // make sure a method on |this| is not called when the object has gone away.
   base::WeakPtr<ExternalFileRemover> weak_this = weak_ptr_factory_.GetWeakPtr();
   web::WebThread::PostDelayedTask(
-      web::WebThread::UI, FROM_HERE, base::BindBlock(^{
+      web::WebThread::UI, FROM_HERE, base::BindBlockArc(^{

[sdefresne, 2017/04/06 11:23:45]

Followup:

I looks like all objects involved here are C++ object, so there is little point
using base::BindBlockArc. Can this be instead changed to a base::Bind instead,
like this:

  bool remove_all_files = delay == base::TimeDelta::FromSeconds(0);
  base::ScopedClosureRunner scoped_closure_runner(callback);
  web::WebThread::PostDelayedTask(
      web::WebThread::UI, FROM_HERE,
      base::Bind(
          [](base::WeakPtr<ExternalFileRemover> remover, bool all_files,
             base::ScopedClosureRunner runner) {
            DCHECK(remover.get());
            remover->RemoveFiles(all_files, runner.Release());
          },
          weak_ptr_factory_.GetWeakPtr(), remove_all_files,
          base::Passed(&scoped_closure_runner)),
      delay);

Or if you change the prototype of RemoveFiles to take a ScopedClosureRunner,
then you can just bind the method directly and remove the wrapping lambda.

[stkhapugin, 2017/04/07 13:02:09]

I agree with your assessment, but I'd like to do this in a separate CL, since
BindBlockArc makes as much sense as BindBlock before this CL. 

[sdefresne, 2017/04/10 09:32:05]

This is why I used "Followup:" to introduce my comment :-)

         if (weak_this) {
           weak_this->Remove(remove_all_files, callback_copy);
         } else if (!callback_copy.is_null()) {
           callback_copy.Run();
         }
       }),
       delay);
 }