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

chrome/browser/extensions/extension_storage_monitor.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/extensions/extension_storage_monitor.h"
 
 #include <map>
 #include <utility>
 
 #include "base/metrics/histogram_macros.h"
@@ skipping 216 matching lines @@
     StorageState& state = iter->second;
 
     if (state.should_uma) {
       if (event.filter.storage_type == storage::kStorageTypePersistent) {
         UMA_HISTOGRAM_MEMORY_KB(
             "Extensions.HostedAppUnlimitedStoragePersistentStorageUsage",
             event.usage);
       } else {
         // We can't use the quota in the event because it assumes unlimited
         // storage.
-        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                                base::Bind(&LogTemporaryStorageUsage,
-                                           state.quota_manager, event.usage));
+        BrowserThread::PostTask(
+            BrowserThread::IO, FROM_HERE,
+            base::BindOnce(&LogTemporaryStorageUsage, state.quota_manager,
+                           event.usage));
       }
     }
 
     if (state.next_threshold != -1 &&
         event.usage >= state.next_threshold) {
       while (event.usage >= state.next_threshold)
         state.next_threshold *= 2;
 
       BrowserThread::PostTask(
-          BrowserThread::UI,
-          FROM_HERE,
-          base::Bind(&ExtensionStorageMonitor::OnStorageThresholdExceeded,
-                     storage_monitor_,
-                     state.extension_id,
-                     state.next_threshold,
-                     event.usage));
+          BrowserThread::UI, FROM_HERE,
+          base::BindOnce(&ExtensionStorageMonitor::OnStorageThresholdExceeded,
+                         storage_monitor_, state.extension_id,
+                         state.next_threshold, event.usage));
     }
   }
 
   OriginStorageStateMap origin_state_map_;
   base::WeakPtr<ExtensionStorageMonitor> storage_monitor_;
 };
 
 // ExtensionStorageMonitor
 
 // static
@@ skipping 61 matching lines @@
 
   int64_t next_threshold = GetNextStorageThresholdFromPrefs(extension->id());
   if (next_threshold <= initial_extension_threshold_) {
     // Clear the next threshold in the prefs. This effectively raises it to
     // |initial_extension_threshold_|. If the current threshold is already
     // higher than this, leave it as is.
     SetNextStorageThreshold(extension->id(), 0);
 
     if (storage_observer_.get()) {
       BrowserThread::PostTask(
-          BrowserThread::IO,
-          FROM_HERE,
-          base::Bind(&StorageEventObserver::UpdateThresholdForExtension,
-                     storage_observer_,
-                     extension->id(),
-                     initial_extension_threshold_));
+          BrowserThread::IO, FROM_HERE,
+          base::BindOnce(&StorageEventObserver::UpdateThresholdForExtension,
+                         storage_observer_, extension->id(),
+                         initial_extension_threshold_));
     }
   }
 }
 
 void ExtensionStorageMonitor::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const Extension* extension,
     extensions::UninstallReason reason) {
   RemoveNotificationForExtension(extension->id());
 }
@@ skipping 150 matching lines @@
 
   GURL storage_origin(site_url.GetOrigin());
   if (extension->is_hosted_app())
     storage_origin = AppLaunchInfo::GetLaunchWebURL(extension).GetOrigin();
 
   // Don't give a threshold if we're not enforcing.
   int next_threshold =
       should_enforce ? GetNextStorageThreshold(extension->id()) : -1;
 
   BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&StorageEventObserver::StartObservingForExtension,
-                 storage_observer_,
-                 quota_manager,
-                 extension->id(),
-                 storage_origin,
-                 next_threshold,
-                 observer_rate_,
-                 for_metrics));
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&StorageEventObserver::StartObservingForExtension,
+                     storage_observer_, quota_manager, extension->id(),
+                     storage_origin, next_threshold, observer_rate_,
+                     for_metrics));
 }
 
 void ExtensionStorageMonitor::StopMonitoringStorage(
     const std::string& extension_id) {
   if (!storage_observer_.get())
     return;
 
   BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&StorageEventObserver::StopObservingForExtension,
-                 storage_observer_,
-                 extension_id));
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&StorageEventObserver::StopObservingForExtension,
+                     storage_observer_, extension_id));
 }
 
 void ExtensionStorageMonitor::StopMonitoringAll() {
   extension_registry_observer_.RemoveAll();
 
   RemoveAllNotifications();
 
   if (!storage_observer_.get())
     return;
 
   BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&StorageEventObserver::StopObserving, storage_observer_));
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&StorageEventObserver::StopObserving, storage_observer_));
   storage_observer_ = NULL;
 }
 
 void ExtensionStorageMonitor::RemoveNotificationForExtension(
     const std::string& extension_id) {
   std::set<std::string>::iterator ext_id =
       notified_extension_ids_.find(extension_id);
   if (ext_id == notified_extension_ids_.end())
     return;
 
@@ skipping 82 matching lines @@
 
 void ExtensionStorageMonitor::SetStorageNotificationEnabled(
     const std::string& extension_id,
     bool enable_notifications) {
   extension_prefs_->UpdateExtensionPref(
       extension_id, kPrefDisableStorageNotifications,
       enable_notifications ? nullptr : base::MakeUnique<base::Value>(true));
 }
 
 }  // namespace extensions