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

chrome/browser/media_galleries/gallery_watch_manager.cc

 // Copyright 2014 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/gallery_watch_manager.h"
 
 #include <stddef.h>
 
 #include <tuple>
 
@@ skipping 93 matching lines @@
 }
 
 void GalleryWatchManager::FileWatchManager::AddFileWatch(
     const base::FilePath& path,
     const base::Callback<void(bool)>& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   // This can occur if the GalleryWatchManager attempts to watch the same path
   // again before recieving the callback. It's benign.
   if (base::ContainsKey(watchers_, path)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE, base::Bind(callback, false));
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::BindOnce(callback, false));
     return;
   }
 
   linked_ptr<base::FilePathWatcher> watcher(new base::FilePathWatcher);
   bool success = watcher->Watch(path,
                                 true /*recursive*/,
                                 base::Bind(&FileWatchManager::OnFilePathChanged,
                                            weak_factory_.GetWeakPtr()));
 
   if (success)
     watchers_[path] = watcher;
 
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE, base::Bind(callback, success));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::BindOnce(callback, success));
 }
 
 void GalleryWatchManager::FileWatchManager::RemoveFileWatch(
     const base::FilePath& path) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   size_t erased = watchers_.erase(path);
   DCHECK_EQ(erased, 1u);
 }
 
 base::WeakPtr<GalleryWatchManager::FileWatchManager>
 GalleryWatchManager::FileWatchManager::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 void GalleryWatchManager::FileWatchManager::OnFilePathChanged(
     const base::FilePath& path,
     bool error) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (error)
     RemoveFileWatch(path);
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE, base::Bind(callback_, path, error));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::BindOnce(callback_, path, error));
 }
 
 GalleryWatchManager::WatchOwner::WatchOwner(BrowserContext* browser_context,
                                             const std::string& extension_id,
                                             MediaGalleryPrefId gallery_id)
     : browser_context(browser_context),
       extension_id(extension_id),
       gallery_id(gallery_id) {
 }
 
@@ skipping 121 matching lines @@
   // Start the FilePathWatcher on |gallery_path| if necessary.
   if (base::ContainsKey(watched_paths_, path)) {
     OnFileWatchActivated(owner, path, callback, true);
   } else {
     base::Callback<void(bool)> on_watch_added =
         base::Bind(&GalleryWatchManager::OnFileWatchActivated,
                    weak_factory_.GetWeakPtr(),
                    owner,
                    path,
                    callback);
-    BrowserThread::PostTask(BrowserThread::FILE,
-                            FROM_HERE,
-                            base::Bind(&FileWatchManager::AddFileWatch,
-                                       watch_manager_->GetWeakPtr(),
-                                       path,
-                                       on_watch_added));
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+        base::BindOnce(&FileWatchManager::AddFileWatch,
+                       watch_manager_->GetWeakPtr(), path, on_watch_added));
   }
 }
 
 void GalleryWatchManager::RemoveWatch(BrowserContext* browser_context,
                                       const std::string& extension_id,
                                       MediaGalleryPrefId gallery_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(browser_context);
 
   WatchOwner owner(browser_context, extension_id, gallery_id);
@@ skipping 53 matching lines @@
 void GalleryWatchManager::DeactivateFileWatch(const WatchOwner& owner,
                                               const base::FilePath& path) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   WatchedPaths::iterator it = watched_paths_.find(path);
   if (it == watched_paths_.end())
     return;
 
   it->second.owners.erase(owner);
   if (it->second.owners.empty()) {
     watched_paths_.erase(it);
-    BrowserThread::PostTask(BrowserThread::FILE,
-                            FROM_HERE,
-                            base::Bind(&FileWatchManager::RemoveFileWatch,
-                                       watch_manager_->GetWeakPtr(),
-                                       path));
+    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+                            base::BindOnce(&FileWatchManager::RemoveFileWatch,
+                                           watch_manager_->GetWeakPtr(), path));
   }
 }
 
 void GalleryWatchManager::OnFileWatchActivated(const WatchOwner& owner,
                                                const base::FilePath& path,
                                                const ResultCallback& callback,
                                                bool success) {
   if (success) {
     // |watched_paths_| doesn't necessarily to contain |path| yet.
     // In that case, it calls the default constructor for NotificationInfo.
@@ skipping 31 matching lines @@
       base::Time::Now() - notification_info->second.last_notify_time;
   if (time_since_last_notify <
       base::TimeDelta::FromSeconds(kMinNotificationDelayInSeconds)) {
     if (!notification_info->second.delayed_notification_pending) {
       notification_info->second.delayed_notification_pending = true;
       base::TimeDelta delay_to_next_valid_time =
           notification_info->second.last_notify_time +
           base::TimeDelta::FromSeconds(kMinNotificationDelayInSeconds) -
           base::Time::Now();
       BrowserThread::PostDelayedTask(
-          BrowserThread::UI,
-          FROM_HERE,
-          base::Bind(&GalleryWatchManager::OnFilePathChanged,
-                     weak_factory_.GetWeakPtr(),
-                     path,
-                     error),
+          BrowserThread::UI, FROM_HERE,
+          base::BindOnce(&GalleryWatchManager::OnFilePathChanged,
+                         weak_factory_.GetWeakPtr(), path, error),
           delay_to_next_valid_time);
     }
     return;
   }
   notification_info->second.delayed_notification_pending = false;
   notification_info->second.last_notify_time = base::Time::Now();
 
   std::set<WatchOwner>::const_iterator it;
   for (it = notification_info->second.owners.begin();
        it != notification_info->second.owners.end();
@@ skipping 50 matching lines @@
       DeactivateFileWatch(owner, it->second);
       // Post increment moves iterator to next element while deleting current.
       watches_.erase(it++);
       observers_[preferences->profile()]->OnGalleryWatchDropped(
           owner.extension_id, owner.gallery_id);
     } else {
       ++it;
     }
   }
 }