mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 2

Part I: Move from base::Bind to base::BindOnce and remove unneeded base::Passed (#12661)

Browse source
This commit is contained in:
Robo 2018-04-20 16:25:05 +05:30 • committed by Cheng Zhao
parent fcc82ebd35
commit ff571f3b5d
26 changed files with 143 additions and 135 deletions
Download patch file Download diff file Expand all files Collapse all files

4
atom/browser/api/atom_api_app.cc
View file

@ -431,8 +431,8 @@ bool NotificationCallbackWrapper(
} else {
scoped_refptr<base::SingleThreadTaskRunner> task_runner(
base::ThreadTaskRunnerHandle::Get());
task_runner->PostTask(FROM_HERE,
base::Bind(base::IgnoreResult(callback), cmd, cwd));
task_runner->PostTask(
FROM_HERE, base::BindOnce(base::IgnoreResult(callback), cmd, cwd));
}
// ProcessSingleton needs to know whether current process is quiting.
return !Browser::Get()->is_shutting_down();

2
atom/browser/api/atom_api_browser_window.cc
View file

@ -141,7 +141,7 @@ void BrowserWindow::DidFirstVisuallyNonEmptyPaint() {
// Emit the ReadyToShow event in next tick in case of pending drawing work.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(
FROM_HERE, base::BindOnce(
[](base::WeakPtr<BrowserWindow> self) {
if (self)
self->Emit("ready-to-show");

14
atom/browser/api/atom_api_cookies.cc
View file

@ -174,7 +174,7 @@ void RemoveCookieOnIOThread(scoped_refptr<net::URLRequestContextGetter> getter,
const std::string& name,
const base::Closure& callback) {
GetCookieStore(getter)->DeleteCookieAsync(
url, name, base::Bind(RunCallbackInUI, callback));
url, name, base::BindOnce(RunCallbackInUI, callback));
}
// Callback of SetCookie.
@ -187,7 +187,7 @@ void OnSetCookie(const Cookies::SetCallback& callback, bool success) {
void FlushCookieStoreOnIOThread(
scoped_refptr<net::URLRequestContextGetter> getter,
const base::Closure& callback) {
GetCookieStore(getter)->FlushStore(base::Bind(RunCallbackInUI, callback));
GetCookieStore(getter)->FlushStore(base::BindOnce(RunCallbackInUI, callback));
}
// Sets cookie with |details| in IO thread.
@ -232,7 +232,7 @@ void SetCookieOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
GetCookieStore(getter)->SetCookieWithDetailsAsync(
GURL(url), name, value, domain, path, creation_time, expiration_time,
last_access_time, secure, http_only, net::CookieSameSite::DEFAULT_MODE,
net::COOKIE_PRIORITY_DEFAULT, base::Bind(OnSetCookie, callback));
net::COOKIE_PRIORITY_DEFAULT, base::BindOnce(OnSetCookie, callback));
}
} // namespace
@ -253,8 +253,8 @@ void Cookies::Get(const base::DictionaryValue& filter,
auto* getter = browser_context_->GetRequestContext();
content::BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::BindOnce(GetCookiesOnIO, base::RetainedRef(getter), Passed(&copied),
callback));
base::BindOnce(GetCookiesOnIO, base::RetainedRef(getter),
std::move(copied), callback));
}
void Cookies::Remove(const GURL& url,
@ -273,8 +273,8 @@ void Cookies::Set(const base::DictionaryValue& details,
auto* getter = browser_context_->GetRequestContext();
content::BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::BindOnce(SetCookieOnIO, base::RetainedRef(getter), Passed(&copied),
callback));
base::BindOnce(SetCookieOnIO, base::RetainedRef(getter),
std::move(copied), callback));
}
void Cookies::FlushStore(const base::Closure& callback) {

47
atom/browser/api/atom_api_session.cc
View file

@ -244,15 +244,15 @@ class ResolveProxyHelper {
scoped_refptr<net::URLRequestContextGetter> context_getter =
browser_context->url_request_context_getter();
context_getter->GetNetworkTaskRunner()->PostTask(
FROM_HERE, base::Bind(&ResolveProxyHelper::ResolveProxy,
base::Unretained(this), context_getter, url));
FROM_HERE, base::BindOnce(&ResolveProxyHelper::ResolveProxy,
base::Unretained(this), context_getter, url));
}
void OnResolveProxyCompleted(int result) {
std::string proxy;
if (result == net::OK)
proxy = proxy_info_.ToPacString();
original_thread_->PostTask(FROM_HERE, base::Bind(callback_, proxy));
original_thread_->PostTask(FROM_HERE, base::BindOnce(callback_, proxy));
delete this;
}
@ -291,7 +291,7 @@ void RunCallbackInUI(const base::Callback<void()>& callback) {
template <typename... T>
void RunCallbackInUI(const base::Callback<void(T...)>& callback, T... result) {
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(callback, result...));
base::BindOnce(callback, result...));
}
// Callback of HttpCache::GetBackend.
@ -529,9 +529,9 @@ template <Session::CacheAction action>
void Session::DoCacheAction(const net::CompletionCallback& callback) {
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&DoCacheActionInIO,
WrapRefCounted(browser_context_->GetRequestContext()), action,
callback));
base::BindOnce(&DoCacheActionInIO,
WrapRefCounted(browser_context_->GetRequestContext()),
action, callback));
}
void Session::ClearStorageData(mate::Arguments* args) {
@ -592,7 +592,7 @@ void Session::EnableNetworkEmulation(const mate::Dictionary& options) {
devtools_network_emulation_client_id_, std::move(conditions));
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(
base::BindOnce(
&SetDevToolsNetworkEmulationClientIdInIO,
base::RetainedRef(browser_context_->url_request_context_getter()),
devtools_network_emulation_client_id_));
@ -604,7 +604,7 @@ void Session::DisableNetworkEmulation() {
devtools_network_emulation_client_id_, std::move(conditions));
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(
base::BindOnce(
&SetDevToolsNetworkEmulationClientIdInIO,
base::RetainedRef(browser_context_->url_request_context_getter()),
std::string()));
@ -620,8 +620,9 @@ void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&SetCertVerifyProcInIO,
WrapRefCounted(browser_context_->GetRequestContext()), proc));
base::BindOnce(&SetCertVerifyProcInIO,
WrapRefCounted(browser_context_->GetRequestContext()),
proc));
}
void Session::SetPermissionRequestHandler(v8::Local<v8::Value> val,
@ -642,9 +643,9 @@ void Session::ClearHostResolverCache(mate::Arguments* args) {
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&ClearHostResolverCacheInIO,
WrapRefCounted(browser_context_->GetRequestContext()),
callback));
base::BindOnce(&ClearHostResolverCacheInIO,
WrapRefCounted(browser_context_->GetRequestContext()),
callback));
}
void Session::ClearAuthCache(mate::Arguments* args) {
@ -658,17 +659,17 @@ void Session::ClearAuthCache(mate::Arguments* args) {
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&ClearAuthCacheInIO,
WrapRefCounted(browser_context_->GetRequestContext()), options,
callback));
base::BindOnce(&ClearAuthCacheInIO,
WrapRefCounted(browser_context_->GetRequestContext()),
options, callback));
}
void Session::AllowNTLMCredentialsForDomains(const std::string& domains) {
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&AllowNTLMCredentialsForDomainsInIO,
WrapRefCounted(browser_context_->GetRequestContext()),
domains));
base::BindOnce(&AllowNTLMCredentialsForDomainsInIO,
WrapRefCounted(browser_context_->GetRequestContext()),
domains));
}
void Session::SetUserAgent(const std::string& user_agent,
@ -682,7 +683,7 @@ void Session::SetUserAgent(const std::string& user_agent,
browser_context_->GetRequestContext());
getter->GetNetworkTaskRunner()->PostTask(
FROM_HERE,
base::Bind(&SetUserAgentInIO, getter, accept_lang, user_agent));
base::BindOnce(&SetUserAgentInIO, getter, accept_lang, user_agent));
}
std::string Session::GetUserAgent() {
@ -697,8 +698,8 @@ void Session::GetBlobData(const std::string& uuid,
AtomBlobReader* blob_reader = browser_context()->GetBlobReader();
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&AtomBlobReader::StartReading, base::Unretained(blob_reader),
uuid, callback));
base::BindOnce(&AtomBlobReader::StartReading,
base::Unretained(blob_reader), uuid, callback));
}
void Session::CreateInterruptedDownload(const mate::Dictionary& options) {

3
atom/browser/api/atom_api_web_contents.cc
View file

@ -1363,7 +1363,8 @@ void WebContents::HasServiceWorker(const base::Callback<void(bool)>& callback) {
context->CheckHasServiceWorker(
web_contents()->GetLastCommittedURL(), GURL::EmptyGURL(),
base::Bind(&WrappedCallback::Run, base::Unretained(wrapped_callback)));
base::BindOnce(&WrappedCallback::Run,
base::Unretained(wrapped_callback)));
}
void WebContents::UnregisterServiceWorker(

6
atom/browser/api/atom_api_web_request.cc
View file

@ -100,9 +100,9 @@ void WebRequest::SetListener(Method method, Event type, mate::Arguments* args) {
return;
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CallNetworkDelegateMethod<Method, Event, Listener>,
base::RetainedRef(url_request_context_getter), method, type,
std::move(patterns), std::move(listener)));
base::BindOnce(&CallNetworkDelegateMethod<Method, Event, Listener>,
base::RetainedRef(url_request_context_getter), method,
type, std::move(patterns), std::move(listener)));
}
// static

2
atom/browser/api/event_subscriber.h
View file

@ -71,7 +71,7 @@ class EventSubscriber : internal::EventSubscriberBase {
ptr->handler_ = nullptr;
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(
base::BindOnce(
[](EventSubscriber<HandlerType>* subscriber) {
{
// It is possible that this function will execute in the UI

4
atom/browser/atom_blob_reader.cc
View file

@ -61,7 +61,7 @@ void AtomBlobReader::StartReading(
auto callback = base::Bind(&RunCallbackInUI, completion_callback);
if (!blob_data_handle) {
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(callback, nullptr, 0));
base::BindOnce(callback, nullptr, 0));
return;
}
@ -117,7 +117,7 @@ void AtomBlobReader::BlobReadHelper::DidReadBlobData(
char* data = new char[size];
memcpy(data, blob_data->data(), size);
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(completion_callback_, data, size));
base::BindOnce(completion_callback_, data, size));
delete this;
}

10
atom/browser/atom_download_manager_delegate.cc
View file

@ -43,7 +43,7 @@ void CreateDownloadPath(
base::FilePath path(default_download_path.Append(generated_name));
content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
base::Bind(callback, path));
base::BindOnce(callback, path));
}
} // namespace
@ -165,10 +165,10 @@ bool AtomDownloadManagerDelegate::DetermineDownloadTarget(
content::BrowserThread::PostTask(
content::BrowserThread::FILE, FROM_HERE,
base::Bind(&CreateDownloadPath, download->GetURL(),
download->GetContentDisposition(),
download->GetSuggestedFilename(), download->GetMimeType(),
default_download_path, download_path_callback));
base::BindOnce(&CreateDownloadPath, download->GetURL(),
download->GetContentDisposition(),
download->GetSuggestedFilename(), download->GetMimeType(),
default_download_path, download_path_callback));
return true;
}

6
atom/browser/atom_resource_dispatcher_host_delegate.cc
View file

@ -117,9 +117,9 @@ bool AtomResourceDispatcherHostDelegate::HandleExternalProtocol(
const GURL& url,
content::ResourceRequestInfo* info) {
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
base::Bind(&HandleExternalProtocolInUI, url,
info->GetWebContentsGetterForRequest(),
info->HasUserGesture()));
base::BindOnce(&HandleExternalProtocolInUI, url,
info->GetWebContentsGetterForRequest(),
info->HasUserGesture()));
return true;
}

13
atom/browser/common_web_contents_delegate.cc
View file

@ -312,9 +312,10 @@ void CommonWebContentsDelegate::DevToolsSaveToFile(const std::string& url,
saved_files_[url] = path;
BrowserThread::PostTaskAndReply(
BrowserThread::FILE, FROM_HERE, base::Bind(&WriteToFile, path, content),
base::Bind(&CommonWebContentsDelegate::OnDevToolsSaveToFile,
base::Unretained(this), url));
BrowserThread::FILE, FROM_HERE,
base::BindOnce(&WriteToFile, path, content),
base::BindOnce(&CommonWebContentsDelegate::OnDevToolsSaveToFile,
base::Unretained(this), url));
}
void CommonWebContentsDelegate::DevToolsAppendToFile(
@ -326,9 +327,9 @@ void CommonWebContentsDelegate::DevToolsAppendToFile(
BrowserThread::PostTaskAndReply(
BrowserThread::FILE, FROM_HERE,
base::Bind(&AppendToFile, it->second, content),
base::Bind(&CommonWebContentsDelegate::OnDevToolsAppendToFile,
base::Unretained(this), url));
base::BindOnce(&AppendToFile, it->second, content),
base::BindOnce(&CommonWebContentsDelegate::OnDevToolsAppendToFile,
base::Unretained(this), url));
}
void CommonWebContentsDelegate::DevToolsRequestFileSystems() {

10
atom/browser/login_handler.cc
View file

@ -47,9 +47,9 @@ LoginHandler::LoginHandler(net::AuthChallengeInfo* auth_info,
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&Browser::RequestLogin, base::Unretained(Browser::Get()),
base::RetainedRef(WrapRefCounted(this)),
base::Passed(&request_details)));
base::BindOnce(&Browser::RequestLogin, base::Unretained(Browser::Get()),
base::RetainedRef(WrapRefCounted(this)),
std::move(request_details)));
}
LoginHandler::~LoginHandler() {}
@ -69,7 +69,7 @@ void LoginHandler::Login(const base::string16& username,
return;
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&LoginHandler::DoLogin, this, username, password));
base::BindOnce(&LoginHandler::DoLogin, this, username, password));
}
void LoginHandler::CancelAuth() {
@ -77,7 +77,7 @@ void LoginHandler::CancelAuth() {
if (TestAndSetAuthHandled())
return;
BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
base::Bind(&LoginHandler::DoCancelAuth, this));
base::BindOnce(&LoginHandler::DoCancelAuth, this));
}
void LoginHandler::OnRequestCancelled() {

14
atom/browser/net/asar/url_request_asar_job.cc
View file

@ -109,15 +109,15 @@ void URLRequestAsarJob::Start() {
}
file_task_runner_->PostTaskAndReply(
FROM_HERE,
base::Bind(&URLRequestAsarJob::FetchMetaInfo, file_path_, type_,
base::Unretained(meta_info)),
base::Bind(&URLRequestAsarJob::DidFetchMetaInfo,
weak_ptr_factory_.GetWeakPtr(), base::Owned(meta_info)));
base::BindOnce(&URLRequestAsarJob::FetchMetaInfo, file_path_, type_,
base::Unretained(meta_info)),
base::BindOnce(&URLRequestAsarJob::DidFetchMetaInfo,
weak_ptr_factory_.GetWeakPtr(), base::Owned(meta_info)));
} else {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
base::Bind(&URLRequestAsarJob::DidOpen, weak_ptr_factory_.GetWeakPtr(),
net::ERR_FILE_NOT_FOUND));
FROM_HERE, base::BindOnce(&URLRequestAsarJob::DidOpen,
weak_ptr_factory_.GetWeakPtr(),
net::ERR_FILE_NOT_FOUND));
}
}

8
atom/browser/net/atom_cert_verifier.cc
View file

@ -100,9 +100,9 @@ class CertVerifierRequest : public AtomCertVerifier::Request {
weak_ptr_factory_.GetWeakPtr());
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&CertVerifierRequest::OnVerifyRequestInUI,
cert_verifier_->verify_proc(), base::Passed(&request),
response_callback));
base::BindOnce(&CertVerifierRequest::OnVerifyRequestInUI,
cert_verifier_->verify_proc(), std::move(request),
response_callback));
}
static void OnVerifyRequestInUI(
@ -116,7 +116,7 @@ class CertVerifierRequest : public AtomCertVerifier::Request {
int result) {
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CertVerifierRequest::NotifyResponseInIO, self, result));
base::BindOnce(&CertVerifierRequest::NotifyResponseInIO, self, result));
}
void NotifyResponseInIO(int result) {

12
atom/browser/net/atom_network_delegate.cc
View file

@ -403,8 +403,8 @@ int AtomNetworkDelegate::HandleResponseEvent(
base::Unretained(this), request->identifier(), out);
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(RunResponseListener, info.listener, base::Passed(&details),
render_process_id, render_frame_id, response));
base::BindOnce(RunResponseListener, info.listener, std::move(details),
render_process_id, render_frame_id, response));
return net::ERR_IO_PENDING;
}
@ -425,8 +425,8 @@ void AtomNetworkDelegate::HandleSimpleEvent(SimpleEvent type,
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(RunSimpleListener, info.listener, base::Passed(&details),
render_process_id, render_frame_id));
base::BindOnce(RunSimpleListener, info.listener, std::move(details),
render_process_id, render_frame_id));
}
template <typename T>
@ -453,8 +453,8 @@ void AtomNetworkDelegate::OnListenerResultInUI(
std::unique_ptr<base::DictionaryValue> copy = response.CreateDeepCopy();
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&AtomNetworkDelegate::OnListenerResultInIO<T>,
base::Unretained(this), id, out, base::Passed(&copy)));
base::BindOnce(&AtomNetworkDelegate::OnListenerResultInIO<T>,
base::Unretained(this), id, out, std::move(copy)));
}
} // namespace atom

50
atom/browser/net/atom_url_request.cc
View file

@ -79,8 +79,9 @@ scoped_refptr<AtomURLRequest> AtomURLRequest::Create(
scoped_refptr<AtomURLRequest> atom_url_request(new AtomURLRequest(delegate));
if (content::BrowserThread::PostTask(
content::BrowserThread::IO, FROM_HERE,
base::Bind(&AtomURLRequest::DoInitialize, atom_url_request,
request_context_getter, method, url, redirect_policy))) {
base::BindOnce(&AtomURLRequest::DoInitialize, atom_url_request,
request_context_getter, method, url,
redirect_policy))) {
return atom_url_request;
}
return nullptr;
@ -91,7 +92,7 @@ void AtomURLRequest::Terminate() {
delegate_ = nullptr;
content::BrowserThread::PostTask(
content::BrowserThread::IO, FROM_HERE,
base::Bind(&AtomURLRequest::DoTerminate, this));
base::BindOnce(&AtomURLRequest::DoTerminate, this));
}
void AtomURLRequest::DoInitialize(
@ -141,7 +142,7 @@ bool AtomURLRequest::Write(scoped_refptr<const net::IOBufferWithSize> buffer,
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
return content::BrowserThread::PostTask(
content::BrowserThread::IO, FROM_HERE,
base::Bind(&AtomURLRequest::DoWriteBuffer, this, buffer, is_last));
base::BindOnce(&AtomURLRequest::DoWriteBuffer, this, buffer, is_last));
}
void AtomURLRequest::SetChunkedUpload(bool is_chunked_upload) {
@ -155,15 +156,16 @@ void AtomURLRequest::SetChunkedUpload(bool is_chunked_upload) {
void AtomURLRequest::Cancel() {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
base::Bind(&AtomURLRequest::DoCancel, this));
content::BrowserThread::PostTask(
content::BrowserThread::IO, FROM_HERE,
base::BindOnce(&AtomURLRequest::DoCancel, this));
}
void AtomURLRequest::FollowRedirect() {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
content::BrowserThread::PostTask(
content::BrowserThread::IO, FROM_HERE,
base::Bind(&AtomURLRequest::DoFollowRedirect, this));
base::BindOnce(&AtomURLRequest::DoFollowRedirect, this));
}
void AtomURLRequest::SetExtraHeader(const std::string& name,
@ -171,14 +173,14 @@ void AtomURLRequest::SetExtraHeader(const std::string& name,
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
content::BrowserThread::PostTask(
content::BrowserThread::IO, FROM_HERE,
base::Bind(&AtomURLRequest::DoSetExtraHeader, this, name, value));
base::BindOnce(&AtomURLRequest::DoSetExtraHeader, this, name, value));
}
void AtomURLRequest::RemoveExtraHeader(const std::string& name) const {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
content::BrowserThread::PostTask(
content::BrowserThread::IO, FROM_HERE,
base::Bind(&AtomURLRequest::DoRemoveExtraHeader, this, name));
base::BindOnce(&AtomURLRequest::DoRemoveExtraHeader, this, name));
}
void AtomURLRequest::PassLoginInformation(
@ -188,11 +190,11 @@ void AtomURLRequest::PassLoginInformation(
if (username.empty() || password.empty()) {
content::BrowserThread::PostTask(
content::BrowserThread::IO, FROM_HERE,
base::Bind(&AtomURLRequest::DoCancelAuth, this));
base::BindOnce(&AtomURLRequest::DoCancelAuth, this));
} else {
content::BrowserThread::PostTask(
content::BrowserThread::IO, FROM_HERE,
base::Bind(&AtomURLRequest::DoSetAuth, this, username, password));
base::BindOnce(&AtomURLRequest::DoSetAuth, this, username, password));
}
}
@ -200,7 +202,7 @@ void AtomURLRequest::SetLoadFlags(int flags) const {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
content::BrowserThread::PostTask(
content::BrowserThread::IO, FROM_HERE,
base::Bind(&AtomURLRequest::DoSetLoadFlags, this, flags));
base::BindOnce(&AtomURLRequest::DoSetLoadFlags, this, flags));
}
void AtomURLRequest::DoWriteBuffer(
@ -308,8 +310,8 @@ void AtomURLRequest::DoCancelWithError(const std::string& error,
DoCancel();
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&AtomURLRequest::InformDelegateErrorOccured, this, error,
isRequestError));
base::BindOnce(&AtomURLRequest::InformDelegateErrorOccured, this, error,
isRequestError));
}
void AtomURLRequest::DoSetLoadFlags(int flags) const {
@ -337,9 +339,9 @@ void AtomURLRequest::OnReceivedRedirect(net::URLRequest* request,
request->response_headers();
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&AtomURLRequest::InformDelegateReceivedRedirect, this,
info.status_code, info.new_method, info.new_url,
response_headers));
base::BindOnce(&AtomURLRequest::InformDelegateReceivedRedirect, this,
info.status_code, info.new_method, info.new_url,
response_headers));
}
}
@ -349,8 +351,8 @@ void AtomURLRequest::OnAuthRequired(net::URLRequest* request,
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&AtomURLRequest::InformDelegateAuthenticationRequired, this,
scoped_refptr<net::AuthChallengeInfo>(auth_info)));
base::BindOnce(&AtomURLRequest::InformDelegateAuthenticationRequired,
this, scoped_refptr<net::AuthChallengeInfo>(auth_info)));
}
void AtomURLRequest::OnResponseStarted(net::URLRequest* request) {
@ -367,8 +369,8 @@ void AtomURLRequest::OnResponseStarted(net::URLRequest* request) {
// Success or pending trigger a Read.
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&AtomURLRequest::InformDelegateResponseStarted, this,
response_headers));
base::BindOnce(&AtomURLRequest::InformDelegateResponseStarted, this,
response_headers));
ReadResponse();
} else if (status.status() == net::URLRequestStatus::Status::FAILED) {
// Report error on Start.
@ -426,7 +428,7 @@ void AtomURLRequest::OnReadCompleted(net::URLRequest* request, int bytes_read) {
} else if (data_ended) {
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&AtomURLRequest::InformDelegateResponseCompleted, this));
base::BindOnce(&AtomURLRequest::InformDelegateResponseCompleted, this));
DoTerminate();
} else if (data_transfer_error) {
// We abort the request on corrupted data transfer.
@ -449,8 +451,8 @@ bool AtomURLRequest::CopyAndPostBuffer(int bytes_read) {
return content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&AtomURLRequest::InformDelegateResponseData, this,
buffer_copy));
base::BindOnce(&AtomURLRequest::InformDelegateResponseData, this,
buffer_copy));
}
void AtomURLRequest::InformDelegateReceivedRedirect(

4
atom/browser/net/js_asker.cc
View file

@ -23,7 +23,7 @@ void HandlerCallback(const BeforeStartCallback& before_start,
v8::Local<v8::Value> value;
if (!args->GetNext(&value)) {
content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
base::Bind(callback, false, nullptr));
base::BindOnce(callback, false, nullptr));
return;
}
@ -36,7 +36,7 @@ void HandlerCallback(const BeforeStartCallback& before_start,
std::unique_ptr<base::Value> options(converter.FromV8Value(value, context));
content::BrowserThread::PostTask(
content::BrowserThread::IO, FROM_HERE,
base::Bind(callback, true, base::Passed(&options)));
base::BindOnce(callback, true, std::move(options)));
}
} // namespace

4
atom/browser/net/js_asker.h
View file

@ -74,9 +74,9 @@ class JsAsker : public RequestJob {
FillRequestDetails(request_details.get(), RequestJob::request());
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(
base::BindOnce(
&internal::AskForOptions, isolate_, handler_,
base::Passed(&request_details),
std::move(request_details),
base::Bind(&JsAsker::BeforeStartInUI, weak_factory_.GetWeakPtr()),
base::Bind(&JsAsker::OnResponse, weak_factory_.GetWeakPtr())));
}

4
atom/browser/net/url_request_about_job.cc
View file

@ -14,8 +14,8 @@ URLRequestAboutJob::URLRequestAboutJob(net::URLRequest* request,
void URLRequestAboutJob::Start() {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&URLRequestAboutJob::StartAsync,
weak_ptr_factory_.GetWeakPtr()));
FROM_HERE, base::BindOnce(&URLRequestAboutJob::StartAsync,
weak_ptr_factory_.GetWeakPtr()));
}
void URLRequestAboutJob::Kill() {

9
atom/browser/net/url_request_stream_job.cc
View file

@ -120,8 +120,9 @@ void URLRequestStreamJob::OnError(mate::Arguments* args) {
int URLRequestStreamJob::ReadRawData(net::IOBuffer* dest, int dest_size) {
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&URLRequestStreamJob::CopyMoreData, weak_factory_.GetWeakPtr(),
WrapRefCounted(dest), dest_size));
base::BindOnce(&URLRequestStreamJob::CopyMoreData,
weak_factory_.GetWeakPtr(), WrapRefCounted(dest),
dest_size));
return net::ERR_IO_PENDING;
}
@ -168,8 +169,8 @@ void URLRequestStreamJob::CopyMoreData(scoped_refptr<net::IOBuffer> io_buf,
int status = (errored_ && !read_count) ? net::ERR_FAILED : read_count;
content::BrowserThread::PostTask(
content::BrowserThread::IO, FROM_HERE,
base::Bind(&URLRequestStreamJob::CopyMoreDataDone,
weak_factory_.GetWeakPtr(), io_buf, status));
base::BindOnce(&URLRequestStreamJob::CopyMoreDataDone,
weak_factory_.GetWeakPtr(), io_buf, status));
}
}

16
atom/browser/osr/osr_render_widget_host_view.cc
View file

@ -167,8 +167,8 @@ class AtomCopyFrameGenerator {
next_frame_time_ += frame_duration_;
content::BrowserThread::PostDelayedTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&AtomCopyFrameGenerator::OnCopyFrameCaptureSuccess,
weak_ptr_factory_.GetWeakPtr(), damage_rect, bitmap),
base::BindOnce(&AtomCopyFrameGenerator::OnCopyFrameCaptureSuccess,
weak_ptr_factory_.GetWeakPtr(), damage_rect, bitmap),
next_frame_in);
} else {
next_frame_time_ = now + frame_duration_;
@ -187,8 +187,8 @@ class AtomCopyFrameGenerator {
// Retry with the same |damage_rect|.
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&AtomCopyFrameGenerator::GenerateCopyFrame,
weak_ptr_factory_.GetWeakPtr(), damage_rect));
base::BindOnce(&AtomCopyFrameGenerator::GenerateCopyFrame,
weak_ptr_factory_.GetWeakPtr(), damage_rect));
}
}
@ -1030,8 +1030,8 @@ void OffScreenRenderWidgetHostView::ReleaseResize() {
pending_resize_ = false;
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&OffScreenRenderWidgetHostView::WasResized,
weak_ptr_factory_.GetWeakPtr()));
base::BindOnce(&OffScreenRenderWidgetHostView::WasResized,
weak_ptr_factory_.GetWeakPtr()));
}
}
@ -1131,8 +1131,8 @@ void OffScreenRenderWidgetHostView::ProcessMouseWheelEvent(
// other callback.
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&OffScreenRenderWidgetHostView::CancelWidget,
popup_host_view_->weak_ptr_factory_.GetWeakPtr()));
base::BindOnce(&OffScreenRenderWidgetHostView::CancelWidget,
popup_host_view_->weak_ptr_factory_.GetWeakPtr()));
}
}
}

4
atom/common/node_bindings.cc
View file

@ -318,8 +318,8 @@ void NodeBindings::UvRunOnce() {
void NodeBindings::WakeupMainThread() {
DCHECK(task_runner_);
task_runner_->PostTask(FROM_HERE, base::Bind(&NodeBindings::UvRunOnce,
weak_factory_.GetWeakPtr()));
task_runner_->PostTask(FROM_HERE, base::BindOnce(&NodeBindings::UvRunOnce,
weak_factory_.GetWeakPtr()));
}
void NodeBindings::WakeupEmbedThread() {

4
atom/renderer/atom_autofill_agent.cc
View file

@ -84,8 +84,8 @@ void AutofillAgent::TextFieldDidChange(
weak_ptr_factory_.InvalidateWeakPtrs();
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&AutofillAgent::TextFieldDidChangeImpl,
weak_ptr_factory_.GetWeakPtr(), element));
FROM_HERE, base::BindOnce(&AutofillAgent::TextFieldDidChangeImpl,
weak_ptr_factory_.GetWeakPtr(), element));
}
void AutofillAgent::TextFieldDidChangeImpl(

2
atom/renderer/guest_view_container.cc
View file

@ -53,7 +53,7 @@ void GuestViewContainer::DidResizeElement(const gfx::Size& new_size) {
return;
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(element_resize_callback_, new_size));
FROM_HERE, base::BindOnce(element_resize_callback_, new_size));
}
base::WeakPtr<content::BrowserPluginDelegate> GuestViewContainer::GetWeakPtr() {

20
brightray/browser/devtools_file_system_indexer.cc
View file

@ -279,13 +279,14 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::Start() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
BrowserThread::PostTask(
BrowserThread::FILE, FROM_HERE,
Bind(&FileSystemIndexingJob::CollectFilesToIndex, this));
BindOnce(&FileSystemIndexingJob::CollectFilesToIndex, this));
}
void DevToolsFileSystemIndexer::FileSystemIndexingJob::Stop() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
Bind(&FileSystemIndexingJob::StopOnFileThread, this));
BrowserThread::PostTask(
BrowserThread::FILE, FROM_HERE,
BindOnce(&FileSystemIndexingJob::StopOnFileThread, this));
}
void DevToolsFileSystemIndexer::FileSystemIndexingJob::StopOnFileThread() {
@ -304,7 +305,7 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::CollectFilesToIndex() {
if (file_path.empty()) {
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
Bind(total_work_callback_, file_path_times_.size()));
BindOnce(total_work_callback_, file_path_times_.size()));
indexing_it_ = file_path_times_.begin();
IndexFiles();
return;
@ -318,7 +319,7 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::CollectFilesToIndex() {
}
BrowserThread::PostTask(
BrowserThread::FILE, FROM_HERE,
Bind(&FileSystemIndexingJob::CollectFilesToIndex, this));
BindOnce(&FileSystemIndexingJob::CollectFilesToIndex, this));
}
void DevToolsFileSystemIndexer::FileSystemIndexingJob::IndexFiles() {
@ -429,7 +430,7 @@ void DevToolsFileSystemIndexer::FileSystemIndexingJob::ReportWorked() {
if (should_send_worked_nitification) {
last_worked_notification_time_ = current_time;
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
Bind(worked_callback_, files_indexed_));
BindOnce(worked_callback_, files_indexed_));
files_indexed_ = 0;
}
}
@ -458,8 +459,8 @@ void DevToolsFileSystemIndexer::SearchInPath(const string& file_system_path,
DCHECK_CURRENTLY_ON(BrowserThread::UI);
BrowserThread::PostTask(
BrowserThread::FILE, FROM_HERE,
Bind(&DevToolsFileSystemIndexer::SearchInPathOnFileThread, this,
file_system_path, query, callback));
BindOnce(&DevToolsFileSystemIndexer::SearchInPathOnFileThread, this,
file_system_path, query, callback));
}
void DevToolsFileSystemIndexer::SearchInPathOnFileThread(
@ -475,7 +476,8 @@ void DevToolsFileSystemIndexer::SearchInPathOnFileThread(
if (path.IsParent(*it))
result.push_back(it->AsUTF8Unsafe());
}
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, Bind(callback, result));
BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
BindOnce(callback, result));
}
} // namespace brightray

6
brightray/browser/inspectable_web_contents_impl.cc
View file

@ -171,9 +171,9 @@ int ResponseWriter::Write(net::IOBuffer* buffer,
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&InspectableWebContentsImpl::CallClientFunction, bindings_,
"DevToolsAPI.streamWrite", base::Owned(id), base::Owned(chunk),
nullptr));
base::BindOnce(&InspectableWebContentsImpl::CallClientFunction, bindings_,
"DevToolsAPI.streamWrite", base::Owned(id),
base::Owned(chunk), nullptr));
return num_bytes;
}