Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/{a,b,c,d,e,f,g}*

chrome/browser/custom_handlers/protocol_handler_registry.cc

 // 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.
 
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 337 matching lines @@
       replaced_handlers.push_back(*p);
     }
   }
   return replaced_handlers;
 }
 
 void ProtocolHandlerRegistry::ClearDefault(const std::string& scheme) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   default_handlers_.erase(scheme);
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&IOThreadDelegate::ClearDefault, io_thread_delegate_, scheme));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::BindOnce(&IOThreadDelegate::ClearDefault,
+                                         io_thread_delegate_, scheme));
   Save();
   NotifyChanged();
 }
 
 bool ProtocolHandlerRegistry::IsDefault(
     const ProtocolHandler& handler) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return GetHandlerFor(handler.protocol()) == handler;
 }
 
@@ skipping 209 matching lines @@
   }
   ProtocolHandlerMap::iterator q = default_handlers_.find(handler.protocol());
   if (erase_success && q != default_handlers_.end() && q->second == handler) {
     // Make the new top handler in the list the default.
     if (!handlers.empty()) {
       // NOTE We pass a copy because SetDefault() modifies handlers.
       SetDefault(ProtocolHandler(handlers[0]));
     } else {
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
-          base::Bind(&IOThreadDelegate::ClearDefault, io_thread_delegate_,
-                     q->second.protocol()));
+          base::BindOnce(&IOThreadDelegate::ClearDefault, io_thread_delegate_,
+                         q->second.protocol()));
 
       default_handlers_.erase(q);
     }
   }
 
   if (erase_success && !IsHandledProtocol(handler.protocol())) {
     delegate_->DeregisterExternalHandler(handler.protocol());
   }
   Save();
   if (erase_success)
@@ skipping 13 matching lines @@
   return LookupHandler(default_handlers_, scheme);
 }
 
 void ProtocolHandlerRegistry::Enable() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (enabled_) {
     return;
   }
   enabled_ = true;
   BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&IOThreadDelegate::Enable, io_thread_delegate_));
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&IOThreadDelegate::Enable, io_thread_delegate_));
 
   ProtocolHandlerMap::const_iterator p;
   for (p = default_handlers_.begin(); p != default_handlers_.end(); ++p) {
     delegate_->RegisterExternalHandler(p->first);
   }
   Save();
   NotifyChanged();
 }
 
 void ProtocolHandlerRegistry::Disable() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!enabled_) {
     return;
   }
   enabled_ = false;
   BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&IOThreadDelegate::Disable, io_thread_delegate_));
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&IOThreadDelegate::Disable, io_thread_delegate_));
 
   ProtocolHandlerMap::const_iterator p;
   for (p = default_handlers_.begin(); p != default_handlers_.end(); ++p) {
     delegate_->DeregisterExternalHandler(p->first);
   }
   Save();
   NotifyChanged();
 }
 
 void ProtocolHandlerRegistry::Shutdown() {
@@ skipping 60 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ProtocolHandlerMap::const_iterator p = default_handlers_.find(
       handler.protocol());
   // If we're not loading, and we are setting a default for a new protocol,
   // register with the OS.
   if (!is_loading_ && p == default_handlers_.end())
       delegate_->RegisterWithOSAsDefaultClient(handler.protocol(), this);
   default_handlers_.erase(handler.protocol());
   default_handlers_.insert(std::make_pair(handler.protocol(), handler));
   PromoteHandler(handler);
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&IOThreadDelegate::SetDefault, io_thread_delegate_, handler));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::BindOnce(&IOThreadDelegate::SetDefault,
+                                         io_thread_delegate_, handler));
 }
 
 void ProtocolHandlerRegistry::InsertHandler(const ProtocolHandler& handler) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ProtocolHandlerMultiMap::iterator p =
       protocol_handlers_.find(handler.protocol());
 
   if (p != protocol_handlers_.end()) {
     p->second.push_back(handler);
     return;
@@ skipping 175 matching lines @@
 
 std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
 ProtocolHandlerRegistry::CreateJobInterceptorFactory() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // this is always created on the UI thread (in profile_io's
   // InitializeOnUIThread. Any method calls must be done
   // on the IO thread (this is checked).
   return std::unique_ptr<JobInterceptorFactory>(
       new JobInterceptorFactory(io_thread_delegate_.get()));
 }