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

chrome/browser/extensions/api/cookies/cookies_api.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.
 
 // Implements the Chrome Extensions Cookies API.
 
 #include "chrome/browser/extensions/api/cookies/cookies_api.h"
 
 #include <memory>
 #include <utility>
@@ skipping 210 matching lines @@
   if (!ParseStoreContext(this, &store_id, &store_context))
     return false;
   store_browser_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
   store_browser_context_ = store_context;
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CookiesGetFunction::GetCookieOnIOThread, this));
+      base::BindOnce(&CookiesGetFunction::GetCookieOnIOThread, this));
   DCHECK(rv);
 
   // Will finish asynchronously.
   return true;
 }
 
 void CookiesGetFunction::GetCookieOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::CookieStore* cookie_store =
       store_browser_context_->GetURLRequestContext()->cookie_store();
@@ skipping 14 matching lines @@
       break;
     }
   }
 
   // The cookie doesn't exist; return null.
   if (!results_)
     SetResult(base::MakeUnique<base::Value>());
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&CookiesGetFunction::RespondOnUIThread, this));
+      base::BindOnce(&CookiesGetFunction::RespondOnUIThread, this));
   DCHECK(rv);
 }
 
 void CookiesGetFunction::RespondOnUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SendResponse(true);
 }
 
 CookiesGetAllFunction::CookiesGetAllFunction() {
 }
@@ skipping 15 matching lines @@
                                            : std::string();
   net::URLRequestContextGetter* store_context = NULL;
   if (!ParseStoreContext(this, &store_id, &store_context))
     return false;
   store_browser_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CookiesGetAllFunction::GetAllCookiesOnIOThread, this));
+      base::BindOnce(&CookiesGetAllFunction::GetAllCookiesOnIOThread, this));
   DCHECK(rv);
 
   // Will finish asynchronously.
   return true;
 }
 
 void CookiesGetAllFunction::GetAllCookiesOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::CookieStore* cookie_store =
       store_browser_context_->GetURLRequestContext()->cookie_store();
   cookies_helpers::GetCookieListFromStore(
       cookie_store, url_,
       base::Bind(&CookiesGetAllFunction::GetAllCookiesCallback, this));
 }
 
 void CookiesGetAllFunction::GetAllCookiesCallback(
     const net::CookieList& cookie_list) {
   if (extension()) {
     std::vector<cookies::Cookie> match_vector;
     cookies_helpers::AppendMatchingCookiesToVector(
         cookie_list, url_, &parsed_args_->details, extension(), &match_vector);
 
     results_ = GetAll::Results::Create(match_vector);
   }
   bool rv = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&CookiesGetAllFunction::RespondOnUIThread, this));
+      base::BindOnce(&CookiesGetAllFunction::RespondOnUIThread, this));
   DCHECK(rv);
 }
 
 void CookiesGetAllFunction::RespondOnUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SendResponse(true);
 }
 
 CookiesSetFunction::CookiesSetFunction() : success_(false) {
 }
@@ skipping 14 matching lines @@
                                            : std::string();
   net::URLRequestContextGetter* store_context = NULL;
   if (!ParseStoreContext(this, &store_id, &store_context))
     return false;
   store_browser_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CookiesSetFunction::SetCookieOnIOThread, this));
+      base::BindOnce(&CookiesSetFunction::SetCookieOnIOThread, this));
   DCHECK(rv);
 
   // Will finish asynchronously.
   return true;
 }
 
 void CookiesSetFunction::SetCookieOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::CookieStore* cookie_store =
       store_browser_context_->GetURLRequestContext()->cookie_store();
@@ skipping 66 matching lines @@
     if (cookie.Name() == name) {
       cookies::Cookie api_cookie = cookies_helpers::CreateCookie(
           cookie, *parsed_args_->details.store_id);
       results_ = Set::Results::Create(api_cookie);
       break;
     }
   }
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&CookiesSetFunction::RespondOnUIThread, this));
+      base::BindOnce(&CookiesSetFunction::RespondOnUIThread, this));
   DCHECK(rv);
 }
 
 void CookiesSetFunction::RespondOnUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!success_) {
     std::string name =
         parsed_args_->details.name.get() ? *parsed_args_->details.name
                                          : std::string();
     error_ = ErrorUtils::FormatErrorMessage(keys::kCookieSetFailedError, name);
@@ skipping 21 matching lines @@
   net::URLRequestContextGetter* store_context = NULL;
   if (!ParseStoreContext(this, &store_id, &store_context))
     return false;
   store_browser_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
   // Pass the work off to the IO thread.
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CookiesRemoveFunction::RemoveCookieOnIOThread, this));
+      base::BindOnce(&CookiesRemoveFunction::RemoveCookieOnIOThread, this));
   DCHECK(rv);
 
   // Will return asynchronously.
   return true;
 }
 
 void CookiesRemoveFunction::RemoveCookieOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Remove the cookie
   net::CookieStore* cookie_store =
       store_browser_context_->GetURLRequestContext()->cookie_store();
   cookie_store->DeleteCookieAsync(
       url_, parsed_args_->details.name,
       base::Bind(&CookiesRemoveFunction::RemoveCookieCallback, this));
 }
 
 void CookiesRemoveFunction::RemoveCookieCallback() {
   // Build the callback result
   Remove::Results::Details details;
   details.name = parsed_args_->details.name;
   details.url = url_.spec();
   details.store_id = *parsed_args_->details.store_id;
   results_ = Remove::Results::Create(details);
 
   // Return to UI thread
   bool rv = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&CookiesRemoveFunction::RespondOnUIThread, this));
+      base::BindOnce(&CookiesRemoveFunction::RespondOnUIThread, this));
   DCHECK(rv);
 }
 
 void CookiesRemoveFunction::RespondOnUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SendResponse(true);
 }
 
 ExtensionFunction::ResponseAction CookiesGetAllCookieStoresFunction::Run() {
   Profile* original_profile = Profile::FromBrowserContext(browser_context());
@@ skipping 55 matching lines @@
 BrowserContextKeyedAPIFactory<CookiesAPI>* CookiesAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void CookiesAPI::OnListenerAdded(const EventListenerInfo& details) {
   cookies_event_router_.reset(new CookiesEventRouter(browser_context_));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions