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

chrome/browser/gcm/fake_gcm_profile_service.cc

 // Copyright 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/gcm/fake_gcm_profile_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 86 matching lines @@
     return;  // Drop request.
 
   // Generate fake registration IDs, encoding the number of sender IDs (used by
   // GcmApiTest.RegisterValidation), then an incrementing count (even for the
   // same app_id - there's no caching) so tests can distinguish registrations.
   std::string registration_id = base::StringPrintf(
       "%" PRIuS "-%d", sender_ids.size(), registration_count_);
   ++registration_count_;
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&CustomFakeGCMDriver::DoRegister, weak_factory_.GetWeakPtr(),
-                 app_id, sender_ids, registration_id));
+      FROM_HERE, base::BindOnce(&CustomFakeGCMDriver::DoRegister,
+                                weak_factory_.GetWeakPtr(), app_id, sender_ids,
+                                registration_id));
 }
 
 void FakeGCMProfileService::CustomFakeGCMDriver::DoRegister(
     const std::string& app_id,
     const std::vector<std::string>& sender_ids,
     const std::string& registration_id) {
   if (service_->collect_) {
     service_->last_registered_app_id_ = app_id;
     service_->last_registered_sender_ids_ = sender_ids;
   }
   RegisterFinished(app_id, registration_id, GCMClient::SUCCESS);
 }
 
 void FakeGCMProfileService::CustomFakeGCMDriver::UnregisterImpl(
     const std::string& app_id) {
   if (service_->is_offline_)
     return;  // Drop request.
 
   GCMClient::Result result = GCMClient::SUCCESS;
   if (!service_->unregister_responses_.empty()) {
     result = service_->unregister_responses_.front();
     service_->unregister_responses_.pop_front();
   }
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&CustomFakeGCMDriver::UnregisterFinished,
-                            weak_factory_.GetWeakPtr(), app_id, result));
+      FROM_HERE, base::BindOnce(&CustomFakeGCMDriver::UnregisterFinished,
+                                weak_factory_.GetWeakPtr(), app_id, result));
 }
 
 void FakeGCMProfileService::CustomFakeGCMDriver::UnregisterWithSenderIdImpl(
     const std::string& app_id,
     const std::string& sender_id) {
   NOTREACHED() << "This Android-specific method is not yet faked.";
 }
 
 void FakeGCMProfileService::CustomFakeGCMDriver::SendImpl(
     const std::string& app_id,
     const std::string& receiver_id,
     const OutgoingMessage& message) {
   if (service_->is_offline_)
     return;  // Drop request.
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
-      base::Bind(&CustomFakeGCMDriver::DoSend, weak_factory_.GetWeakPtr(),
-                 app_id, receiver_id, message));
+      base::BindOnce(&CustomFakeGCMDriver::DoSend, weak_factory_.GetWeakPtr(),
+                     app_id, receiver_id, message));
 }
 
 void FakeGCMProfileService::CustomFakeGCMDriver::DoSend(
     const std::string& app_id,
     const std::string& receiver_id,
     const OutgoingMessage& message) {
   if (service_->collect_) {
     service_->last_sent_message_ = message;
     service_->last_receiver_id_ = receiver_id;
   }
@@ skipping 51 matching lines @@
 }
 
 void FakeGCMProfileService::DispatchMessage(const std::string& app_id,
                                             const IncomingMessage& message) {
   CustomFakeGCMDriver* custom_driver =
       static_cast<CustomFakeGCMDriver*>(driver());
   custom_driver->OnDispatchMessage(app_id, message);
 }
 
 }  // namespace gcm