Use base::BindOnce for PostTask callbacks.
TaskRunner::PostTask() takes a OnceCallback. Replace usage of
base::Bind(), which produces a RepeatingCallback, with base::BindOnce()
when the callback is created as a temporary inside of PostTask(). The
following regex was used to find instances that could be replaced:
(Post(?:Delayed)?Task)\((?:\n\s*)?FROM_HERE,(?:\n)?\s*base::Bind\(
Also replace any usage of base::Passed(&var) with std::move(var) for
variables passed to base::BindOnce(). base::Passed() isn't needed for
move-only types with OnceCallbacks.
This CL was uploaded by git cl split.
[email protected]
Bug: 714018
Change-Id: I752c22efc5f81b5a7fb6dba1769ca61ecd0f6bd9
Reviewed-on: https://chromium-review.googlesource.com/c/1475647
Auto-Submit: kylechar <[email protected]>
Reviewed-by: Bence Béky <[email protected]>
Commit-Queue: Bence Béky <[email protected]>
Cr-Commit-Position: refs/heads/master@{#632708}diff --git a/net/android/http_auth_negotiate_android.cc b/net/android/http_auth_negotiate_android.cc
index 836b0f4..50f9eb2 100644
--- a/net/android/http_auth_negotiate_android.cc
+++ b/net/android/http_auth_negotiate_android.cc
@@ -51,7 +51,7 @@
// simplifies the logic. In practice the result will only ever come back on
// the original thread in an obscure error case.
callback_task_runner_->PostTask(
- FROM_HERE, base::Bind(thread_safe_callback_, result, raw_token));
+ FROM_HERE, base::BindOnce(thread_safe_callback_, result, raw_token));
// We will always get precisely one call to set result for each call to
// getNextAuthToken, so we can now delete the callback object, and must
// do so to avoid a memory leak.
diff --git a/net/base/directory_lister.cc b/net/base/directory_lister.cc
index aec3125..c898aaa 100644
--- a/net/base/directory_lister.cc
+++ b/net/base/directory_lister.cc
@@ -118,9 +118,9 @@
if (!base::DirectoryExists(dir_)) {
origin_task_runner_->PostTask(
- FROM_HERE, base::Bind(&Core::DoneOnOriginSequence, this,
- base::Passed(std::move(directory_list)),
- ERR_FILE_NOT_FOUND));
+ FROM_HERE, base::BindOnce(&Core::DoneOnOriginSequence, this,
+ base::Passed(std::move(directory_list)),
+ ERR_FILE_NOT_FOUND));
return;
}
@@ -158,7 +158,7 @@
origin_loop_->PostTask(
FROM_HERE,
- base::Bind(&DirectoryLister::Core::SendData, file_data));
+ base::BindOnce(&DirectoryLister::Core::SendData, file_data));
file_data.clear();
*/
}
@@ -166,8 +166,8 @@
SortData(directory_list.get(), type_);
origin_task_runner_->PostTask(
- FROM_HERE, base::Bind(&Core::DoneOnOriginSequence, this,
- base::Passed(std::move(directory_list)), OK));
+ FROM_HERE, base::BindOnce(&Core::DoneOnOriginSequence, this,
+ base::Passed(std::move(directory_list)), OK));
}
bool DirectoryLister::Core::IsCancelled() const {
diff --git a/net/base/file_stream_context_win.cc b/net/base/file_stream_context_win.cc
index f16f94ba..38571a4 100644
--- a/net/base/file_stream_context_win.cc
+++ b/net/base/file_stream_context_win.cc
@@ -82,9 +82,10 @@
task_runner_->PostTask(
FROM_HERE,
- base::Bind(&FileStream::Context::ReadAsync, base::Unretained(this),
- file_.GetPlatformFile(), base::WrapRefCounted(buf), buf_len,
- &io_context_.overlapped, base::ThreadTaskRunnerHandle::Get()));
+ base::BindOnce(&FileStream::Context::ReadAsync, base::Unretained(this),
+ file_.GetPlatformFile(), base::WrapRefCounted(buf),
+ buf_len, &io_context_.overlapped,
+ base::ThreadTaskRunnerHandle::Get()));
return ERR_IO_PENDING;
}
@@ -208,9 +209,9 @@
DWORD bytes_read = 0;
BOOL ret = ::ReadFile(file, buf->data(), buf_len, &bytes_read, overlapped);
origin_thread_task_runner->PostTask(
- FROM_HERE,
- base::Bind(&FileStream::Context::ReadAsyncResult,
- base::Unretained(context), ret, bytes_read, ::GetLastError()));
+ FROM_HERE, base::BindOnce(&FileStream::Context::ReadAsyncResult,
+ base::Unretained(context), ret, bytes_read,
+ ::GetLastError()));
}
void FileStream::Context::ReadAsyncResult(BOOL read_file_ret,
diff --git a/net/base/network_activity_monitor_unittest.cc b/net/base/network_activity_monitor_unittest.cc
index 3221ddab..d7b6ceaa 100644
--- a/net/base/network_activity_monitor_unittest.cc
+++ b/net/base/network_activity_monitor_unittest.cc
@@ -107,17 +107,14 @@
for (size_t i = 0; i < num_increments; ++i) {
size_t thread_num = i % threads.size();
threads[thread_num]->task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&IncrementBytesReceived, bytes_received));
+ FROM_HERE, base::BindOnce(&IncrementBytesReceived, bytes_received));
+ threads[thread_num]->task_runner()->PostTask(
+ FROM_HERE, base::BindOnce(&IncrementBytesSent, bytes_sent));
+ threads[thread_num]->task_runner()->PostTask(
+ FROM_HERE, base::BindOnce(&VerifyBytesSentIsMultipleOf, bytes_sent));
threads[thread_num]->task_runner()->PostTask(
FROM_HERE,
- base::Bind(&IncrementBytesSent, bytes_sent));
- threads[thread_num]->task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&VerifyBytesSentIsMultipleOf, bytes_sent));
- threads[thread_num]->task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&VerifyBytesReceivedIsMultipleOf, bytes_received));
+ base::BindOnce(&VerifyBytesReceivedIsMultipleOf, bytes_received));
}
threads.clear();
diff --git a/net/base/network_change_notifier_win.cc b/net/base/network_change_notifier_win.cc
index 882a71b..4031e87d 100644
--- a/net/base/network_change_notifier_win.cc
+++ b/net/base/network_change_notifier_win.cc
@@ -275,8 +275,9 @@
}
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, base::Bind(&NetworkChangeNotifierWin::WatchForAddressChange,
- weak_factory_.GetWeakPtr()),
+ FROM_HERE,
+ base::BindOnce(&NetworkChangeNotifierWin::WatchForAddressChange,
+ weak_factory_.GetWeakPtr()),
base::TimeDelta::FromMilliseconds(
kWatchForAddressChangeRetryIntervalMs));
return;
diff --git a/net/base/network_change_notifier_win_unittest.cc b/net/base/network_change_notifier_win_unittest.cc
index 8d50f8ae..a89b3c7 100644
--- a/net/base/network_change_notifier_win_unittest.cc
+++ b/net/base/network_change_notifier_win_unittest.cc
@@ -45,8 +45,8 @@
void RecomputeCurrentConnectionTypeOnDnsThread(
base::Callback<void(ConnectionType)> reply_callback) const override {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(reply_callback, NetworkChangeNotifier::CONNECTION_UNKNOWN));
+ FROM_HERE, base::BindOnce(reply_callback,
+ NetworkChangeNotifier::CONNECTION_UNKNOWN));
}
// From NetworkChangeNotifierWin.
diff --git a/net/base/network_config_watcher_mac.cc b/net/base/network_config_watcher_mac.cc
index f324969a..5aef19f 100644
--- a/net/base/network_config_watcher_mac.cc
+++ b/net/base/network_config_watcher_mac.cc
@@ -169,8 +169,9 @@
// initialize this, rather than just delaying it by a fixed time.
const base::TimeDelta kInitializationDelay = base::TimeDelta::FromSeconds(1);
task_runner()->PostDelayedTask(
- FROM_HERE, base::Bind(&NetworkConfigWatcherMacThread::InitNotifications,
- weak_factory_.GetWeakPtr()),
+ FROM_HERE,
+ base::BindOnce(&NetworkConfigWatcherMacThread::InitNotifications,
+ weak_factory_.GetWeakPtr()),
kInitializationDelay);
}
diff --git a/net/base/network_throttle_manager_impl.cc b/net/base/network_throttle_manager_impl.cc
index 5494531..d5043bc 100644
--- a/net/base/network_throttle_manager_impl.cc
+++ b/net/base/network_throttle_manager_impl.cc
@@ -250,8 +250,8 @@
// Via PostTask so there aren't upcalls from within destructors.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&NetworkThrottleManagerImpl::MaybeUnblockThrottles,
- weak_ptr_factory_.GetWeakPtr()));
+ base::BindOnce(&NetworkThrottleManagerImpl::MaybeUnblockThrottles,
+ weak_ptr_factory_.GetWeakPtr()));
}
}
diff --git a/net/base/test_completion_callback_unittest.cc b/net/base/test_completion_callback_unittest.cc
index 5a0242d..8ee06e0b1 100644
--- a/net/base/test_completion_callback_unittest.cc
+++ b/net/base/test_completion_callback_unittest.cc
@@ -74,8 +74,8 @@
void ExampleEmployer::ExampleWorker::DoWork() {
// In a real worker thread, some work would be done here.
// Pretend it is, and send the completion callback.
- origin_task_runner_->PostTask(FROM_HERE,
- base::Bind(&ExampleWorker::DoCallback, this));
+ origin_task_runner_->PostTask(
+ FROM_HERE, base::BindOnce(&ExampleWorker::DoCallback, this));
}
void ExampleEmployer::ExampleWorker::DoCallback() {
@@ -99,7 +99,7 @@
request_ = new ExampleWorker(this, std::move(callback));
if (!base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&ExampleWorker::DoWork, request_))) {
+ FROM_HERE, base::BindOnce(&ExampleWorker::DoWork, request_))) {
NOTREACHED();
request_ = NULL;
return false;
diff --git a/net/cert/cert_database_mac.cc b/net/cert/cert_database_mac.cc
index b363f59..8e7ffc4 100644
--- a/net/cert/cert_database_mac.cc
+++ b/net/cert/cert_database_mac.cc
@@ -38,9 +38,8 @@
// Ensure an associated CFRunLoop.
DCHECK(base::MessageLoopCurrentForUI::IsSet());
DCHECK(task_runner_->BelongsToCurrentThread());
- task_runner_->PostTask(FROM_HERE,
- base::Bind(&Notifier::Init,
- base::Unretained(this)));
+ task_runner_->PostTask(
+ FROM_HERE, base::BindOnce(&Notifier::Init, base::Unretained(this)));
}
// Should be called from the |task_runner_|'s sequence. Use Shutdown()
diff --git a/net/cert_net/cert_net_fetcher_impl.cc b/net/cert_net/cert_net_fetcher_impl.cc
index 48cf1ca..e2f2083 100644
--- a/net/cert_net/cert_net_fetcher_impl.cc
+++ b/net/cert_net/cert_net_fetcher_impl.cc
@@ -387,7 +387,7 @@
void RequestCore::CancelJob() {
if (!task_runner_->RunsTasksInCurrentSequence()) {
task_runner_->PostTask(FROM_HERE,
- base::Bind(&RequestCore::CancelJob, this));
+ base::BindOnce(&RequestCore::CancelJob, this));
return;
}
@@ -799,8 +799,8 @@
// then the request will hang (that is, WaitForResult will not return).
if (!task_runner_->PostTask(
FROM_HERE,
- base::Bind(&CertNetFetcherImpl::DoFetchOnNetworkSequence, this,
- base::Passed(&request_params), request_core))) {
+ base::BindOnce(&CertNetFetcherImpl::DoFetchOnNetworkSequence, this,
+ std::move(request_params), request_core))) {
request_core->SignalImmediateError();
}
diff --git a/net/cert_net/cert_net_fetcher_impl_unittest.cc b/net/cert_net/cert_net_fetcher_impl_unittest.cc
index 5b31dc0..87bfddf 100644
--- a/net/cert_net/cert_net_fetcher_impl_unittest.cc
+++ b/net/cert_net/cert_net_fetcher_impl_unittest.cc
@@ -124,8 +124,9 @@
if (!network_thread_)
return;
network_thread_->task_runner()->PostTask(
- FROM_HERE, base::Bind(&CertNetFetcherImplTest::TeardownOnNetworkThread,
- base::Unretained(this)));
+ FROM_HERE,
+ base::BindOnce(&CertNetFetcherImplTest::TeardownOnNetworkThread,
+ base::Unretained(this)));
network_thread_->Stop();
}
@@ -142,8 +143,8 @@
base::WaitableEvent::InitialState::NOT_SIGNALED);
network_thread_->task_runner()->PostTask(
FROM_HERE,
- base::Bind(&CertNetFetcherImplTest::CreateFetcherOnNetworkThread,
- base::Unretained(this), &done));
+ base::BindOnce(&CertNetFetcherImplTest::CreateFetcherOnNetworkThread,
+ base::Unretained(this), &done));
done.Wait();
}
@@ -157,8 +158,8 @@
base::WaitableEvent::InitialState::NOT_SIGNALED);
network_thread_->task_runner()->PostTask(
FROM_HERE,
- base::Bind(&CertNetFetcherImplTest::ShutDownFetcherOnNetworkThread,
- base::Unretained(this), &done));
+ base::BindOnce(&CertNetFetcherImplTest::ShutDownFetcherOnNetworkThread,
+ base::Unretained(this), &done));
done.Wait();
}
@@ -167,8 +168,8 @@
base::WaitableEvent done(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
network_thread_->task_runner()->PostTask(
- FROM_HERE, base::Bind(&CertNetFetcherImplTest::CountCreatedRequests,
- base::Unretained(this), &count, &done));
+ FROM_HERE, base::BindOnce(&CertNetFetcherImplTest::CountCreatedRequests,
+ base::Unretained(this), &count, &done));
done.Wait();
return count;
}
@@ -183,8 +184,8 @@
base::WaitableEvent done(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED);
network_thread_->task_runner()->PostTask(
- FROM_HERE, base::Bind(&CertNetFetcherImplTest::InitOnNetworkThread,
- base::Unretained(this), &done));
+ FROM_HERE, base::BindOnce(&CertNetFetcherImplTest::InitOnNetworkThread,
+ base::Unretained(this), &done));
done.Wait();
}
@@ -204,8 +205,8 @@
base::WaitableEvent::InitialState::NOT_SIGNALED);
network_thread_->task_runner()->PostTask(
FROM_HERE,
- base::Bind(&CertNetFetcherImplTest::ResetStateOnNetworkThread,
- base::Unretained(this), &done));
+ base::BindOnce(&CertNetFetcherImplTest::ResetStateOnNetworkThread,
+ base::Unretained(this), &done));
done.Wait();
}
diff --git a/net/cert_net/nss_ocsp.cc b/net/cert_net/nss_ocsp.cc
index e8f0a53..9fa92efec 100644
--- a/net/cert_net/nss_ocsp.cc
+++ b/net/cert_net/nss_ocsp.cc
@@ -353,7 +353,8 @@
lock_.AssertAcquired();
if (io_task_runner_) {
io_task_runner_->PostTask(
- FROM_HERE, base::Bind(&OCSPRequestSession::CancelURLRequest, this));
+ FROM_HERE,
+ base::BindOnce(&OCSPRequestSession::CancelURLRequest, this));
}
}
diff --git a/net/cookies/cookie_monster_store_test.cc b/net/cookies/cookie_monster_store_test.cc
index ee3e80e..d31091b9 100644
--- a/net/cookies/cookie_monster_store_test.cc
+++ b/net/cookies/cookie_monster_store_test.cc
@@ -55,7 +55,7 @@
loaded_ = true;
}
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(loaded_callback, base::Passed(&out_cookies)));
+ FROM_HERE, base::BindOnce(loaded_callback, std::move(out_cookies)));
}
void MockPersistentCookieStore::LoadCookiesForKey(
@@ -71,7 +71,7 @@
} else {
std::vector<std::unique_ptr<CanonicalCookie>> empty_cookies;
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(loaded_callback, base::Passed(&empty_cookies)));
+ FROM_HERE, base::BindOnce(loaded_callback, std::move(empty_cookies)));
}
}
@@ -147,7 +147,7 @@
out_cookies.push_back(std::make_unique<CanonicalCookie>(it->second));
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(loaded_callback, base::Passed(&out_cookies)));
+ FROM_HERE, base::BindOnce(loaded_callback, std::move(out_cookies)));
loaded_ = true;
}
@@ -159,7 +159,7 @@
} else {
std::vector<std::unique_ptr<CanonicalCookie>> empty_cookies;
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(loaded_callback, base::Passed(&empty_cookies)));
+ FROM_HERE, base::BindOnce(loaded_callback, std::move(empty_cookies)));
}
}
diff --git a/net/disk_cache/blockfile/eviction.cc b/net/disk_cache/blockfile/eviction.cc
index 63e018a..be71609 100644
--- a/net/disk_cache/blockfile/eviction.cc
+++ b/net/disk_cache/blockfile/eviction.cc
@@ -154,8 +154,8 @@
if (!empty && (deleted_entries > 20 ||
(TimeTicks::Now() - start).InMilliseconds() > 20)) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&Eviction::TrimCache, ptr_factory_.GetWeakPtr(), false));
+ FROM_HERE, base::BindOnce(&Eviction::TrimCache,
+ ptr_factory_.GetWeakPtr(), false));
break;
}
}
@@ -222,7 +222,8 @@
delay_trim_ = true;
trim_delays_++;
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, base::Bind(&Eviction::DelayedTrim, ptr_factory_.GetWeakPtr()),
+ FROM_HERE,
+ base::BindOnce(&Eviction::DelayedTrim, ptr_factory_.GetWeakPtr()),
base::TimeDelta::FromMilliseconds(1000));
}
@@ -370,8 +371,8 @@
if (!empty && (deleted_entries > 20 ||
(TimeTicks::Now() - start).InMilliseconds() > 20)) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&Eviction::TrimCache, ptr_factory_.GetWeakPtr(), false));
+ FROM_HERE, base::BindOnce(&Eviction::TrimCache,
+ ptr_factory_.GetWeakPtr(), false));
break;
}
}
@@ -383,8 +384,8 @@
TrimDeleted(true);
} else if (ShouldTrimDeleted()) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&Eviction::TrimDeleted, ptr_factory_.GetWeakPtr(), empty));
+ FROM_HERE, base::BindOnce(&Eviction::TrimDeleted,
+ ptr_factory_.GetWeakPtr(), empty));
}
if (empty) {
@@ -516,8 +517,8 @@
if (deleted_entries && !empty && ShouldTrimDeleted()) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&Eviction::TrimDeleted, ptr_factory_.GetWeakPtr(), false));
+ FROM_HERE, base::BindOnce(&Eviction::TrimDeleted,
+ ptr_factory_.GetWeakPtr(), false));
}
CACHE_UMA(AGE_MS, "TotalTrimDeletedTime", 0, start);
diff --git a/net/disk_cache/blockfile/in_flight_io.cc b/net/disk_cache/blockfile/in_flight_io.cc
index 2471b35..e32a6b49 100644
--- a/net/disk_cache/blockfile/in_flight_io.cc
+++ b/net/disk_cache/blockfile/in_flight_io.cc
@@ -77,7 +77,7 @@
#endif
callback_task_runner_->PostTask(
- FROM_HERE, base::Bind(&BackgroundIO::OnIOSignalled, operation));
+ FROM_HERE, base::BindOnce(&BackgroundIO::OnIOSignalled, operation));
operation->io_completed()->Signal();
}
diff --git a/net/disk_cache/blockfile/sparse_control.cc b/net/disk_cache/blockfile/sparse_control.cc
index 21969c4..105ce54 100644
--- a/net/disk_cache/blockfile/sparse_control.cc
+++ b/net/disk_cache/blockfile/sparse_control.cc
@@ -147,7 +147,7 @@
// Post a task to delete the next child.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&ChildrenDeleter::DeleteChildren, this));
+ FROM_HERE, base::BindOnce(&ChildrenDeleter::DeleteChildren, this));
}
// Returns the NetLog event type corresponding to a SparseOperation.
@@ -375,11 +375,11 @@
if (buffer) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&ChildrenDeleter::Start, deleter, buffer, data_len));
+ base::BindOnce(&ChildrenDeleter::Start, deleter, buffer, data_len));
} else {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&ChildrenDeleter::ReadData, deleter, address, data_len));
+ base::BindOnce(&ChildrenDeleter::ReadData, deleter, address, data_len));
}
}
diff --git a/net/dns/dns_config_service_posix.cc b/net/dns/dns_config_service_posix.cc
index 31c564fa..061a011 100644
--- a/net/dns/dns_config_service_posix.cc
+++ b/net/dns/dns_config_service_posix.cc
@@ -273,8 +273,9 @@
// Ignore transient flutter of resolv.conf by delaying the signal a bit.
const base::TimeDelta kDelay = base::TimeDelta::FromMilliseconds(50);
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, base::Bind(&Watcher::OnConfigChangedDelayed,
- weak_factory_.GetWeakPtr(), succeeded),
+ FROM_HERE,
+ base::BindOnce(&Watcher::OnConfigChangedDelayed,
+ weak_factory_.GetWeakPtr(), succeeded),
kDelay);
}
diff --git a/net/dns/dns_config_service_win.cc b/net/dns/dns_config_service_win.cc
index 860aa27..c9ec3e4d 100644
--- a/net/dns/dns_config_service_win.cc
+++ b/net/dns/dns_config_service_win.cc
@@ -672,7 +672,7 @@
LOG(WARNING) << "Failed to read DnsConfig.";
// Try again in a while in case DnsConfigWatcher missed the signal.
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, base::Bind(&ConfigReader::WorkNow, this),
+ FROM_HERE, base::BindOnce(&ConfigReader::WorkNow, this),
base::TimeDelta::FromSeconds(kRetryIntervalSeconds));
}
}
diff --git a/net/dns/dns_test_util.cc b/net/dns/dns_test_util.cc
index e6a78a32..285a2d5 100644
--- a/net/dns/dns_test_util.cc
+++ b/net/dns/dns_test_util.cc
@@ -268,7 +268,7 @@
return;
// Using WeakPtr to cleanly cancel when transaction is destroyed.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&MockTransaction::Finish, AsWeakPtr()));
+ FROM_HERE, base::BindOnce(&MockTransaction::Finish, AsWeakPtr()));
}
void FinishDelayedTransaction() {
diff --git a/net/dns/dns_transaction_unittest.cc b/net/dns/dns_transaction_unittest.cc
index cfb46e3..150b2c07 100644
--- a/net/dns/dns_transaction_unittest.cc
+++ b/net/dns/dns_transaction_unittest.cc
@@ -465,8 +465,8 @@
// Start reading asynchronously so that all error reporting and data
// callbacks happen as they would for network requests.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestMockDohJob::StartAsync,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&URLRequestMockDohJob::StartAsync,
+ weak_factory_.GetWeakPtr()));
}
~URLRequestMockDohJob() override {
diff --git a/net/dns/mdns_client_impl.cc b/net/dns/mdns_client_impl.cc
index 967ca35..cfcd6d3 100644
--- a/net/dns/mdns_client_impl.cc
+++ b/net/dns/mdns_client_impl.cc
@@ -213,8 +213,8 @@
VLOG(1) << "Socket error. id=" << id << ", error=" << rv;
// Post to allow deletion of this object by delegate.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&MDnsConnection::OnError, weak_ptr_factory_.GetWeakPtr(), rv));
+ FROM_HERE, base::BindOnce(&MDnsConnection::OnError,
+ weak_ptr_factory_.GetWeakPtr(), rv));
}
void MDnsConnection::OnError(int rv) {
@@ -395,8 +395,8 @@
// Schedule the actual removal for later in case the listener removal
// happens while iterating over the observer list.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&MDnsClientImpl::Core::CleanupObserverList,
- AsWeakPtr(), key));
+ FROM_HERE, base::BindOnce(&MDnsClientImpl::Core::CleanupObserverList,
+ AsWeakPtr(), key));
}
}
diff --git a/net/dns/mock_host_resolver.cc b/net/dns/mock_host_resolver.cc
index dbb22b3..0811064 100644
--- a/net/dns/mock_host_resolver.cc
+++ b/net/dns/mock_host_resolver.cc
@@ -357,8 +357,8 @@
DCHECK(ondemand_mode_);
for (auto i = requests_.begin(); i != requests_.end(); ++i) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&MockHostResolverBase::ResolveNow, AsWeakPtr(), i->first));
+ FROM_HERE, base::BindOnce(&MockHostResolverBase::ResolveNow,
+ AsWeakPtr(), i->first));
}
}
diff --git a/net/dns/serial_worker_unittest.cc b/net/dns/serial_worker_unittest.cc
index 7175af5..a9562f9c 100644
--- a/net/dns/serial_worker_unittest.cc
+++ b/net/dns/serial_worker_unittest.cc
@@ -77,8 +77,8 @@
void BreakNow(const std::string& b) {
task_runner_->PostTask(FROM_HERE,
- base::Bind(&SerialWorkerTest::BreakCallback,
- base::Unretained(this), b));
+ base::BindOnce(&SerialWorkerTest::BreakCallback,
+ base::Unretained(this), b));
}
void RunUntilBreak(const std::string& b) {
diff --git a/net/extras/sqlite/sqlite_channel_id_store.cc b/net/extras/sqlite/sqlite_channel_id_store.cc
index b67d23f..865fb63 100644
--- a/net/extras/sqlite/sqlite_channel_id_store.cc
+++ b/net/extras/sqlite/sqlite_channel_id_store.cc
@@ -355,8 +355,8 @@
// TODO(shess): Consider just calling RazeAndClose() immediately.
// db_ may not be safe to reset at this point, but RazeAndClose()
// would cause the stack to unwind safely with errors.
- background_task_runner_->PostTask(FROM_HERE,
- base::Bind(&Backend::KillDatabase, this));
+ background_task_runner_->PostTask(
+ FROM_HERE, base::BindOnce(&Backend::KillDatabase, this));
}
void SQLiteChannelIDStore::Backend::KillDatabase() {
@@ -388,9 +388,8 @@
return;
// Perform deletion on background task runner.
background_task_runner_->PostTask(
- FROM_HERE,
- base::Bind(
- &Backend::BackgroundDeleteAllInList, this, server_identifiers));
+ FROM_HERE, base::BindOnce(&Backend::BackgroundDeleteAllInList, this,
+ server_identifiers));
}
void SQLiteChannelIDStore::Backend::BatchOperation(
@@ -421,13 +420,12 @@
if (num_pending == 1) {
// We've gotten our first entry for this batch, fire off the timer.
background_task_runner_->PostDelayedTask(
- FROM_HERE,
- base::Bind(&Backend::Commit, this),
+ FROM_HERE, base::BindOnce(&Backend::Commit, this),
base::TimeDelta::FromMilliseconds(kCommitIntervalMs));
} else if (num_pending == kCommitAfterBatchSize) {
// We've reached a big enough batch, fire off a commit now.
background_task_runner_->PostTask(FROM_HERE,
- base::Bind(&Backend::Commit, this));
+ base::BindOnce(&Backend::Commit, this));
}
}
@@ -453,7 +451,7 @@
Commit();
} else {
background_task_runner_->PostTask(FROM_HERE,
- base::Bind(&Backend::Commit, this));
+ base::BindOnce(&Backend::Commit, this));
}
}
@@ -526,7 +524,7 @@
void SQLiteChannelIDStore::Backend::Close() {
// Must close the backend on the background task runner.
background_task_runner_->PostTask(
- FROM_HERE, base::Bind(&Backend::InternalBackgroundClose, this));
+ FROM_HERE, base::BindOnce(&Backend::InternalBackgroundClose, this));
}
void SQLiteChannelIDStore::Backend::InternalBackgroundClose() {
diff --git a/net/extras/sqlite/sqlite_persistent_cookie_store.cc b/net/extras/sqlite/sqlite_persistent_cookie_store.cc
index 65a5308..fb891be 100644
--- a/net/extras/sqlite/sqlite_persistent_cookie_store.cc
+++ b/net/extras/sqlite/sqlite_persistent_cookie_store.cc
@@ -866,7 +866,7 @@
if (load_success && keys_to_load_.size() > 0) {
bool success = background_task_runner_->PostDelayedTask(
FROM_HERE,
- base::Bind(&Backend::ChainLoadCookies, this, loaded_callback),
+ base::BindOnce(&Backend::ChainLoadCookies, this, loaded_callback),
base::TimeDelta::FromMilliseconds(kLoadDelayMilliseconds));
if (!success) {
LOG(WARNING) << "Failed to post task from " << FROM_HERE.ToString()
@@ -1310,7 +1310,7 @@
if (num_pending == 1) {
// We've gotten our first entry for this batch, fire off the timer.
if (!background_task_runner_->PostDelayedTask(
- FROM_HERE, base::Bind(&Backend::Commit, this),
+ FROM_HERE, base::BindOnce(&Backend::Commit, this),
base::TimeDelta::FromMilliseconds(kCommitIntervalMs))) {
NOTREACHED() << "background_task_runner_ is not running.";
}
diff --git a/net/extras/sqlite/sqlite_persistent_cookie_store_unittest.cc b/net/extras/sqlite/sqlite_persistent_cookie_store_unittest.cc
index 84636fb..6f673ab9 100644
--- a/net/extras/sqlite/sqlite_persistent_cookie_store_unittest.cc
+++ b/net/extras/sqlite/sqlite_persistent_cookie_store_unittest.cc
@@ -320,8 +320,8 @@
// Posting a blocking task to db_thread_ makes sure that the DB thread waits
// until both Load and Flush have been posted to its task queue.
background_task_runner_->PostTask(
- FROM_HERE, base::Bind(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
- base::Unretained(this)));
+ FROM_HERE, base::BindOnce(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
+ base::Unretained(this)));
store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
base::Unretained(this)),
NetLogWithSource());
@@ -385,8 +385,8 @@
// Posting a blocking task to db_thread_ makes sure that the DB thread waits
// until both Load and LoadCookiesForKey have been posted to its task queue.
background_task_runner_->PostTask(
- FROM_HERE, base::Bind(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
- base::Unretained(this)));
+ FROM_HERE, base::BindOnce(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
+ base::Unretained(this)));
BoundTestNetLog net_log;
store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
base::Unretained(this)),
@@ -397,8 +397,8 @@
"aaa.com", base::Bind(&SQLitePersistentCookieStoreTest::OnKeyLoaded,
base::Unretained(this), run_loop.QuitClosure()));
background_task_runner_->PostTask(
- FROM_HERE, base::Bind(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
- base::Unretained(this)));
+ FROM_HERE, base::BindOnce(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
+ base::Unretained(this)));
// Now the DB-thread queue contains:
// (active:)
diff --git a/net/http/bidirectional_stream.cc b/net/http/bidirectional_stream.cc
index 404602b..3530487 100644
--- a/net/http/bidirectional_stream.cc
+++ b/net/http/bidirectional_stream.cc
@@ -107,8 +107,8 @@
if (!request_info_->url.SchemeIs(url::kHttpsScheme)) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&BidirectionalStream::NotifyFailed,
- weak_factory_.GetWeakPtr(), ERR_DISALLOWED_URL_SCHEME));
+ base::BindOnce(&BidirectionalStream::NotifyFailed,
+ weak_factory_.GetWeakPtr(), ERR_DISALLOWED_URL_SCHEME));
return;
}
diff --git a/net/http/http_auth_handler_mock.cc b/net/http/http_auth_handler_mock.cc
index 0ac30e1..fa245cb 100644
--- a/net/http/http_auth_handler_mock.cc
+++ b/net/http/http_auth_handler_mock.cc
@@ -115,8 +115,8 @@
callback_ = std::move(callback);
auth_token_ = auth_token;
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&HttpAuthHandlerMock::OnGenerateAuthToken,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&HttpAuthHandlerMock::OnGenerateAuthToken,
+ weak_factory_.GetWeakPtr()));
state_ = State::TOKEN_PENDING;
return ERR_IO_PENDING;
} else {
diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc
index 45ac482..3e544cb 100644
--- a/net/http/http_cache.cc
+++ b/net/http/http_cache.cc
@@ -1013,7 +1013,8 @@
for (auto* transaction : entry->add_to_entry_queue) {
transaction->ResetCachePendingState();
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(transaction->io_callback(), net::ERR_CACHE_RACE));
+ FROM_HERE,
+ base::BindOnce(transaction->io_callback(), net::ERR_CACHE_RACE));
}
entry->add_to_entry_queue.clear();
}
@@ -1082,8 +1083,8 @@
// Post a task instead of invoking the io callback of another transaction here
// to avoid re-entrancy.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&HttpCache::OnProcessQueuedTransactions, GetWeakPtr(), entry));
+ FROM_HERE, base::BindOnce(&HttpCache::OnProcessQueuedTransactions,
+ GetWeakPtr(), entry));
}
void HttpCache::ProcessAddToEntryQueue(ActiveEntry* entry) {
@@ -1474,8 +1475,8 @@
pending_op->writer = std::move(pending_item);
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&HttpCache::OnBackendCreated, GetWeakPtr(),
- result, pending_op));
+ FROM_HERE, base::BindOnce(&HttpCache::OnBackendCreated, GetWeakPtr(),
+ result, pending_op));
} else {
building_backend_ = false;
DeletePendingOp(pending_op);
diff --git a/net/http/http_cache_transaction.cc b/net/http/http_cache_transaction.cc
index 8b20caa4..e1bcd20 100644
--- a/net/http/http_cache_transaction.cc
+++ b/net/http/http_cache_transaction.cc
@@ -1329,8 +1329,8 @@
next_state_ == STATE_FINISH_HEADERS_COMPLETE)) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&HttpCache::Transaction::OnCacheLockTimeout,
- weak_factory_.GetWeakPtr(), entry_lock_waiting_since_));
+ base::BindOnce(&HttpCache::Transaction::OnCacheLockTimeout,
+ weak_factory_.GetWeakPtr(), entry_lock_waiting_since_));
} else {
int timeout_milliseconds = 20 * 1000;
if (partial_ && entry->writers && !entry->writers->IsEmpty() &&
@@ -1356,8 +1356,8 @@
}
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
- base::Bind(&HttpCache::Transaction::OnCacheLockTimeout,
- weak_factory_.GetWeakPtr(), entry_lock_waiting_since_),
+ base::BindOnce(&HttpCache::Transaction::OnCacheLockTimeout,
+ weak_factory_.GetWeakPtr(), entry_lock_waiting_since_),
TimeDelta::FromMilliseconds(timeout_milliseconds));
}
}
diff --git a/net/http/http_stream_factory_job.cc b/net/http/http_stream_factory_job.cc
index aeded63..f7158e1 100644
--- a/net/http/http_stream_factory_job.cc
+++ b/net/http/http_stream_factory_job.cc
@@ -584,8 +584,9 @@
if (job_type_ == PRECONNECT) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&HttpStreamFactory::Job::OnPreconnectsComplete,
- ptr_factory_.GetWeakPtr()));
+ FROM_HERE,
+ base::BindOnce(&HttpStreamFactory::Job::OnPreconnectsComplete,
+ ptr_factory_.GetWeakPtr()));
return;
}
@@ -597,8 +598,8 @@
next_state_ = STATE_WAITING_USER_ACTION;
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&HttpStreamFactory::Job::OnCertificateErrorCallback,
- ptr_factory_.GetWeakPtr(), result, ssl_info));
+ base::BindOnce(&HttpStreamFactory::Job::OnCertificateErrorCallback,
+ ptr_factory_.GetWeakPtr(), result, ssl_info));
return;
}
@@ -609,8 +610,9 @@
if (!connection_.get()) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&Job::OnStreamFailedCallback, ptr_factory_.GetWeakPtr(),
- ERR_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION));
+ base::BindOnce(&Job::OnStreamFailedCallback,
+ ptr_factory_.GetWeakPtr(),
+ ERR_PROXY_AUTH_REQUESTED_WITH_NO_CONNECTION));
return;
}
CHECK(connection_->socket());
@@ -621,16 +623,17 @@
static_cast<ProxyClientSocket*>(connection_->socket());
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&Job::OnNeedsProxyAuthCallback, ptr_factory_.GetWeakPtr(),
- *proxy_socket->GetConnectResponseInfo(),
- base::RetainedRef(proxy_socket->GetAuthController())));
+ base::BindOnce(&Job::OnNeedsProxyAuthCallback,
+ ptr_factory_.GetWeakPtr(),
+ *proxy_socket->GetConnectResponseInfo(),
+ base::RetainedRef(proxy_socket->GetAuthController())));
return;
}
case ERR_SSL_CLIENT_AUTH_CERT_NEEDED:
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(
+ base::BindOnce(
&Job::OnNeedsClientAuthCallback, ptr_factory_.GetWeakPtr(),
base::RetainedRef(
connection_->ssl_error_response_info().cert_request_info)));
@@ -661,36 +664,37 @@
next_state_ = STATE_DONE;
if (new_spdy_session_.get()) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&Job::OnNewSpdySessionReadyCallback,
- ptr_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&Job::OnNewSpdySessionReadyCallback,
+ ptr_factory_.GetWeakPtr()));
} else if (is_websocket_) {
DCHECK(websocket_stream_);
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&Job::OnWebSocketHandshakeStreamReadyCallback,
- ptr_factory_.GetWeakPtr()));
+ FROM_HERE,
+ base::BindOnce(&Job::OnWebSocketHandshakeStreamReadyCallback,
+ ptr_factory_.GetWeakPtr()));
} else if (stream_type_ == HttpStreamRequest::BIDIRECTIONAL_STREAM) {
if (!bidirectional_stream_impl_) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&Job::OnStreamFailedCallback,
- ptr_factory_.GetWeakPtr(), ERR_FAILED));
+ FROM_HERE, base::BindOnce(&Job::OnStreamFailedCallback,
+ ptr_factory_.GetWeakPtr(), ERR_FAILED));
} else {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&Job::OnBidirectionalStreamImplReadyCallback,
- ptr_factory_.GetWeakPtr()));
+ base::BindOnce(&Job::OnBidirectionalStreamImplReadyCallback,
+ ptr_factory_.GetWeakPtr()));
}
} else {
DCHECK(stream_.get());
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&Job::OnStreamReadyCallback, ptr_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&Job::OnStreamReadyCallback,
+ ptr_factory_.GetWeakPtr()));
}
return;
default:
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&Job::OnStreamFailedCallback,
- ptr_factory_.GetWeakPtr(), result));
+ FROM_HERE, base::BindOnce(&Job::OnStreamFailedCallback,
+ ptr_factory_.GetWeakPtr(), result));
return;
}
}
diff --git a/net/http/http_stream_factory_job_controller.cc b/net/http/http_stream_factory_job_controller.cc
index aee6810..333031e 100644
--- a/net/http/http_stream_factory_job_controller.cc
+++ b/net/http/http_stream_factory_job_controller.cc
@@ -736,8 +736,8 @@
DCHECK(!alternative_job_);
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&HttpStreamFactory::JobController::NotifyRequestFailed,
- ptr_factory_.GetWeakPtr(), rv));
+ base::BindOnce(&HttpStreamFactory::JobController::NotifyRequestFailed,
+ ptr_factory_.GetWeakPtr(), rv));
}
}
diff --git a/net/http/http_stream_parser_unittest.cc b/net/http/http_stream_parser_unittest.cc
index be70ac2..1125d556 100644
--- a/net/http/http_stream_parser_unittest.cc
+++ b/net/http/http_stream_parser_unittest.cc
@@ -82,8 +82,8 @@
int ReadInternal(IOBuffer* buf, int buf_len) override {
if (async_ == FailureMode::ASYNC) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&ReadErrorUploadDataStream::CompleteRead,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&ReadErrorUploadDataStream::CompleteRead,
+ weak_factory_.GetWeakPtr()));
return ERR_IO_PENDING;
}
return ERR_FAILED;
@@ -207,8 +207,8 @@
int InitInternal(const NetLogWithSource& net_log) override {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&InitAsyncUploadDataStream::CompleteInit,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&InitAsyncUploadDataStream::CompleteInit,
+ weak_factory_.GetWeakPtr()));
return ERR_IO_PENDING;
}
diff --git a/net/log/file_net_log_observer.cc b/net/log/file_net_log_observer.cc
index f31acf2..1b1b7e40 100644
--- a/net/log/file_net_log_observer.cc
+++ b/net/log/file_net_log_observer.cc
@@ -368,8 +368,9 @@
// StopObserving was not called.
net_log()->RemoveObserver(this);
file_task_runner_->PostTask(
- FROM_HERE, base::Bind(&FileNetLogObserver::FileWriter::DeleteAllFiles,
- base::Unretained(file_writer_.get())));
+ FROM_HERE,
+ base::BindOnce(&FileNetLogObserver::FileWriter::DeleteAllFiles,
+ base::Unretained(file_writer_.get())));
}
file_task_runner_->DeleteSoon(FROM_HERE, file_writer_.release());
}
@@ -412,8 +413,8 @@
if (queue_size == kNumWriteQueueEvents) {
file_task_runner_->PostTask(
FROM_HERE,
- base::Bind(&FileNetLogObserver::FileWriter::Flush,
- base::Unretained(file_writer_.get()), write_queue_));
+ base::BindOnce(&FileNetLogObserver::FileWriter::Flush,
+ base::Unretained(file_writer_.get()), write_queue_));
}
}
@@ -477,9 +478,9 @@
if (!constants)
constants = GetNetConstants();
file_task_runner_->PostTask(
- FROM_HERE, base::Bind(&FileNetLogObserver::FileWriter::Initialize,
- base::Unretained(file_writer_.get()),
- base::Passed(&constants)));
+ FROM_HERE, base::BindOnce(&FileNetLogObserver::FileWriter::Initialize,
+ base::Unretained(file_writer_.get()),
+ std::move(constants)));
}
FileNetLogObserver::WriteQueue::WriteQueue(uint64_t memory_max)
diff --git a/net/log/file_net_log_observer_unittest.cc b/net/log/file_net_log_observer_unittest.cc
index 64ea6b4..ce841283 100644
--- a/net/log/file_net_log_observer_unittest.cc
+++ b/net/log/file_net_log_observer_unittest.cc
@@ -578,8 +578,8 @@
// Add events in parallel from all the threads.
for (size_t i = 0; i < kNumThreads; ++i) {
threads[i]->task_runner()->PostTask(
- FROM_HERE, base::Bind(&AddEntries, base::Unretained(logger_.get()),
- kNumEventsAddedPerThread, kDummyEventSize));
+ FROM_HERE, base::BindOnce(&AddEntries, base::Unretained(logger_.get()),
+ kNumEventsAddedPerThread, kDummyEventSize));
}
// Join all the threads.
@@ -963,8 +963,9 @@
// Add events in parallel from all the threads.
for (size_t i = 0; i < kNumThreads; ++i) {
threads[i]->task_runner()->PostTask(
- FROM_HERE, base::Bind(&AddEntriesViaNetLog, base::Unretained(&net_log_),
- kNumEventsAddedPerThread));
+ FROM_HERE,
+ base::BindOnce(&AddEntriesViaNetLog, base::Unretained(&net_log_),
+ kNumEventsAddedPerThread));
}
// Stop observing.
@@ -998,8 +999,9 @@
// Add events in parallel from all the threads.
for (size_t i = 0; i < kNumThreads; ++i) {
threads[i]->task_runner()->PostTask(
- FROM_HERE, base::Bind(&AddEntriesViaNetLog, base::Unretained(&net_log_),
- kNumEventsAddedPerThread));
+ FROM_HERE,
+ base::BindOnce(&AddEntriesViaNetLog, base::Unretained(&net_log_),
+ kNumEventsAddedPerThread));
}
// Destroy logger.
diff --git a/net/nqe/network_quality_estimator.cc b/net/nqe/network_quality_estimator.cc
index a46ce25..66f2871 100644
--- a/net/nqe/network_quality_estimator.cc
+++ b/net/nqe/network_quality_estimator.cc
@@ -1055,9 +1055,10 @@
// Notify the |observer| on the next message pump since |observer| may not
// be completely set up for receiving the callbacks.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&NetworkQualityEstimator::
- NotifyEffectiveConnectionTypeObserverIfPresent,
- weak_ptr_factory_.GetWeakPtr(), observer));
+ FROM_HERE,
+ base::BindOnce(&NetworkQualityEstimator::
+ NotifyEffectiveConnectionTypeObserverIfPresent,
+ weak_ptr_factory_.GetWeakPtr(), observer));
}
void NetworkQualityEstimator::RemoveEffectiveConnectionTypeObserver(
@@ -1076,9 +1077,9 @@
// be completely set up for receiving the callbacks.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&NetworkQualityEstimator::
- NotifyRTTAndThroughputEstimatesObserverIfPresent,
- weak_ptr_factory_.GetWeakPtr(), observer));
+ base::BindOnce(&NetworkQualityEstimator::
+ NotifyRTTAndThroughputEstimatesObserverIfPresent,
+ weak_ptr_factory_.GetWeakPtr(), observer));
}
void NetworkQualityEstimator::RemoveRTTAndThroughputEstimatesObserver(
diff --git a/net/nqe/network_quality_store.cc b/net/nqe/network_quality_store.cc
index 905162c..aa444b0 100644
--- a/net/nqe/network_quality_store.cc
+++ b/net/nqe/network_quality_store.cc
@@ -175,8 +175,9 @@
// Notify the |observer| on the next message pump since |observer| may not
// be completely set up for receiving the callbacks.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&NetworkQualityStore::NotifyCacheObserverIfPresent,
- weak_ptr_factory_.GetWeakPtr(), observer));
+ FROM_HERE,
+ base::BindOnce(&NetworkQualityStore::NotifyCacheObserverIfPresent,
+ weak_ptr_factory_.GetWeakPtr(), observer));
}
void NetworkQualityStore::RemoveNetworkQualitiesCacheObserver(
diff --git a/net/nqe/socket_watcher.cc b/net/nqe/socket_watcher.cc
index 096a5c14..1c559e7 100644
--- a/net/nqe/socket_watcher.cc
+++ b/net/nqe/socket_watcher.cc
@@ -120,7 +120,7 @@
last_rtt_notification_ = tick_clock_->NowTicks();
task_runner_->PostTask(
FROM_HERE,
- base::Bind(updated_rtt_observation_callback_, protocol_, rtt, host_));
+ base::BindOnce(updated_rtt_observation_callback_, protocol_, rtt, host_));
}
void SocketWatcher::OnConnectionChanged() {
diff --git a/net/nqe/throughput_analyzer.cc b/net/nqe/throughput_analyzer.cc
index 3632b6ae..2e9e2352 100644
--- a/net/nqe/throughput_analyzer.cc
+++ b/net/nqe/throughput_analyzer.cc
@@ -191,7 +191,7 @@
// Notify the provided callback.
task_runner_->PostTask(
FROM_HERE,
- base::Bind(throughput_observation_callback_, downstream_kbps));
+ base::BindOnce(throughput_observation_callback_, downstream_kbps));
}
// Try to remove the request from either |accuracy_degrading_requests_| or
diff --git a/net/proxy_resolution/multi_threaded_proxy_resolver.cc b/net/proxy_resolution/multi_threaded_proxy_resolver.cc
index ae41f4f..b48196c 100644
--- a/net/proxy_resolution/multi_threaded_proxy_resolver.cc
+++ b/net/proxy_resolution/multi_threaded_proxy_resolver.cc
@@ -239,7 +239,8 @@
DCHECK_NE(rv, ERR_IO_PENDING);
origin_runner->PostTask(
- FROM_HERE, base::Bind(&CreateResolverJob::RequestComplete, this, rv));
+ FROM_HERE,
+ base::BindOnce(&CreateResolverJob::RequestComplete, this, rv));
}
protected:
@@ -307,7 +308,7 @@
DCHECK_NE(rv, ERR_IO_PENDING);
origin_runner->PostTask(
- FROM_HERE, base::Bind(&GetProxyForURLJob::QueryComplete, this, rv));
+ FROM_HERE, base::BindOnce(&GetProxyForURLJob::QueryComplete, this, rv));
}
protected:
@@ -362,7 +363,7 @@
job->FinishedWaitingForThread();
thread_->task_runner()->PostTask(
FROM_HERE,
- base::Bind(&Job::Run, job, base::ThreadTaskRunnerHandle::Get()));
+ base::BindOnce(&Job::Run, job, base::ThreadTaskRunnerHandle::Get()));
}
void Executor::OnJobCompleted(Job* job) {
diff --git a/net/proxy_resolution/network_delegate_error_observer.cc b/net/proxy_resolution/network_delegate_error_observer.cc
index a588161..a898cb6 100644
--- a/net/proxy_resolution/network_delegate_error_observer.cc
+++ b/net/proxy_resolution/network_delegate_error_observer.cc
@@ -49,8 +49,9 @@
int line_number,
const base::string16& error) {
if (!origin_runner_->BelongsToCurrentThread()) {
- origin_runner_->PostTask(FROM_HERE, base::Bind(&Core::NotifyPACScriptError,
- this, line_number, error));
+ origin_runner_->PostTask(
+ FROM_HERE,
+ base::BindOnce(&Core::NotifyPACScriptError, this, line_number, error));
return;
}
if (network_delegate_)
diff --git a/net/proxy_resolution/network_delegate_error_observer_unittest.cc b/net/proxy_resolution/network_delegate_error_observer_unittest.cc
index bfb0867..0a13cab02 100644
--- a/net/proxy_resolution/network_delegate_error_observer_unittest.cc
+++ b/net/proxy_resolution/network_delegate_error_observer_unittest.cc
@@ -94,8 +94,9 @@
NetworkDelegateErrorObserver observer(
&network_delegate, base::ThreadTaskRunnerHandle::Get().get());
thread.task_runner()->PostTask(
- FROM_HERE, base::Bind(&NetworkDelegateErrorObserver::OnPACScriptError,
- base::Unretained(&observer), 42, base::string16()));
+ FROM_HERE,
+ base::BindOnce(&NetworkDelegateErrorObserver::OnPACScriptError,
+ base::Unretained(&observer), 42, base::string16()));
thread.Stop();
base::RunLoop().RunUntilIdle();
ASSERT_TRUE(network_delegate.got_pac_error());
@@ -109,8 +110,9 @@
NetworkDelegateErrorObserver observer(
NULL, base::ThreadTaskRunnerHandle::Get().get());
thread.task_runner()->PostTask(
- FROM_HERE, base::Bind(&NetworkDelegateErrorObserver::OnPACScriptError,
- base::Unretained(&observer), 42, base::string16()));
+ FROM_HERE,
+ base::BindOnce(&NetworkDelegateErrorObserver::OnPACScriptError,
+ base::Unretained(&observer), 42, base::string16()));
thread.Stop();
base::RunLoop().RunUntilIdle();
// Shouldn't have crashed until here...
diff --git a/net/proxy_resolution/pac_file_decider_unittest.cc b/net/proxy_resolution/pac_file_decider_unittest.cc
index fd10db4..216d3ba 100644
--- a/net/proxy_resolution/pac_file_decider_unittest.cc
+++ b/net/proxy_resolution/pac_file_decider_unittest.cc
@@ -797,8 +797,8 @@
const NetworkTrafficAnnotationTag traffic_annotation) override {
callback_ = std::move(callback);
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&AsyncFailDhcpFetcher::CallbackWithFailure, AsWeakPtr()));
+ FROM_HERE, base::BindOnce(&AsyncFailDhcpFetcher::CallbackWithFailure,
+ AsWeakPtr()));
return ERR_IO_PENDING;
}
diff --git a/net/proxy_resolution/pac_file_fetcher_impl.cc b/net/proxy_resolution/pac_file_fetcher_impl.cc
index 3a5b956..e9e919b 100644
--- a/net/proxy_resolution/pac_file_fetcher_impl.cc
+++ b/net/proxy_resolution/pac_file_fetcher_impl.cc
@@ -206,8 +206,8 @@
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
- base::Bind(&PacFileFetcherImpl::OnTimeout, weak_factory_.GetWeakPtr(),
- cur_request_id_),
+ base::BindOnce(&PacFileFetcherImpl::OnTimeout, weak_factory_.GetWeakPtr(),
+ cur_request_id_),
max_duration_);
// Start the request.
diff --git a/net/proxy_resolution/polling_proxy_config_service.cc b/net/proxy_resolution/polling_proxy_config_service.cc
index dc1a86d..793fd875 100644
--- a/net/proxy_resolution/polling_proxy_config_service.cc
+++ b/net/proxy_resolution/polling_proxy_config_service.cc
@@ -110,7 +110,7 @@
base::AutoLock lock(lock_);
if (origin_task_runner_.get()) {
origin_task_runner_->PostTask(
- FROM_HERE, base::Bind(&Core::GetConfigCompleted, this, config));
+ FROM_HERE, base::BindOnce(&Core::GetConfigCompleted, this, config));
}
}
diff --git a/net/proxy_resolution/proxy_config_service_android.cc b/net/proxy_resolution/proxy_config_service_android.cc
index 6134fd88..b55e5ee 100644
--- a/net/proxy_resolution/proxy_config_service_android.cc
+++ b/net/proxy_resolution/proxy_config_service_android.cc
@@ -307,7 +307,7 @@
ShutdownInJNISequence();
} else {
jni_task_runner_->PostTask(
- FROM_HERE, base::Bind(&Delegate::ShutdownInJNISequence, this));
+ FROM_HERE, base::BindOnce(&Delegate::ShutdownInJNISequence, this));
}
}
diff --git a/net/proxy_resolution/proxy_config_service_linux.cc b/net/proxy_resolution/proxy_config_service_linux.cc
index 72a81e5..e2ae592 100644
--- a/net/proxy_resolution/proxy_config_service_linux.cc
+++ b/net/proxy_resolution/proxy_config_service_linux.cc
@@ -1268,8 +1268,10 @@
SetUpNotifications();
} else {
// Post a task to set up notifications. We don't wait for success.
- required_loop->PostTask(FROM_HERE, base::Bind(
- &ProxyConfigServiceLinux::Delegate::SetUpNotifications, this));
+ required_loop->PostTask(
+ FROM_HERE,
+ base::BindOnce(
+ &ProxyConfigServiceLinux::Delegate::SetUpNotifications, this));
}
}
}
@@ -1340,8 +1342,8 @@
// update |cached_config_|.
main_task_runner_->PostTask(
FROM_HERE,
- base::Bind(&ProxyConfigServiceLinux::Delegate::SetNewProxyConfig, this,
- new_config));
+ base::BindOnce(&ProxyConfigServiceLinux::Delegate::SetNewProxyConfig,
+ this, new_config));
// Update the thread-private copy in |reference_config_| as well.
reference_config_ = new_config;
} else {
@@ -1373,8 +1375,9 @@
} else {
// Post to shutdown thread. Note that on browser shutdown, we may quit
// this MessageLoop and exit the program before ever running this.
- shutdown_loop->PostTask(FROM_HERE, base::Bind(
- &ProxyConfigServiceLinux::Delegate::OnDestroy, this));
+ shutdown_loop->PostTask(
+ FROM_HERE,
+ base::BindOnce(&ProxyConfigServiceLinux::Delegate::OnDestroy, this));
}
}
void ProxyConfigServiceLinux::Delegate::OnDestroy() {
diff --git a/net/proxy_resolution/proxy_config_service_linux_unittest.cc b/net/proxy_resolution/proxy_config_service_linux_unittest.cc
index cc63ce6..160c579 100644
--- a/net/proxy_resolution/proxy_config_service_linux_unittest.cc
+++ b/net/proxy_resolution/proxy_config_service_linux_unittest.cc
@@ -292,7 +292,8 @@
// Make sure the thread started.
main_thread_.task_runner()->PostTask(
- FROM_HERE, base::Bind(&SyncConfigGetter::Init, base::Unretained(this)));
+ FROM_HERE,
+ base::BindOnce(&SyncConfigGetter::Init, base::Unretained(this)));
Wait();
}
@@ -300,7 +301,7 @@
// Clean up the main thread.
main_thread_.task_runner()->PostTask(
FROM_HERE,
- base::Bind(&SyncConfigGetter::CleanUp, base::Unretained(this)));
+ base::BindOnce(&SyncConfigGetter::CleanUp, base::Unretained(this)));
Wait();
}
@@ -316,8 +317,8 @@
ProxyConfigService::ConfigAvailability SyncGetLatestProxyConfig(
ProxyConfigWithAnnotation* config) {
main_thread_.task_runner()->PostTask(
- FROM_HERE, base::Bind(&SyncConfigGetter::GetLatestConfigOnIOThread,
- base::Unretained(this)));
+ FROM_HERE, base::BindOnce(&SyncConfigGetter::GetLatestConfigOnIOThread,
+ base::Unretained(this)));
Wait();
*config = proxy_config_;
return get_latest_config_result_;
diff --git a/net/proxy_resolution/proxy_config_service_mac.cc b/net/proxy_resolution/proxy_config_service_mac.cc
index 3409321..1b81b26 100644
--- a/net/proxy_resolution/proxy_config_service_mac.cc
+++ b/net/proxy_resolution/proxy_config_service_mac.cc
@@ -269,7 +269,7 @@
// Call OnProxyConfigChanged() on the TakeRunner to notify our observers.
sequenced_task_runner_->PostTask(
FROM_HERE,
- base::Bind(&Helper::OnProxyConfigChanged, helper_.get(), new_config));
+ base::BindOnce(&Helper::OnProxyConfigChanged, helper_.get(), new_config));
}
void ProxyConfigServiceMac::OnProxyConfigChanged(
diff --git a/net/proxy_resolution/proxy_resolution_service.cc b/net/proxy_resolution/proxy_resolution_service.cc
index cf2a962..5aff9e25 100644
--- a/net/proxy_resolution/proxy_resolution_service.cc
+++ b/net/proxy_resolution/proxy_resolution_service.cc
@@ -704,7 +704,8 @@
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
- base::Bind(&PacFileDeciderPoller::DoPoll, weak_factory_.GetWeakPtr()),
+ base::BindOnce(&PacFileDeciderPoller::DoPoll,
+ weak_factory_.GetWeakPtr()),
next_poll_delay_);
}
@@ -751,7 +752,7 @@
// the notification.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(
+ base::BindOnce(
&PacFileDeciderPoller::NotifyProxyResolutionServiceOfChange,
weak_factory_.GetWeakPtr(), result, decider_->script_data(),
decider_->effective_config()));
diff --git a/net/proxy_resolution/proxy_resolver_v8_tracing.cc b/net/proxy_resolution/proxy_resolver_v8_tracing.cc
index d6f984b..8e16acc 100644
--- a/net/proxy_resolution/proxy_resolver_v8_tracing.cc
+++ b/net/proxy_resolution/proxy_resolver_v8_tracing.cc
@@ -471,7 +471,7 @@
CheckIsOnWorkerThread();
origin_runner_->PostTask(
- FROM_HERE, base::Bind(&Job::NotifyCallerOnOriginLoop, this, result));
+ FROM_HERE, base::BindOnce(&Job::NotifyCallerOnOriginLoop, this, result));
}
void Job::NotifyCallerOnOriginLoop(int result) {
@@ -699,7 +699,8 @@
DCHECK(!pending_dns_);
pending_dns_host_ = host;
pending_dns_op_ = op;
- origin_runner_->PostTask(FROM_HERE, base::Bind(&Job::DoDnsOperation, this));
+ origin_runner_->PostTask(FROM_HERE,
+ base::BindOnce(&Job::DoDnsOperation, this));
event_.Wait();
event_.Reset();
@@ -766,8 +767,8 @@
if (!blocking_dns_ && !pending_dns_completed_synchronously_) {
// Restart. This time it should make more progress due to having
// cached items.
- worker_task_runner()->PostTask(FROM_HERE,
- base::Bind(&Job::ExecuteNonBlocking, this));
+ worker_task_runner()->PostTask(
+ FROM_HERE, base::BindOnce(&Job::ExecuteNonBlocking, this));
}
}
@@ -842,8 +843,8 @@
if (blocking_dns_) {
// In blocking DNS mode the events can be dispatched immediately.
origin_runner_->PostTask(
- FROM_HERE, base::Bind(&Job::DispatchAlertOrErrorOnOriginThread, this,
- is_alert, line_number, message));
+ FROM_HERE, base::BindOnce(&Job::DispatchAlertOrErrorOnOriginThread,
+ this, is_alert, line_number, message));
return;
}
diff --git a/net/quic/bidirectional_stream_quic_impl.cc b/net/quic/bidirectional_stream_quic_impl.cc
index 68d2f64..9725e10 100644
--- a/net/quic/bidirectional_stream_quic_impl.cc
+++ b/net/quic/bidirectional_stream_quic_impl.cc
@@ -95,17 +95,17 @@
if (rv != OK) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamQuicImpl::NotifyError,
- weak_factory_.GetWeakPtr(),
- session_->IsCryptoHandshakeConfirmed()
- ? rv
- : ERR_QUIC_HANDSHAKE_FAILED));
+ FROM_HERE, base::BindOnce(&BidirectionalStreamQuicImpl::NotifyError,
+ weak_factory_.GetWeakPtr(),
+ session_->IsCryptoHandshakeConfirmed()
+ ? rv
+ : ERR_QUIC_HANDSHAKE_FAILED));
return;
}
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamQuicImpl::OnStreamReady,
- weak_factory_.GetWeakPtr(), rv));
+ FROM_HERE, base::BindOnce(&BidirectionalStreamQuicImpl::OnStreamReady,
+ weak_factory_.GetWeakPtr(), rv));
}
void BidirectionalStreamQuicImpl::SendRequestHeaders() {
@@ -113,8 +113,8 @@
int rv = WriteHeaders();
if (rv < 0) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamQuicImpl::NotifyError,
- weak_factory_.GetWeakPtr(), rv));
+ FROM_HERE, base::BindOnce(&BidirectionalStreamQuicImpl::NotifyError,
+ weak_factory_.GetWeakPtr(), rv));
}
}
@@ -174,8 +174,8 @@
if (!stream_->IsOpen()) {
LOG(ERROR) << "Trying to send data after stream has been closed.";
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamQuicImpl::NotifyError,
- weak_factory_.GetWeakPtr(), ERR_UNEXPECTED));
+ FROM_HERE, base::BindOnce(&BidirectionalStreamQuicImpl::NotifyError,
+ weak_factory_.GetWeakPtr(), ERR_UNEXPECTED));
return;
}
@@ -186,8 +186,8 @@
int rv = WriteHeaders();
if (rv < 0) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamQuicImpl::NotifyError,
- weak_factory_.GetWeakPtr(), rv));
+ FROM_HERE, base::BindOnce(&BidirectionalStreamQuicImpl::NotifyError,
+ weak_factory_.GetWeakPtr(), rv));
return;
}
}
@@ -199,8 +199,9 @@
if (rv != ERR_IO_PENDING) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamQuicImpl::OnSendDataComplete,
- weak_factory_.GetWeakPtr(), rv));
+ FROM_HERE,
+ base::BindOnce(&BidirectionalStreamQuicImpl::OnSendDataComplete,
+ weak_factory_.GetWeakPtr(), rv));
}
}
@@ -261,8 +262,9 @@
}
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamQuicImpl::ReadInitialHeaders,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE,
+ base::BindOnce(&BidirectionalStreamQuicImpl::ReadInitialHeaders,
+ weak_factory_.GetWeakPtr()));
NotifyStreamReady();
}
@@ -291,8 +293,9 @@
negotiated_protocol_ = kProtoQUIC;
connect_timing_ = session_->GetConnectTiming();
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamQuicImpl::ReadTrailingHeaders,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE,
+ base::BindOnce(&BidirectionalStreamQuicImpl::ReadTrailingHeaders,
+ weak_factory_.GetWeakPtr()));
if (delegate_)
delegate_->OnHeadersReceived(initial_headers_);
}
@@ -369,8 +372,9 @@
weak_factory_.InvalidateWeakPtrs();
if (notify_delegate_later) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamQuicImpl::NotifyFailure,
- weak_factory_.GetWeakPtr(), delegate, error));
+ FROM_HERE,
+ base::BindOnce(&BidirectionalStreamQuicImpl::NotifyFailure,
+ weak_factory_.GetWeakPtr(), delegate, error));
} else {
NotifyFailure(delegate, error);
// |this| might be destroyed at this point.
@@ -392,8 +396,8 @@
int rv = WriteHeaders();
if (rv < 0) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamQuicImpl::NotifyError,
- weak_factory_.GetWeakPtr(), rv));
+ FROM_HERE, base::BindOnce(&BidirectionalStreamQuicImpl::NotifyError,
+ weak_factory_.GetWeakPtr(), rv));
return;
}
}
diff --git a/net/quic/quic_chromium_alarm_factory.cc b/net/quic/quic_chromium_alarm_factory.cc
index 5475bfb..9124fb0 100644
--- a/net/quic/quic_chromium_alarm_factory.cc
+++ b/net/quic/quic_chromium_alarm_factory.cc
@@ -47,7 +47,7 @@
}
task_runner_->PostDelayedTask(
FROM_HERE,
- base::Bind(&QuicChromeAlarm::OnAlarm, weak_factory_.GetWeakPtr()),
+ base::BindOnce(&QuicChromeAlarm::OnAlarm, weak_factory_.GetWeakPtr()),
base::TimeDelta::FromMicroseconds(delay_us));
task_deadline_ = deadline();
}
diff --git a/net/quic/quic_chromium_client_session.cc b/net/quic/quic_chromium_client_session.cc
index f70d555..2436487a 100644
--- a/net/quic/quic_chromium_client_session.cc
+++ b/net/quic/quic_chromium_client_session.cc
@@ -587,8 +587,8 @@
// Avoid re-entrancy if the callback calls into the session.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&QuicChromiumClientSession::StreamRequest::DoCallback,
- weak_factory_.GetWeakPtr(), rv));
+ base::BindOnce(&QuicChromiumClientSession::StreamRequest::DoCallback,
+ weak_factory_.GetWeakPtr(), rv));
}
}
@@ -1773,9 +1773,9 @@
// Post a task to migrate the session onto a new network.
task_runner_->PostTask(
FROM_HERE,
- base::Bind(&QuicChromiumClientSession::MigrateSessionOnWriteError,
- weak_factory_.GetWeakPtr(), error_code,
- connection()->writer()));
+ base::BindOnce(&QuicChromiumClientSession::MigrateSessionOnWriteError,
+ weak_factory_.GetWeakPtr(), error_code,
+ connection()->writer()));
// Store packet in the session since the actual migration and packet rewrite
// can happen via this posted task or via an async network notification.
@@ -1893,8 +1893,8 @@
// Post a task to maybe close the session if the alarm fires.
task_runner_->PostDelayedTask(
FROM_HERE,
- base::Bind(&QuicChromiumClientSession::OnMigrationTimeout,
- weak_factory_.GetWeakPtr(), sockets_.size()),
+ base::BindOnce(&QuicChromiumClientSession::OnMigrationTimeout,
+ weak_factory_.GetWeakPtr(), sockets_.size()),
base::TimeDelta::FromSeconds(kWaitTimeForNewNetworkSecs));
}
@@ -2801,8 +2801,8 @@
DCHECK(!connection()->connected());
task_runner_->PostTask(
FROM_HERE,
- base::Bind(&QuicChromiumClientSession::NotifyFactoryOfSessionClosed,
- weak_factory_.GetWeakPtr()));
+ base::BindOnce(&QuicChromiumClientSession::NotifyFactoryOfSessionClosed,
+ weak_factory_.GetWeakPtr()));
}
void QuicChromiumClientSession::NotifyFactoryOfSessionClosed() {
@@ -2918,8 +2918,8 @@
// socket. This avoids reentrancy issues if there is a write error
// on the write to the new socket.
task_runner_->PostTask(
- FROM_HERE, base::Bind(&QuicChromiumClientSession::WriteToNewSocket,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&QuicChromiumClientSession::WriteToNewSocket,
+ weak_factory_.GetWeakPtr()));
return true;
}
diff --git a/net/quic/quic_chromium_client_stream.cc b/net/quic/quic_chromium_client_stream.cc
index 01ef6d1..3fc5eca5 100644
--- a/net/quic/quic_chromium_client_stream.cc
+++ b/net/quic/quic_chromium_client_stream.cc
@@ -126,8 +126,8 @@
// the call stack of the owner of the handle.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&QuicChromiumClientStream::Handle::InvokeCallbacksOnClose,
- weak_factory_.GetWeakPtr(), error));
+ base::BindOnce(&QuicChromiumClientStream::Handle::InvokeCallbacksOnClose,
+ weak_factory_.GetWeakPtr(), error));
}
void QuicChromiumClientStream::Handle::InvokeCallbacksOnClose(int error) {
@@ -620,7 +620,7 @@
DCHECK(handle_);
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(
+ base::BindOnce(
&QuicChromiumClientStream::NotifyHandleOfInitialHeadersAvailable,
weak_factory_.GetWeakPtr()));
}
@@ -637,7 +637,7 @@
DCHECK(handle_);
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(
+ base::BindOnce(
&QuicChromiumClientStream::NotifyHandleOfTrailingHeadersAvailable,
weak_factory_.GetWeakPtr()));
}
@@ -689,8 +689,8 @@
DCHECK(handle_);
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&QuicChromiumClientStream::NotifyHandleOfDataAvailable,
- weak_factory_.GetWeakPtr()));
+ base::BindOnce(&QuicChromiumClientStream::NotifyHandleOfDataAvailable,
+ weak_factory_.GetWeakPtr()));
}
void QuicChromiumClientStream::NotifyHandleOfDataAvailable() {
diff --git a/net/quic/quic_chromium_packet_reader.cc b/net/quic/quic_chromium_packet_reader.cc
index 49584bc..0f4c8cd6 100644
--- a/net/quic/quic_chromium_packet_reader.cc
+++ b/net/quic/quic_chromium_packet_reader.cc
@@ -63,8 +63,8 @@
// Schedule the work through the message loop to 1) prevent infinite
// recursion and 2) avoid blocking the thread for too long.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&QuicChromiumPacketReader::OnReadComplete,
- weak_factory_.GetWeakPtr(), rv));
+ FROM_HERE, base::BindOnce(&QuicChromiumPacketReader::OnReadComplete,
+ weak_factory_.GetWeakPtr(), rv));
} else {
if (!ProcessReadResult(rv)) {
return;
diff --git a/net/quic/quic_connectivity_probing_manager.cc b/net/quic/quic_connectivity_probing_manager.cc
index 98c6ea8b..78e8461 100644
--- a/net/quic/quic_connectivity_probing_manager.cc
+++ b/net/quic/quic_connectivity_probing_manager.cc
@@ -80,8 +80,8 @@
// undergoing probing, which will delete the packet writer.
task_runner_->PostTask(
FROM_HERE,
- base::Bind(&QuicConnectivityProbingManager::NotifyDelegateProbeFailed,
- weak_factory_.GetWeakPtr()));
+ base::BindOnce(&QuicConnectivityProbingManager::NotifyDelegateProbeFailed,
+ weak_factory_.GetWeakPtr()));
return error_code;
}
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index 3675488..734c258 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -123,8 +123,8 @@
int ReadInternal(IOBuffer* buf, int buf_len) override {
if (async_ == FailureMode::ASYNC) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&ReadErrorUploadDataStream::CompleteRead,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&ReadErrorUploadDataStream::CompleteRead,
+ weak_factory_.GetWeakPtr()));
return ERR_IO_PENDING;
}
return ERR_FAILED;
diff --git a/net/server/http_server.cc b/net/server/http_server.cc
index 49a3196..4c84b5d 100644
--- a/net/server/http_server.cc
+++ b/net/server/http_server.cc
@@ -62,8 +62,8 @@
// Start accepting connections in next run loop in case when delegate is not
// ready to get callbacks.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&HttpServer::DoAcceptLoop, weak_ptr_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&HttpServer::DoAcceptLoop,
+ weak_ptr_factory_.GetWeakPtr()));
}
HttpServer::~HttpServer() = default;
diff --git a/net/socket/client_socket_pool_base.cc b/net/socket/client_socket_pool_base.cc
index d391c3a..77bbb4a6 100644
--- a/net/socket/client_socket_pool_base.cc
+++ b/net/socket/client_socket_pool_base.cc
@@ -225,7 +225,7 @@
if (group->CanUseAdditionalSocketSlot(max_sockets_per_group_)) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(
+ base::BindOnce(
&ClientSocketPoolBaseHelper::TryToCloseSocketsInLayeredPools,
weak_factory_.GetWeakPtr()));
}
@@ -1129,8 +1129,8 @@
handle->socket()->ApplySocketTag(socket_tag);
}
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&ClientSocketPoolBaseHelper::InvokeUserCallback,
- weak_factory_.GetWeakPtr(), handle));
+ FROM_HERE, base::BindOnce(&ClientSocketPoolBaseHelper::InvokeUserCallback,
+ weak_factory_.GetWeakPtr(), handle));
}
void ClientSocketPoolBaseHelper::InvokeUserCallback(
diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
index a69642b..157503a 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -415,18 +415,18 @@
// time functions, so this change would be rather invasive.
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
- base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
- weak_factory_.GetWeakPtr(), true /* successful */,
- true /* async */, false /* recoverable */),
+ base::BindOnce(base::IgnoreResult(&TestConnectJob::DoConnect),
+ weak_factory_.GetWeakPtr(), true /* successful */,
+ true /* async */, false /* recoverable */),
base::TimeDelta::FromMilliseconds(kPendingConnectDelay));
return ERR_IO_PENDING;
case kMockPendingFailingJob:
set_load_state(LOAD_STATE_CONNECTING);
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
- base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
- weak_factory_.GetWeakPtr(), false /* error */,
- true /* async */, false /* recoverable */),
+ base::BindOnce(base::IgnoreResult(&TestConnectJob::DoConnect),
+ weak_factory_.GetWeakPtr(), false /* error */,
+ true /* async */, false /* recoverable */),
base::TimeDelta::FromMilliseconds(2));
return ERR_IO_PENDING;
case kMockWaitingJob:
@@ -441,9 +441,9 @@
set_load_state(LOAD_STATE_CONNECTING);
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
- base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
- weak_factory_.GetWeakPtr(), false /* error */,
- true /* async */, true /* recoverable */),
+ base::BindOnce(base::IgnoreResult(&TestConnectJob::DoConnect),
+ weak_factory_.GetWeakPtr(), false /* error */,
+ true /* async */, true /* recoverable */),
base::TimeDelta::FromMilliseconds(2));
return ERR_IO_PENDING;
case kMockAdditionalErrorStateJob:
@@ -455,9 +455,9 @@
store_additional_error_state_ = true;
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
- base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
- weak_factory_.GetWeakPtr(), false /* error */,
- true /* async */, false /* recoverable */),
+ base::BindOnce(base::IgnoreResult(&TestConnectJob::DoConnect),
+ weak_factory_.GetWeakPtr(), false /* error */,
+ true /* async */, false /* recoverable */),
base::TimeDelta::FromMilliseconds(2));
return ERR_IO_PENDING;
case kMockUnreadDataJob: {
diff --git a/net/socket/socket_bio_adapter.cc b/net/socket/socket_bio_adapter.cc
index 09b7eb4..f7975b8a 100644
--- a/net/socket/socket_bio_adapter.cc
+++ b/net/socket/socket_bio_adapter.cc
@@ -270,8 +270,8 @@
if (write_error_ != OK && write_error_ != ERR_IO_PENDING &&
read_result_ == ERR_IO_PENDING) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&SocketBIOAdapter::CallOnReadReady,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&SocketBIOAdapter::CallOnReadReady,
+ weak_factory_.GetWeakPtr()));
}
return bytes_copied;
diff --git a/net/socket/socket_test_util.cc b/net/socket/socket_test_util.cc
index ce65d44..8379d114 100644
--- a/net/socket/socket_test_util.cc
+++ b/net/socket/socket_test_util.cc
@@ -453,8 +453,8 @@
return MockRead(SYNCHRONOUS, ERR_IO_PENDING);
}
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&SequencedSocketData::OnReadComplete,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&SequencedSocketData::OnReadComplete,
+ weak_factory_.GetWeakPtr()));
CHECK_NE(COMPLETING, write_state_);
read_state_ = COMPLETING;
} else if (next_read.mode == SYNCHRONOUS) {
@@ -506,8 +506,8 @@
NET_TRACE(1, " *** ") << "Posting task to complete write";
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&SequencedSocketData::OnWriteComplete,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&SequencedSocketData::OnWriteComplete,
+ weak_factory_.GetWeakPtr()));
CHECK_NE(COMPLETING, read_state_);
write_state_ = COMPLETING;
} else if (next_write.mode == SYNCHRONOUS) {
@@ -624,8 +624,8 @@
NET_TRACE(1, " ****** ") << "Posting task to complete read: "
<< sequence_number_;
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&SequencedSocketData::OnReadComplete,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&SequencedSocketData::OnReadComplete,
+ weak_factory_.GetWeakPtr()));
CHECK_NE(COMPLETING, write_state_);
read_state_ = COMPLETING;
}
@@ -651,8 +651,8 @@
NET_TRACE(1, " ****** ") << "Posting task to complete write: "
<< sequence_number_;
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&SequencedSocketData::OnWriteComplete,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&SequencedSocketData::OnWriteComplete,
+ weak_factory_.GetWeakPtr()));
CHECK_NE(COMPLETING, read_state_);
write_state_ = COMPLETING;
}
diff --git a/net/socket/ssl_server_socket_unittest.cc b/net/socket/ssl_server_socket_unittest.cc
index 0f9e0ec..78bb3ca7 100644
--- a/net/socket/ssl_server_socket_unittest.cc
+++ b/net/socket/ssl_server_socket_unittest.cc
@@ -134,8 +134,8 @@
write_called_after_close_ = true;
write_callback_ = std::move(callback);
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&FakeDataChannel::DoWriteCallback,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&FakeDataChannel::DoWriteCallback,
+ weak_factory_.GetWeakPtr()));
return ERR_IO_PENDING;
}
// This function returns synchronously, so make a copy of the buffer.
@@ -143,8 +143,8 @@
base::MakeRefCounted<StringIOBuffer>(std::string(buf->data(), buf_len)),
buf_len));
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&FakeDataChannel::DoReadCallback,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&FakeDataChannel::DoReadCallback,
+ weak_factory_.GetWeakPtr()));
return buf_len;
}
@@ -156,8 +156,8 @@
closed_ = true;
if (!read_callback_.is_null()) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&FakeDataChannel::DoReadCallback,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&FakeDataChannel::DoReadCallback,
+ weak_factory_.GetWeakPtr()));
}
}
diff --git a/net/socket/udp_socket_unittest.cc b/net/socket/udp_socket_unittest.cc
index 5a06304..6a994d3 100644
--- a/net/socket/udp_socket_unittest.cc
+++ b/net/socket/udp_socket_unittest.cc
@@ -207,8 +207,8 @@
// Client sends to the server.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&UDPSocketTest::WriteSocketIgnoreResult,
- base::Unretained(this), client.get(), simple_message));
+ base::BindOnce(&UDPSocketTest::WriteSocketIgnoreResult,
+ base::Unretained(this), client.get(), simple_message));
run_loop.Run();
EXPECT_EQ(simple_message.length(), static_cast<size_t>(read_result));
EXPECT_EQ(simple_message, std::string(buffer_->data(), read_result));
diff --git a/net/socket/websocket_endpoint_lock_manager.cc b/net/socket/websocket_endpoint_lock_manager.cc
index 9acdaa8..cdf90aa 100644
--- a/net/socket/websocket_endpoint_lock_manager.cc
+++ b/net/socket/websocket_endpoint_lock_manager.cc
@@ -122,8 +122,8 @@
++pending_unlock_count_;
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
- base::Bind(&WebSocketEndpointLockManager::DelayedUnlockEndpoint,
- weak_factory_.GetWeakPtr(), endpoint),
+ base::BindOnce(&WebSocketEndpointLockManager::DelayedUnlockEndpoint,
+ weak_factory_.GetWeakPtr(), endpoint),
unlock_delay_);
}
diff --git a/net/spdy/bidirectional_stream_spdy_impl.cc b/net/spdy/bidirectional_stream_spdy_impl.cc
index 89f217a..f1281455 100644
--- a/net/spdy/bidirectional_stream_spdy_impl.cc
+++ b/net/spdy/bidirectional_stream_spdy_impl.cc
@@ -69,8 +69,8 @@
if (!spdy_session_) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&BidirectionalStreamSpdyImpl::NotifyError,
- weak_factory_.GetWeakPtr(), ERR_CONNECTION_CLOSED));
+ base::BindOnce(&BidirectionalStreamSpdyImpl::NotifyError,
+ weak_factory_.GetWeakPtr(), ERR_CONNECTION_CLOSED));
return;
}
@@ -122,8 +122,8 @@
if (written_end_of_stream_) {
LOG(ERROR) << "Writing after end of stream is written.";
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamSpdyImpl::NotifyError,
- weak_factory_.GetWeakPtr(), ERR_UNEXPECTED));
+ FROM_HERE, base::BindOnce(&BidirectionalStreamSpdyImpl::NotifyError,
+ weak_factory_.GetWeakPtr(), ERR_UNEXPECTED));
return;
}
@@ -397,14 +397,14 @@
// blackhole any pending write data. crbug.com/650438.
if (stream_closed_ && closed_stream_status_ == OK) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamSpdyImpl::OnDataSent,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&BidirectionalStreamSpdyImpl::OnDataSent,
+ weak_factory_.GetWeakPtr()));
return true;
}
LOG(ERROR) << "Trying to send data after stream has been destroyed.";
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&BidirectionalStreamSpdyImpl::NotifyError,
- weak_factory_.GetWeakPtr(), ERR_UNEXPECTED));
+ FROM_HERE, base::BindOnce(&BidirectionalStreamSpdyImpl::NotifyError,
+ weak_factory_.GetWeakPtr(), ERR_UNEXPECTED));
return true;
}
diff --git a/net/spdy/spdy_session.cc b/net/spdy/spdy_session.cc
index b8648e48..f63c127 100644
--- a/net/spdy/spdy_session.cc
+++ b/net/spdy/spdy_session.cc
@@ -1761,8 +1761,8 @@
// possible that the un-stalled stream will be stalled again if it loses.
// TODO(jgraettinger): Provide stronger ordering guarantees.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&SpdySession::CompleteStreamRequest,
- weak_factory_.GetWeakPtr(), pending_request));
+ FROM_HERE, base::BindOnce(&SpdySession::CompleteStreamRequest,
+ weak_factory_.GetWeakPtr(), pending_request));
}
}
@@ -1917,8 +1917,8 @@
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
- base::Bind(&SpdySession::CancelPushedStreamIfUnclaimed, GetWeakPtr(),
- stream_id),
+ base::BindOnce(&SpdySession::CancelPushedStreamIfUnclaimed, GetWeakPtr(),
+ stream_id),
base::TimeDelta::FromSeconds(kPushedStreamLifetimeSeconds));
net::NetworkTrafficAnnotationTag traffic_annotation =
@@ -2146,8 +2146,8 @@
time_func_() > yield_after_time)) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&SpdySession::PumpReadLoop, weak_factory_.GetWeakPtr(),
- READ_STATE_DO_READ, OK));
+ base::BindOnce(&SpdySession::PumpReadLoop, weak_factory_.GetWeakPtr(),
+ READ_STATE_DO_READ, OK));
result = ERR_IO_PENDING;
break;
}
@@ -2251,8 +2251,8 @@
write_state_ = WRITE_STATE_DO_WRITE;
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&SpdySession::PumpWriteLoop, weak_factory_.GetWeakPtr(),
- WRITE_STATE_DO_WRITE, OK));
+ base::BindOnce(&SpdySession::PumpWriteLoop, weak_factory_.GetWeakPtr(),
+ WRITE_STATE_DO_WRITE, OK));
}
}
@@ -2603,8 +2603,9 @@
check_ping_status_pending_ = true;
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, base::Bind(&SpdySession::CheckPingStatus,
- weak_factory_.GetWeakPtr(), time_func_()),
+ FROM_HERE,
+ base::BindOnce(&SpdySession::CheckPingStatus, weak_factory_.GetWeakPtr(),
+ time_func_()),
hung_interval_);
}
@@ -2629,8 +2630,9 @@
// Check the status of connection after a delay.
const base::TimeDelta delay = last_read_time_ + hung_interval_ - now;
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, base::Bind(&SpdySession::CheckPingStatus,
- weak_factory_.GetWeakPtr(), now),
+ FROM_HERE,
+ base::BindOnce(&SpdySession::CheckPingStatus, weak_factory_.GetWeakPtr(),
+ now),
delay);
}
diff --git a/net/spdy/spdy_stream.cc b/net/spdy/spdy_stream.cc
index e47e582..ccb43198 100644
--- a/net/spdy/spdy_stream.cc
+++ b/net/spdy/spdy_stream.cc
@@ -139,7 +139,8 @@
if (io_state_ == STATE_HALF_CLOSED_LOCAL_UNCLAIMED) {
DCHECK_EQ(type_, SPDY_PUSH_STREAM);
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&SpdyStream::PushedStreamReplay, GetWeakPtr()));
+ FROM_HERE,
+ base::BindOnce(&SpdyStream::PushedStreamReplay, GetWeakPtr()));
}
}
diff --git a/net/ssl/default_channel_id_store_unittest.cc b/net/ssl/default_channel_id_store_unittest.cc
index 4955c9c71..3f3ecb30 100644
--- a/net/ssl/default_channel_id_store_unittest.cc
+++ b/net/ssl/default_channel_id_store_unittest.cc
@@ -106,7 +106,7 @@
}
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(loaded_callback, base::Passed(&channel_ids)));
+ FROM_HERE, base::BindOnce(loaded_callback, std::move(channel_ids)));
}
void MockPersistentStore::AddChannelID(
diff --git a/net/test/embedded_test_server/embedded_test_server.cc b/net/test/embedded_test_server/embedded_test_server.cc
index 6578877c..dc86941 100644
--- a/net/test/embedded_test_server/embedded_test_server.cc
+++ b/net/test/embedded_test_server/embedded_test_server.cc
@@ -180,8 +180,8 @@
CHECK(io_thread_->WaitUntilThreadStarted());
io_thread_->task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&EmbeddedTestServer::DoAcceptLoop, base::Unretained(this)));
+ FROM_HERE, base::BindOnce(&EmbeddedTestServer::DoAcceptLoop,
+ base::Unretained(this)));
}
bool EmbeddedTestServer::ShutdownAndWaitUntilComplete() {
diff --git a/net/test/embedded_test_server/embedded_test_server_unittest.cc b/net/test/embedded_test_server/embedded_test_server_unittest.cc
index e117096..318fd6e4 100644
--- a/net/test/embedded_test_server/embedded_test_server_unittest.cc
+++ b/net/test/embedded_test_server/embedded_test_server_unittest.cc
@@ -425,9 +425,9 @@
void SendInfinite(const SendBytesCallback& send) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(send, "echo",
- base::Bind(&InfiniteResponse::SendInfinite,
- weak_ptr_factory_.GetWeakPtr(), send)));
+ base::BindOnce(send, "echo",
+ base::Bind(&InfiniteResponse::SendInfinite,
+ weak_ptr_factory_.GetWeakPtr(), send)));
}
base::WeakPtrFactory<InfiniteResponse> weak_ptr_factory_;
diff --git a/net/test/spawned_test_server/local_test_server_win.cc b/net/test/spawned_test_server/local_test_server_win.cc
index c117d62..06a9401e 100644
--- a/net/test/spawned_test_server/local_test_server_win.cc
+++ b/net/test/spawned_test_server/local_test_server_win.cc
@@ -54,7 +54,7 @@
// Prepare a timeout in case the server fails to start.
bool unblocked = false;
thread.task_runner()->PostDelayedTask(
- FROM_HERE, base::Bind(UnblockPipe, write_fd, bytes_max, &unblocked),
+ FROM_HERE, base::BindOnce(UnblockPipe, write_fd, bytes_max, &unblocked),
TestTimeouts::action_max_timeout());
DWORD bytes_read = 0;
diff --git a/net/test/url_request/ssl_certificate_error_job.cc b/net/test/url_request/ssl_certificate_error_job.cc
index d23f9ced..6391825 100644
--- a/net/test/url_request/ssl_certificate_error_job.cc
+++ b/net/test/url_request/ssl_certificate_error_job.cc
@@ -47,8 +47,8 @@
void SSLCertificateErrorJob::Start() {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&SSLCertificateErrorJob::NotifyError,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&SSLCertificateErrorJob::NotifyError,
+ weak_factory_.GetWeakPtr()));
}
void SSLCertificateErrorJob::AddUrlHandler() {
diff --git a/net/test/url_request/url_request_failed_job.cc b/net/test/url_request/url_request_failed_job.cc
index 71b7b462..a893f72 100644
--- a/net/test/url_request/url_request_failed_job.cc
+++ b/net/test/url_request/url_request_failed_job.cc
@@ -99,8 +99,8 @@
void URLRequestFailedJob::Start() {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&URLRequestFailedJob::StartAsync, weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&URLRequestFailedJob::StartAsync,
+ weak_factory_.GetWeakPtr()));
}
int URLRequestFailedJob::ReadRawData(IOBuffer* buf, int buf_size) {
@@ -109,8 +109,8 @@
return net_error_;
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestFailedJob::ReadRawDataComplete,
- weak_factory_.GetWeakPtr(), net_error_));
+ FROM_HERE, base::BindOnce(&URLRequestFailedJob::ReadRawDataComplete,
+ weak_factory_.GetWeakPtr(), net_error_));
return ERR_IO_PENDING;
}
diff --git a/net/test/url_request/url_request_hanging_read_job.cc b/net/test/url_request/url_request_hanging_read_job.cc
index 006e7bab..6790f6c 100644
--- a/net/test/url_request/url_request_hanging_read_job.cc
+++ b/net/test/url_request/url_request_hanging_read_job.cc
@@ -54,8 +54,8 @@
// Start reading asynchronously so that all error reporting and data
// callbacks happen as they would for network requests.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestHangingReadJob::StartAsync,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&URLRequestHangingReadJob::StartAsync,
+ weak_factory_.GetWeakPtr()));
}
URLRequestHangingReadJob::~URLRequestHangingReadJob() = default;
diff --git a/net/test/url_request/url_request_mock_data_job.cc b/net/test/url_request/url_request_mock_data_job.cc
index 9cef3e9..b6d5471 100644
--- a/net/test/url_request/url_request_mock_data_job.cc
+++ b/net/test/url_request/url_request_mock_data_job.cc
@@ -118,8 +118,8 @@
// Start reading asynchronously so that all error reporting and data
// callbacks happen as they would for network requests.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestMockDataJob::StartAsync,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&URLRequestMockDataJob::StartAsync,
+ weak_factory_.GetWeakPtr()));
}
URLRequestMockDataJob::~URLRequestMockDataJob() = default;
diff --git a/net/test/url_request/url_request_slow_download_job.cc b/net/test/url_request/url_request_slow_download_job.cc
index 72a2b5a..efce74d7 100644
--- a/net/test/url_request/url_request_slow_download_job.cc
+++ b/net/test/url_request/url_request_slow_download_job.cc
@@ -63,8 +63,8 @@
void URLRequestSlowDownloadJob::Start() {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestSlowDownloadJob::StartAsync,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&URLRequestSlowDownloadJob::StartAsync,
+ weak_factory_.GetWeakPtr()));
}
int64_t URLRequestSlowDownloadJob::GetTotalReceivedBytes() const {
@@ -203,8 +203,9 @@
buffer_ = buf;
buffer_size_ = buf_size;
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, base::Bind(&URLRequestSlowDownloadJob::CheckDoneStatus,
- weak_factory_.GetWeakPtr()),
+ FROM_HERE,
+ base::BindOnce(&URLRequestSlowDownloadJob::CheckDoneStatus,
+ weak_factory_.GetWeakPtr()),
base::TimeDelta::FromMilliseconds(100));
return ERR_IO_PENDING;
}
@@ -227,8 +228,9 @@
ReadRawDataComplete(ERR_CONNECTION_RESET);
} else {
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
- FROM_HERE, base::Bind(&URLRequestSlowDownloadJob::CheckDoneStatus,
- weak_factory_.GetWeakPtr()),
+ FROM_HERE,
+ base::BindOnce(&URLRequestSlowDownloadJob::CheckDoneStatus,
+ weak_factory_.GetWeakPtr()),
base::TimeDelta::FromMilliseconds(100));
}
}
diff --git a/net/tools/quic/quic_simple_server.cc b/net/tools/quic/quic_simple_server.cc
index 405c2dc9..6fd3830b 100644
--- a/net/tools/quic/quic_simple_server.cc
+++ b/net/tools/quic/quic_simple_server.cc
@@ -180,8 +180,8 @@
if (dispatcher_->HasChlosBuffered()) {
// No more packets to read, so yield before processing buffered packets.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&QuicSimpleServer::StartReading,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&QuicSimpleServer::StartReading,
+ weak_factory_.GetWeakPtr()));
}
return;
}
@@ -191,8 +191,8 @@
// Schedule the processing through the message loop to 1) prevent infinite
// recursion and 2) avoid blocking the thread for too long.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&QuicSimpleServer::OnReadComplete,
- weak_factory_.GetWeakPtr(), result));
+ FROM_HERE, base::BindOnce(&QuicSimpleServer::OnReadComplete,
+ weak_factory_.GetWeakPtr(), result));
} else {
OnReadComplete(result);
}
diff --git a/net/tools/stress_cache/stress_cache.cc b/net/tools/stress_cache/stress_cache.cc
index 879c3fbf..2483cebe 100644
--- a/net/tools/stress_cache/stress_cache.cc
+++ b/net/tools/stress_cache/stress_cache.cc
@@ -269,7 +269,7 @@
g_data->pendig_operations--;
DCHECK(g_data->pendig_operations);
base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- base::Bind(&LoopTask));
+ base::BindOnce(&LoopTask));
}
// The task that keeps the main thread busy. Whenever an entry becomes idle this
@@ -290,7 +290,7 @@
}
base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- base::Bind(&LoopTask));
+ base::BindOnce(&LoopTask));
}
// This thread will loop forever, adding and removing entries from the cache.
@@ -333,7 +333,7 @@
g_data->keys[i] = GenerateStressKey();
base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
- base::Bind(&LoopTask));
+ base::BindOnce(&LoopTask));
base::RunLoop().Run();
}
@@ -361,7 +361,7 @@
void RunSoon(scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
const base::TimeDelta kTaskDelay = base::TimeDelta::FromSeconds(10);
- task_runner->PostDelayedTask(FROM_HERE, base::Bind(&CrashCallback),
+ task_runner->PostDelayedTask(FROM_HERE, base::BindOnce(&CrashCallback),
kTaskDelay);
}
diff --git a/net/url_request/test_url_fetcher_factory.cc b/net/url_request/test_url_fetcher_factory.cc
index 916190f..c1d1ec1 100644
--- a/net/url_request/test_url_fetcher_factory.cc
+++ b/net/url_request/test_url_fetcher_factory.cc
@@ -399,7 +399,7 @@
TestURLFetcher::Start();
base::SequencedTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&FakeURLFetcher::RunDelegate, weak_factory_.GetWeakPtr()));
+ base::BindOnce(&FakeURLFetcher::RunDelegate, weak_factory_.GetWeakPtr()));
}
void FakeURLFetcher::RunDelegate() {
diff --git a/net/url_request/test_url_request_interceptor.cc b/net/url_request/test_url_request_interceptor.cc
index ae26295..6644369 100644
--- a/net/url_request/test_url_request_interceptor.cc
+++ b/net/url_request/test_url_request_interceptor.cc
@@ -155,24 +155,22 @@
network_task_runner_,
worker_task_runner)) {
network_task_runner_->PostTask(
- FROM_HERE, base::Bind(&Delegate::Register, base::Unretained(delegate_)));
+ FROM_HERE,
+ base::BindOnce(&Delegate::Register, base::Unretained(delegate_)));
}
TestURLRequestInterceptor::~TestURLRequestInterceptor() {
network_task_runner_->PostTask(
- FROM_HERE, base::Bind(&Delegate::Unregister, scheme_, hostname_));
+ FROM_HERE, base::BindOnce(&Delegate::Unregister, scheme_, hostname_));
}
void TestURLRequestInterceptor::SetResponse(const GURL& url,
const base::FilePath& path) {
CHECK_EQ(scheme_, url.scheme());
CHECK_EQ(hostname_, url.host());
- network_task_runner_->PostTask(FROM_HERE,
- base::Bind(&Delegate::SetResponse,
- base::Unretained(delegate_),
- url,
- path,
- false));
+ network_task_runner_->PostTask(
+ FROM_HERE, base::BindOnce(&Delegate::SetResponse,
+ base::Unretained(delegate_), url, path, false));
}
void TestURLRequestInterceptor::SetResponseIgnoreQuery(
@@ -180,12 +178,9 @@
const base::FilePath& path) {
CHECK_EQ(scheme_, url.scheme());
CHECK_EQ(hostname_, url.host());
- network_task_runner_->PostTask(FROM_HERE,
- base::Bind(&Delegate::SetResponse,
- base::Unretained(delegate_),
- url,
- path,
- true));
+ network_task_runner_->PostTask(
+ FROM_HERE, base::BindOnce(&Delegate::SetResponse,
+ base::Unretained(delegate_), url, path, true));
}
int TestURLRequestInterceptor::GetHitCount() {
diff --git a/net/url_request/url_fetcher_core.cc b/net/url_request/url_fetcher_core.cc
index 97a7e3c8..1759ff54 100644
--- a/net/url_request/url_fetcher_core.cc
+++ b/net/url_request/url_fetcher_core.cc
@@ -119,7 +119,7 @@
DCHECK(network_task_runner_.get()) << "We need an IO task runner";
network_task_runner_->PostTask(
- FROM_HERE, base::Bind(&URLFetcherCore::StartOnIOThread, this));
+ FROM_HERE, base::BindOnce(&URLFetcherCore::StartOnIOThread, this));
}
void URLFetcherCore::Stop() {
@@ -135,7 +135,7 @@
} else {
network_task_runner_->PostTask(
FROM_HERE,
- base::Bind(&URLFetcherCore::CancelURLRequest, this, ERR_ABORTED));
+ base::BindOnce(&URLFetcherCore::CancelURLRequest, this, ERR_ABORTED));
}
}
@@ -207,9 +207,8 @@
DCHECK(network_task_runner_.get());
DCHECK(is_chunked_upload_);
network_task_runner_->PostTask(
- FROM_HERE,
- base::Bind(&URLFetcherCore::CompleteAddingUploadDataChunk, this, content,
- is_last_chunk));
+ FROM_HERE, base::BindOnce(&URLFetcherCore::CompleteAddingUploadDataChunk,
+ this, content, is_last_chunk));
}
void URLFetcherCore::SetLoadFlags(int load_flags) {
@@ -361,7 +360,8 @@
DCHECK(delegate_task_runner_->RunsTasksInCurrentSequence());
if (network_task_runner_.get()) {
network_task_runner_->PostTask(
- FROM_HERE, base::Bind(&URLFetcherCore::NotifyMalformedContent, this));
+ FROM_HERE,
+ base::BindOnce(&URLFetcherCore::NotifyMalformedContent, this));
}
}
@@ -684,7 +684,7 @@
GetBackoffReleaseTime());
if (delay != 0) {
network_task_runner_->PostDelayedTask(
- FROM_HERE, base::Bind(&URLFetcherCore::StartURLRequest, this),
+ FROM_HERE, base::BindOnce(&URLFetcherCore::StartURLRequest, this),
base::TimeDelta::FromMilliseconds(delay));
return;
}
@@ -801,7 +801,7 @@
// Retry soon, after flushing all the current tasks which may include
// further network change observers.
network_task_runner_->PostTask(
- FROM_HERE, base::Bind(&URLFetcherCore::StartOnIOThread, this));
+ FROM_HERE, base::BindOnce(&URLFetcherCore::StartOnIOThread, this));
return;
}
@@ -810,8 +810,8 @@
url_request_data_key_ = NULL;
url_request_create_data_callback_.Reset();
bool posted = delegate_task_runner_->PostTask(
- FROM_HERE,
- base::Bind(&URLFetcherCore::OnCompletedURLRequest, this, backoff_delay));
+ FROM_HERE, base::BindOnce(&URLFetcherCore::OnCompletedURLRequest, this,
+ backoff_delay));
// If the delegate message loop does not exist any more, then the delegate
// should be gone too.
@@ -822,7 +822,7 @@
CancelURLRequest(result);
delegate_task_runner_->PostTask(
FROM_HERE,
- base::Bind(&URLFetcherCore::InformDelegateFetchIsComplete, this));
+ base::BindOnce(&URLFetcherCore::InformDelegateFetchIsComplete, this));
}
void URLFetcherCore::ReleaseRequest() {
@@ -924,7 +924,7 @@
}
delegate_task_runner_->PostTask(
FROM_HERE,
- base::Bind(
+ base::BindOnce(
&URLFetcherCore::InformDelegateUploadProgressInDelegateSequence,
this, current, total));
}
@@ -943,7 +943,7 @@
DCHECK(network_task_runner_->BelongsToCurrentThread());
delegate_task_runner_->PostTask(
FROM_HERE,
- base::Bind(
+ base::BindOnce(
&URLFetcherCore::InformDelegateDownloadProgressInDelegateSequence,
this, current_response_bytes_, total_response_bytes_,
request_->GetTotalReceivedBytes()));
diff --git a/net/url_request/url_fetcher_impl_unittest.cc b/net/url_request/url_fetcher_impl_unittest.cc
index eb3e20c..8c7283fa 100644
--- a/net/url_request/url_fetcher_impl_unittest.cc
+++ b/net/url_request/url_fetcher_impl_unittest.cc
@@ -264,11 +264,11 @@
if (!network_task_runner_->RunsTasksInCurrentSequence()) {
network_task_runner_->PostTask(
FROM_HERE,
- base::Bind(&FetcherTestURLRequestContextGetter::AddThrottlerEntry,
- this, url, url_id, sliding_window_period_ms,
- max_send_threshold, initial_backoff_ms, multiply_factor,
- jitter_factor, maximum_backoff_ms,
- reserve_sending_time_for_next_request));
+ base::BindOnce(&FetcherTestURLRequestContextGetter::AddThrottlerEntry,
+ this, url, url_id, sliding_window_period_ms,
+ max_send_threshold, initial_backoff_ms,
+ multiply_factor, jitter_factor, maximum_backoff_ms,
+ reserve_sending_time_for_next_request));
return;
}
scoped_refptr<URLRequestThrottlerEntry> entry(new URLRequestThrottlerEntry(
@@ -289,7 +289,7 @@
if (!network_task_runner_->RunsTasksInCurrentSequence()) {
network_task_runner_->PostTask(
FROM_HERE,
- base::Bind(&FetcherTestURLRequestContextGetter::Shutdown, this));
+ base::BindOnce(&FetcherTestURLRequestContextGetter::Shutdown, this));
return;
}
diff --git a/net/url_request/url_fetcher_response_writer.cc b/net/url_request/url_fetcher_response_writer.cc
index ecd81fef0..ca0e9f9 100644
--- a/net/url_request/url_fetcher_response_writer.cc
+++ b/net/url_request/url_fetcher_response_writer.cc
@@ -166,10 +166,9 @@
file_stream_.reset();
DisownFile();
- file_task_runner_->PostTask(FROM_HERE,
- base::Bind(base::IgnoreResult(&base::DeleteFile),
- file_path_,
- false /* recursive */));
+ file_task_runner_->PostTask(
+ FROM_HERE, base::BindOnce(base::IgnoreResult(&base::DeleteFile),
+ file_path_, false /* recursive */));
}
void URLFetcherFileWriter::DidCreateTempFile(base::FilePath* temp_file_path,
diff --git a/net/url_request/url_request_error_job.cc b/net/url_request/url_request_error_job.cc
index 85ab61f2..0eda199 100644
--- a/net/url_request/url_request_error_job.cc
+++ b/net/url_request/url_request_error_job.cc
@@ -24,8 +24,8 @@
void URLRequestErrorJob::Start() {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&URLRequestErrorJob::StartAsync, weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&URLRequestErrorJob::StartAsync,
+ weak_factory_.GetWeakPtr()));
}
void URLRequestErrorJob::Kill() {
diff --git a/net/url_request/url_request_file_dir_job.cc b/net/url_request/url_request_file_dir_job.cc
index cb630a5..ca05b6c3 100644
--- a/net/url_request/url_request_file_dir_job.cc
+++ b/net/url_request/url_request_file_dir_job.cc
@@ -52,8 +52,8 @@
// Start reading asynchronously so that all error reporting and data
// callbacks happen as they would for network requests.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestFileDirJob::StartAsync,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&URLRequestFileDirJob::StartAsync,
+ weak_factory_.GetWeakPtr()));
}
void URLRequestFileDirJob::Kill() {
diff --git a/net/url_request/url_request_ftp_job.cc b/net/url_request/url_request_ftp_job.cc
index b62f09d..d1fb951 100644
--- a/net/url_request/url_request_ftp_job.cc
+++ b/net/url_request/url_request_ftp_job.cc
@@ -255,8 +255,8 @@
void URLRequestFtpJob::OnStartCompletedAsync(int result) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestFtpJob::OnStartCompleted,
- weak_factory_.GetWeakPtr(), result));
+ FROM_HERE, base::BindOnce(&URLRequestFtpJob::OnStartCompleted,
+ weak_factory_.GetWeakPtr(), result));
}
void URLRequestFtpJob::OnReadCompleted(int result) {
diff --git a/net/url_request/url_request_http_job.cc b/net/url_request/url_request_http_job.cc
index 884edf75..6c00978 100644
--- a/net/url_request/url_request_http_job.cc
+++ b/net/url_request/url_request_http_job.cc
@@ -559,9 +559,9 @@
// Don't call back synchronously to the delegate.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&URLRequestHttpJob::NotifyStartError,
- weak_factory_.GetWeakPtr(),
- URLRequestStatus(URLRequestStatus::FAILED, result)));
+ base::BindOnce(&URLRequestHttpJob::NotifyStartError,
+ weak_factory_.GetWeakPtr(),
+ URLRequestStatus(URLRequestStatus::FAILED, result)));
}
}
@@ -637,8 +637,8 @@
// The transaction started synchronously, but we need to notify the
// URLRequest delegate via the message loop.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestHttpJob::OnStartCompleted,
- weak_factory_.GetWeakPtr(), rv));
+ FROM_HERE, base::BindOnce(&URLRequestHttpJob::OnStartCompleted,
+ weak_factory_.GetWeakPtr(), rv));
}
void URLRequestHttpJob::AddExtraHeaders() {
@@ -1233,8 +1233,8 @@
// We have to do this via InvokeLater to avoid "recursing" the consumer.
//
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestHttpJob::OnStartCompleted,
- weak_factory_.GetWeakPtr(), OK));
+ FROM_HERE, base::BindOnce(&URLRequestHttpJob::OnStartCompleted,
+ weak_factory_.GetWeakPtr(), OK));
}
void URLRequestHttpJob::ContinueWithCertificate(
@@ -1257,8 +1257,8 @@
// The transaction started synchronously, but we need to notify the
// URLRequest delegate via the message loop.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestHttpJob::OnStartCompleted,
- weak_factory_.GetWeakPtr(), rv));
+ FROM_HERE, base::BindOnce(&URLRequestHttpJob::OnStartCompleted,
+ weak_factory_.GetWeakPtr(), rv));
}
void URLRequestHttpJob::ContinueDespiteLastError() {
@@ -1280,8 +1280,8 @@
// The transaction started synchronously, but we need to notify the
// URLRequest delegate via the message loop.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestHttpJob::OnStartCompleted,
- weak_factory_.GetWeakPtr(), rv));
+ FROM_HERE, base::BindOnce(&URLRequestHttpJob::OnStartCompleted,
+ weak_factory_.GetWeakPtr(), rv));
}
bool URLRequestHttpJob::ShouldFixMismatchedContentLength(int rv) const {
diff --git a/net/url_request/url_request_job.cc b/net/url_request/url_request_job.cc
index dc7c3d2..b24a0bc 100644
--- a/net/url_request/url_request_job.cc
+++ b/net/url_request/url_request_job.cc
@@ -568,7 +568,7 @@
// delegate if we're done because of a synchronous call.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
- base::Bind(&URLRequestJob::NotifyDone, weak_factory_.GetWeakPtr()));
+ base::BindOnce(&URLRequestJob::NotifyDone, weak_factory_.GetWeakPtr()));
}
}
diff --git a/net/url_request/url_request_job_factory_impl_unittest.cc b/net/url_request/url_request_job_factory_impl_unittest.cc
index efbccd9..7f887ea 100644
--- a/net/url_request/url_request_job_factory_impl_unittest.cc
+++ b/net/url_request/url_request_job_factory_impl_unittest.cc
@@ -36,8 +36,8 @@
// Start reading asynchronously so that all error reporting and data
// callbacks happen as they would for network requests.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&MockURLRequestJob::StartAsync, weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&MockURLRequestJob::StartAsync,
+ weak_factory_.GetWeakPtr()));
}
protected:
diff --git a/net/url_request/url_request_redirect_job.cc b/net/url_request/url_request_redirect_job.cc
index 9950fe6..6a2c2c60 100644
--- a/net/url_request/url_request_redirect_job.cc
+++ b/net/url_request/url_request_redirect_job.cc
@@ -66,8 +66,8 @@
NetLogEventType::URL_REQUEST_REDIRECT_JOB,
NetLog::StringCallback("reason", &redirect_reason_));
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestRedirectJob::StartAsync,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&URLRequestRedirectJob::StartAsync,
+ weak_factory_.GetWeakPtr()));
}
void URLRequestRedirectJob::Kill() {
diff --git a/net/url_request/url_request_simple_job.cc b/net/url_request/url_request_simple_job.cc
index 77acb7d..6b5b585 100644
--- a/net/url_request/url_request_simple_job.cc
+++ b/net/url_request/url_request_simple_job.cc
@@ -44,8 +44,8 @@
// Start reading asynchronously so that all error reporting and data
// callbacks happen as they would for network requests.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&URLRequestSimpleJob::StartAsync, weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&URLRequestSimpleJob::StartAsync,
+ weak_factory_.GetWeakPtr()));
}
void URLRequestSimpleJob::Kill() {
diff --git a/net/url_request/url_request_test_job.cc b/net/url_request/url_request_test_job.cc
index 5353577..6e7c1b7 100644
--- a/net/url_request/url_request_test_job.cc
+++ b/net/url_request/url_request_test_job.cc
@@ -199,8 +199,8 @@
// Start reading asynchronously so that all error reporting and data
// callbacks happen as they would for network requests.
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&URLRequestTestJob::StartAsync, weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&URLRequestTestJob::StartAsync,
+ weak_factory_.GetWeakPtr()));
}
void URLRequestTestJob::StartAsync() {
@@ -269,8 +269,8 @@
if (stage_ != WAITING) {
stage_ = WAITING;
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestTestJob::ProcessNextOperation,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&URLRequestTestJob::ProcessNextOperation,
+ weak_factory_.GetWeakPtr()));
}
return ERR_IO_PENDING;
}
@@ -363,8 +363,8 @@
void URLRequestTestJob::AdvanceJob() {
if (auto_advance_) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&URLRequestTestJob::ProcessNextOperation,
- weak_factory_.GetWeakPtr()));
+ FROM_HERE, base::BindOnce(&URLRequestTestJob::ProcessNextOperation,
+ weak_factory_.GetWeakPtr()));
return;
}
g_pending_jobs.Get().push_back(this);
diff --git a/net/websockets/websocket_channel_test.cc b/net/websockets/websocket_channel_test.cc
index c7fbb58a0..b6fa071 100644
--- a/net/websockets/websocket_channel_test.cc
+++ b/net/websockets/websocket_channel_test.cc
@@ -611,8 +611,8 @@
private:
void PostCallback() {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&EchoeyFakeWebSocketStream::DoCallback,
- base::Unretained(this)));
+ FROM_HERE, base::BindOnce(&EchoeyFakeWebSocketStream::DoCallback,
+ base::Unretained(this)));
}
void DoCallback() {
diff --git a/net/websockets/websocket_end_to_end_test.cc b/net/websockets/websocket_end_to_end_test.cc
index 0d729a0..b1ad596 100644
--- a/net/websockets/websocket_end_to_end_test.cc
+++ b/net/websockets/websocket_end_to_end_test.cc
@@ -202,9 +202,9 @@
const SSLInfo& ssl_info,
bool fatal) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE, base::Bind(&SSLErrorCallbacks::CancelSSLRequest,
- base::Owned(ssl_error_callbacks.release()),
- ERR_SSL_PROTOCOL_ERROR, &ssl_info));
+ FROM_HERE, base::BindOnce(&SSLErrorCallbacks::CancelSSLRequest,
+ base::Owned(ssl_error_callbacks.release()),
+ ERR_SSL_PROTOCOL_ERROR, &ssl_info));
}
int ConnectTestingEventInterface::OnAuthRequired(
