Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/{i,l,m,n,p,r}*

chrome/browser/pepper_flash_settings_manager.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/pepper_flash_settings_manager.h"
 
 #include <map>
 #include <utility>
 #include <vector>
 
@@ skipping 209 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 PepperFlashSettingsManager::Core::~Core() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 void PepperFlashSettingsManager::Core::Initialize() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&Core::InitializeOnIOThread, this));
+                          base::BindOnce(&Core::InitializeOnIOThread, this));
 }
 
 void PepperFlashSettingsManager::Core::Detach() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // This call guarantees that one ref is retained until we get to the DETACHED
   // state. This is important. Otherwise, if the ref count drops to zero on the
   // UI thread (which posts a task to delete this object on the I/O thread)
   // while the I/O thread doesn't know about it, methods on the I/O thread might
   // increase the ref count again and cause double deletion.
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE, base::Bind(&Core::DetachOnIOThread, this));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::BindOnce(&Core::DetachOnIOThread, this));
 }
 
 void PepperFlashSettingsManager::Core::DeauthorizeContentLicenses(
     uint32_t request_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&Core::DeauthorizeContentLicensesOnIOThread, this,
-                 request_id));
+      base::BindOnce(&Core::DeauthorizeContentLicensesOnIOThread, this,
+                     request_id));
 }
 
 void PepperFlashSettingsManager::Core::GetPermissionSettings(
     uint32_t request_id,
     PP_Flash_BrowserOperations_SettingType setting_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&Core::GetPermissionSettingsOnIOThread, this, request_id,
-                 setting_type));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::BindOnce(&Core::GetPermissionSettingsOnIOThread,
+                                         this, request_id, setting_type));
 }
 
 void PepperFlashSettingsManager::Core::SetDefaultPermission(
     uint32_t request_id,
     PP_Flash_BrowserOperations_SettingType setting_type,
     PP_Flash_BrowserOperations_Permission permission,
     bool clear_site_specific) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&Core::SetDefaultPermissionOnIOThread, this, request_id,
-                 setting_type, permission, clear_site_specific));
+      base::BindOnce(&Core::SetDefaultPermissionOnIOThread, this, request_id,
+                     setting_type, permission, clear_site_specific));
 }
 
 void PepperFlashSettingsManager::Core::SetSitePermission(
     uint32_t request_id,
     PP_Flash_BrowserOperations_SettingType setting_type,
     const ppapi::FlashSiteSettings& sites) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&Core::SetSitePermissionOnIOThread, this, request_id,
-                 setting_type, sites));
+      base::BindOnce(&Core::SetSitePermissionOnIOThread, this, request_id,
+                     setting_type, sites));
 }
 
 void PepperFlashSettingsManager::Core::GetSitesWithData(uint32_t request_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&Core::GetSitesWithDataOnIOThread, this, request_id));
+      base::BindOnce(&Core::GetSitesWithDataOnIOThread, this, request_id));
 }
 
 void PepperFlashSettingsManager::Core::ClearSiteData(uint32_t request_id,
                                                      const std::string& site,
                                                      uint64_t flags,
                                                      uint64_t max_age) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&Core::ClearSiteDataOnIOThread, this, request_id,
-                 site, flags, max_age));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::BindOnce(&Core::ClearSiteDataOnIOThread, this,
+                                         request_id, site, flags, max_age));
 }
 
 bool PepperFlashSettingsManager::Core::OnMessageReceived(
     const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(Core, message)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_DeauthorizeContentLicensesResult,
                         OnDeauthorizeContentLicensesResult)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_GetPermissionSettingsResult,
                         OnGetPermissionSettingsResult)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_SetDefaultPermissionResult,
@@ skipping 140 matching lines @@
     uint32_t request_id,
     const base::FilePath& profile_path) {
   // ChromeOS used to store the device ID in a file but this is no longer used.
   // Wipe that file.
   const base::FilePath& device_id_path =
       chrome::DeviceIDFetcher::GetLegacyDeviceIDPath(profile_path);
   bool success = base::DeleteFile(device_id_path, false);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&Core::DeauthorizeContentLicensesInPlugin, this, request_id,
-                 success));
+      base::BindOnce(&Core::DeauthorizeContentLicensesInPlugin, this,
+                     request_id, success));
 }
 
 void PepperFlashSettingsManager::Core::DeauthorizeContentLicensesInPlugin(
     uint32_t request_id,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!success) {
     NotifyErrorFromIOThread();
     return;
   }
@@ skipping 187 matching lines @@
        iter != pending_requests_.end(); ++iter) {
     notifications.push_back(std::make_pair(iter->id, iter->type));
   }
   pending_requests_.clear();
   notifications.insert(notifications.end(), pending_responses_.begin(),
                        pending_responses_.end());
   pending_responses_.clear();
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&Core::NotifyError, this, notifications));
+      base::BindOnce(&Core::NotifyError, this, notifications));
 }
 
 void PepperFlashSettingsManager::Core::
     NotifyDeauthorizeContentLicensesCompleted(uint32_t request_id,
                                               bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (manager_.get()) {
     manager_->client_->OnDeauthorizeFlashContentLicensesCompleted(request_id,
                                                                   success);
@@ skipping 114 matching lines @@
   std::map<uint32_t, RequestType>::iterator iter =
       pending_responses_.find(request_id);
   if (iter == pending_responses_.end())
     return;
 
   DCHECK_EQ(iter->second, DEAUTHORIZE_CONTENT_LICENSES);
 
   pending_responses_.erase(iter);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&Core::NotifyDeauthorizeContentLicensesCompleted, this,
-                 request_id, success));
+      base::BindOnce(&Core::NotifyDeauthorizeContentLicensesCompleted, this,
+                     request_id, success));
 }
 
 void PepperFlashSettingsManager::Core::OnGetPermissionSettingsResult(
     uint32_t request_id,
     bool success,
     PP_Flash_BrowserOperations_Permission default_permission,
     const ppapi::FlashSiteSettings& sites) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (state_ == STATE_DETACHED)
     return;
 
   DLOG_IF(ERROR, !success) << "GetPermissionSettings returned error";
 
   std::map<uint32_t, RequestType>::iterator iter =
       pending_responses_.find(request_id);
   if (iter == pending_responses_.end())
     return;
 
   DCHECK_EQ(iter->second, GET_PERMISSION_SETTINGS);
 
   pending_responses_.erase(iter);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&Core::NotifyGetPermissionSettingsCompleted, this,
-                 request_id, success, default_permission, sites));
+      base::BindOnce(&Core::NotifyGetPermissionSettingsCompleted, this,
+                     request_id, success, default_permission, sites));
 }
 
 void PepperFlashSettingsManager::Core::OnSetDefaultPermissionResult(
     uint32_t request_id,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (state_ == STATE_DETACHED)
     return;
 
   DLOG_IF(ERROR, !success) << "SetDefaultPermission returned error";
 
   std::map<uint32_t, RequestType>::iterator iter =
       pending_responses_.find(request_id);
   if (iter == pending_responses_.end())
     return;
 
   DCHECK_EQ(iter->second, SET_DEFAULT_PERMISSION);
 
   pending_responses_.erase(iter);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&Core::NotifySetDefaultPermissionCompleted, this,
-                 request_id, success));
+      base::BindOnce(&Core::NotifySetDefaultPermissionCompleted, this,
+                     request_id, success));
 }
 
 void PepperFlashSettingsManager::Core::OnSetSitePermissionResult(
     uint32_t request_id,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (state_ == STATE_DETACHED)
     return;
 
   DLOG_IF(ERROR, !success) << "SetSitePermission returned error";
 
   std::map<uint32_t, RequestType>::iterator iter =
       pending_responses_.find(request_id);
   if (iter == pending_responses_.end())
     return;
 
   DCHECK_EQ(iter->second, SET_SITE_PERMISSION);
 
   pending_responses_.erase(iter);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&Core::NotifySetSitePermissionCompleted, this, request_id,
-      success));
+      base::BindOnce(&Core::NotifySetSitePermissionCompleted, this, request_id,
+                     success));
 }
 
 void PepperFlashSettingsManager::Core::OnGetSitesWithDataResult(
     uint32_t request_id,
     const std::vector<std::string>& sites) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (state_ == STATE_DETACHED)
     return;
 
   std::map<uint32_t, RequestType>::iterator iter =
       pending_responses_.find(request_id);
   if (iter == pending_responses_.end())
     return;
 
   DCHECK_EQ(iter->second, GET_SITES_WITH_DATA);
 
   pending_responses_.erase(iter);
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&Core::NotifyGetSitesWithDataCompleted, this, request_id,
-      sites));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::BindOnce(&Core::NotifyGetSitesWithDataCompleted,
+                                         this, request_id, sites));
 }
 
 void PepperFlashSettingsManager::Core::OnClearSiteDataResult(
     uint32_t request_id,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (state_ == STATE_DETACHED)
     return;
 
   DLOG_IF(ERROR, !success) << "ClearSiteData returned error";
 
   std::map<uint32_t, RequestType>::iterator iter =
       pending_responses_.find(request_id);
   if (iter == pending_responses_.end())
     return;
 
   DCHECK_EQ(iter->second, CLEAR_SITE_DATA);
 
   pending_responses_.erase(iter);
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&Core::NotifyClearSiteDataCompleted, this, request_id,
-      success));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::BindOnce(&Core::NotifyClearSiteDataCompleted,
+                                         this, request_id, success));
 }
 
 PepperFlashSettingsManager::PepperFlashSettingsManager(
     Client* client,
     content::BrowserContext* browser_context)
     : client_(client),
       browser_context_(browser_context),
       next_request_id_(1),
       weak_ptr_factory_(this) {
   DCHECK(client);
@@ skipping 116 matching lines @@
 }
 
 void PepperFlashSettingsManager::OnError(Core* core) {
   DCHECK(core);
   if (core != core_.get())
     return;
 
   core_->Detach();
   core_ = NULL;
 }