Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/media_galleries

chrome/browser/media_galleries/fileapi/media_file_system_backend.cc

 // Copyright (c) 2013 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.
 
 #include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 57 matching lines @@
 
 void OnPreferencesInit(
     const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
     const extensions::Extension* extension,
     MediaGalleryPrefId pref_id,
     const base::Callback<void(base::File::Error result)>& callback) {
   content::WebContents* contents = web_contents_getter.Run();
   if (!contents) {
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(callback, base::File::FILE_ERROR_FAILED));
+        base::BindOnce(callback, base::File::FILE_ERROR_FAILED));
     return;
   }
   MediaFileSystemRegistry* registry =
       g_browser_process->media_file_system_registry();
   registry->RegisterMediaFileSystemForExtension(contents, extension, pref_id,
                                                 callback);
 }
 
 void AttemptAutoMountOnUIThread(
     const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
@@ skipping 27 matching lines @@
       // Pass the WebContentsGetter to the closure to prevent a use-after-free
       // in the case that the web_contents is destroyed before the closure runs.
       preferences->EnsureInitialized(base::Bind(&OnPreferencesInit,
                                                 web_contents_getter, extension,
                                                 pref_id, callback));
       return;
     }
   }
 
   content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(callback, base::File::FILE_ERROR_NOT_FOUND));
+      content::BrowserThread::IO, FROM_HERE,
+      base::BindOnce(callback, base::File::FILE_ERROR_NOT_FOUND));
 }
 
 }  // namespace
 
 const char MediaFileSystemBackend::kMediaTaskRunnerName[] =
     "media-task-runner";
 
 MediaFileSystemBackend::MediaFileSystemBackend(
     const base::FilePath& profile_path,
     base::SequencedTaskRunner* media_task_runner)
@@ skipping 77 matching lines @@
                         base::CompareCase::SENSITIVE))
     return false;
 
   const content::ResourceRequestInfo* request_info =
       content::ResourceRequestInfo::ForRequest(url_request);
   if (!request_info)
     return false;
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&AttemptAutoMountOnUIThread,
-                 request_info->GetWebContentsGetterForRequest(), storage_domain,
-                 mount_point, callback));
+      base::BindOnce(&AttemptAutoMountOnUIThread,
+                     request_info->GetWebContentsGetterForRequest(),
+                     storage_domain, mount_point, callback));
   return true;
 }
 
 bool MediaFileSystemBackend::CanHandleType(storage::FileSystemType type) const {
   switch (type) {
     case storage::kFileSystemTypeNativeMedia:
     case storage::kFileSystemTypeDeviceMedia:
 #if defined(OS_WIN) || defined(OS_MACOSX)
     case storage::kFileSystemTypePicasa:
     case storage::kFileSystemTypeItunes:
 #endif  // defined(OS_WIN) || defined(OS_MACOSX)
       return true;
     default:
       return false;
   }
 }
 
 void MediaFileSystemBackend::Initialize(storage::FileSystemContext* context) {
 }
 
 void MediaFileSystemBackend::ResolveURL(
     const FileSystemURL& url,
     storage::OpenFileSystemMode mode,
     const OpenFileSystemCallback& callback) {
   // We never allow opening a new FileSystem via usual ResolveURL.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(callback,
-                 GURL(),
-                 std::string(),
-                 base::File::FILE_ERROR_SECURITY));
+      FROM_HERE, base::BindOnce(callback, GURL(), std::string(),
+                                base::File::FILE_ERROR_SECURITY));
 }
 
 storage::AsyncFileUtil* MediaFileSystemBackend::GetAsyncFileUtil(
     storage::FileSystemType type) {
   // We count file system usages here, because we want to count (per session)
   // when the file system is actually used for I/O, rather than merely present.
   switch (type) {
     case storage::kFileSystemTypeNativeMedia:
       return native_media_file_util_.get();
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
@@ skipping 122 matching lines @@
 
 const storage::ChangeObserverList* MediaFileSystemBackend::GetChangeObservers(
     storage::FileSystemType type) const {
   return NULL;
 }
 
 const storage::AccessObserverList* MediaFileSystemBackend::GetAccessObservers(
     storage::FileSystemType type) const {
   return NULL;
 }