Rename TaskRunner::RunsTasksOnCurrentThread() in //net

net/http/http_server_properties_manager.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_server_properties_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 63 matching lines @@
 
 HttpServerPropertiesManager::HttpServerPropertiesManager(
     PrefDelegate* pref_delegate,
     scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner)
     : pref_task_runner_(std::move(pref_task_runner)),
       pref_delegate_(pref_delegate),
       setting_prefs_(false),
       is_initialized_(false),
       network_task_runner_(std::move(network_task_runner)) {
-  DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(pref_delegate_);
   pref_weak_ptr_factory_.reset(
       new base::WeakPtrFactory<HttpServerPropertiesManager>(this));
   pref_weak_ptr_ = pref_weak_ptr_factory_->GetWeakPtr();
   pref_cache_update_timer_.reset(new base::OneShotTimer);
   pref_cache_update_timer_->SetTaskRunner(pref_task_runner_);
   pref_delegate_->StartListeningForUpdates(
       base::Bind(&HttpServerPropertiesManager::OnHttpServerPropertiesChanged,
                  base::Unretained(this)));
 }
 
 HttpServerPropertiesManager::~HttpServerPropertiesManager() {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   network_weak_ptr_factory_.reset();
 }
 
-void HttpServerPropertiesManager::InitializeOnNetworkThread() {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+void HttpServerPropertiesManager::InitializeOnNetworkSequence() {
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
 
   network_weak_ptr_factory_.reset(
       new base::WeakPtrFactory<HttpServerPropertiesManager>(this));
   http_server_properties_impl_.reset(new HttpServerPropertiesImpl());
 
   network_prefs_update_timer_.reset(new base::OneShotTimer);
   network_prefs_update_timer_->SetTaskRunner(network_task_runner_);
-  // UpdateCacheFromPrefsOnPrefThread() will post a task to network thread to
+  // UpdateCacheFromPrefsOnPrefSequence() will post a task to network thread to
   // update server properties. SetInitialized() will be run after that task is
   // run as |network_task_runner_| is single threaded.
   pref_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefThread,
-                 pref_weak_ptr_),
+      base::Bind(
+          &HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence,
+          pref_weak_ptr_),
       base::Bind(&HttpServerPropertiesManager::SetInitialized,
                  network_weak_ptr_factory_->GetWeakPtr()));
 }
 
-void HttpServerPropertiesManager::ShutdownOnPrefThread() {
-  DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
+void HttpServerPropertiesManager::ShutdownOnPrefSequence() {
+  DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
   // Cancel any pending updates, and stop listening for pref change updates.
   pref_cache_update_timer_->Stop();
   pref_weak_ptr_factory_.reset();
   pref_delegate_->StopListeningForUpdates();
 }
 
 // static
 void HttpServerPropertiesManager::SetVersion(
     base::DictionaryValue* http_server_properties_dict,
     int version_number) {
   if (version_number < 0)
     version_number = kVersionNumber;
   DCHECK_LE(version_number, kVersionNumber);
   if (version_number <= kVersionNumber)
     http_server_properties_dict->SetInteger(kVersionKey, version_number);
 }
 
 void HttpServerPropertiesManager::Clear() {
   Clear(base::Closure());
 }
 
 void HttpServerPropertiesManager::Clear(const base::Closure& completion) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
 
   http_server_properties_impl_->Clear();
-  UpdatePrefsFromCacheOnNetworkThread(completion);
+  UpdatePrefsFromCacheOnNetworkSequence(completion);
 }
 
 bool HttpServerPropertiesManager::SupportsRequestPriority(
     const url::SchemeHostPort& server) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->SupportsRequestPriority(server);
 }
 
 bool HttpServerPropertiesManager::GetSupportsSpdy(
     const url::SchemeHostPort& server) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->GetSupportsSpdy(server);
 }
 
 void HttpServerPropertiesManager::SetSupportsSpdy(
     const url::SchemeHostPort& server,
     bool support_spdy) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
 
   bool old_support_spdy = http_server_properties_impl_->GetSupportsSpdy(server);
   http_server_properties_impl_->SetSupportsSpdy(server, support_spdy);
   bool new_support_spdy = http_server_properties_impl_->GetSupportsSpdy(server);
   if (old_support_spdy != new_support_spdy)
-    ScheduleUpdatePrefsOnNetworkThread(SUPPORTS_SPDY);
+    ScheduleUpdatePrefsOnNetworkSequence(SUPPORTS_SPDY);
 }
 
 bool HttpServerPropertiesManager::RequiresHTTP11(const HostPortPair& server) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->RequiresHTTP11(server);
 }
 
 void HttpServerPropertiesManager::SetHTTP11Required(
     const HostPortPair& server) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
 
   http_server_properties_impl_->SetHTTP11Required(server);
-  ScheduleUpdatePrefsOnNetworkThread(HTTP_11_REQUIRED);
+  ScheduleUpdatePrefsOnNetworkSequence(HTTP_11_REQUIRED);
 }
 
 void HttpServerPropertiesManager::MaybeForceHTTP11(const HostPortPair& server,
                                                    SSLConfig* ssl_config) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   http_server_properties_impl_->MaybeForceHTTP11(server, ssl_config);
 }
 
 AlternativeServiceInfoVector
 HttpServerPropertiesManager::GetAlternativeServiceInfos(
     const url::SchemeHostPort& origin) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->GetAlternativeServiceInfos(origin);
 }
 
 bool HttpServerPropertiesManager::SetAlternativeService(
     const url::SchemeHostPort& origin,
     const AlternativeService& alternative_service,
     base::Time expiration) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   const bool changed = http_server_properties_impl_->SetAlternativeService(
       origin, alternative_service, expiration);
   if (changed) {
-    ScheduleUpdatePrefsOnNetworkThread(SET_ALTERNATIVE_SERVICES);
+    ScheduleUpdatePrefsOnNetworkSequence(SET_ALTERNATIVE_SERVICES);
   }
   return changed;
 }
 
 bool HttpServerPropertiesManager::SetAlternativeServices(
     const url::SchemeHostPort& origin,
     const AlternativeServiceInfoVector& alternative_service_info_vector) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   const bool changed = http_server_properties_impl_->SetAlternativeServices(
       origin, alternative_service_info_vector);
   if (changed) {
-    ScheduleUpdatePrefsOnNetworkThread(SET_ALTERNATIVE_SERVICES);
+    ScheduleUpdatePrefsOnNetworkSequence(SET_ALTERNATIVE_SERVICES);
   }
   return changed;
 }
 
 void HttpServerPropertiesManager::MarkAlternativeServiceBroken(
     const AlternativeService& alternative_service) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   http_server_properties_impl_->MarkAlternativeServiceBroken(
       alternative_service);
-  ScheduleUpdatePrefsOnNetworkThread(MARK_ALTERNATIVE_SERVICE_BROKEN);
+  ScheduleUpdatePrefsOnNetworkSequence(MARK_ALTERNATIVE_SERVICE_BROKEN);
 }
 
 void HttpServerPropertiesManager::MarkAlternativeServiceRecentlyBroken(
     const AlternativeService& alternative_service) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   http_server_properties_impl_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
-  ScheduleUpdatePrefsOnNetworkThread(MARK_ALTERNATIVE_SERVICE_RECENTLY_BROKEN);
+  ScheduleUpdatePrefsOnNetworkSequence(
+      MARK_ALTERNATIVE_SERVICE_RECENTLY_BROKEN);
 }
 
 bool HttpServerPropertiesManager::IsAlternativeServiceBroken(
     const AlternativeService& alternative_service) const {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->IsAlternativeServiceBroken(
       alternative_service);
 }
 
 bool HttpServerPropertiesManager::WasAlternativeServiceRecentlyBroken(
     const AlternativeService& alternative_service) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->WasAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
 void HttpServerPropertiesManager::ConfirmAlternativeService(
     const AlternativeService& alternative_service) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   bool old_value = http_server_properties_impl_->IsAlternativeServiceBroken(
       alternative_service);
   http_server_properties_impl_->ConfirmAlternativeService(alternative_service);
   bool new_value = http_server_properties_impl_->IsAlternativeServiceBroken(
       alternative_service);
   // For persisting, we only care about the value returned by
   // IsAlternativeServiceBroken. If that value changes, then call persist.
   if (old_value != new_value)
-    ScheduleUpdatePrefsOnNetworkThread(CONFIRM_ALTERNATIVE_SERVICE);
+    ScheduleUpdatePrefsOnNetworkSequence(CONFIRM_ALTERNATIVE_SERVICE);
 }
 
 const AlternativeServiceMap&
 HttpServerPropertiesManager::alternative_service_map() const {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->alternative_service_map();
 }
 
 std::unique_ptr<base::Value>
 HttpServerPropertiesManager::GetAlternativeServiceInfoAsValue() const {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->GetAlternativeServiceInfoAsValue();
 }
 
 bool HttpServerPropertiesManager::GetSupportsQuic(
     IPAddress* last_address) const {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->GetSupportsQuic(last_address);
 }
 
 void HttpServerPropertiesManager::SetSupportsQuic(bool used_quic,
                                                   const IPAddress& address) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   IPAddress old_last_quic_addr;
   http_server_properties_impl_->GetSupportsQuic(&old_last_quic_addr);
   http_server_properties_impl_->SetSupportsQuic(used_quic, address);
   IPAddress new_last_quic_addr;
   http_server_properties_impl_->GetSupportsQuic(&new_last_quic_addr);
   if (old_last_quic_addr != new_last_quic_addr)
-    ScheduleUpdatePrefsOnNetworkThread(SET_SUPPORTS_QUIC);
+    ScheduleUpdatePrefsOnNetworkSequence(SET_SUPPORTS_QUIC);
 }
 
 void HttpServerPropertiesManager::SetServerNetworkStats(
     const url::SchemeHostPort& server,
     ServerNetworkStats stats) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   ServerNetworkStats old_stats;
   const ServerNetworkStats* old_stats_ptr =
       http_server_properties_impl_->GetServerNetworkStats(server);
   if (http_server_properties_impl_->GetServerNetworkStats(server))
     old_stats = *old_stats_ptr;
   http_server_properties_impl_->SetServerNetworkStats(server, stats);
   ServerNetworkStats new_stats =
       *(http_server_properties_impl_->GetServerNetworkStats(server));
   if (old_stats != new_stats)
-    ScheduleUpdatePrefsOnNetworkThread(SET_SERVER_NETWORK_STATS);
+    ScheduleUpdatePrefsOnNetworkSequence(SET_SERVER_NETWORK_STATS);
 }
 
 void HttpServerPropertiesManager::ClearServerNetworkStats(
     const url::SchemeHostPort& server) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   bool need_update =
       http_server_properties_impl_->GetServerNetworkStats(server) != nullptr;
   http_server_properties_impl_->ClearServerNetworkStats(server);
   if (need_update)
-    ScheduleUpdatePrefsOnNetworkThread(CLEAR_SERVER_NETWORK_STATS);
+    ScheduleUpdatePrefsOnNetworkSequence(CLEAR_SERVER_NETWORK_STATS);
 }
 
 const ServerNetworkStats* HttpServerPropertiesManager::GetServerNetworkStats(
     const url::SchemeHostPort& server) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->GetServerNetworkStats(server);
 }
 
 const ServerNetworkStatsMap&
 HttpServerPropertiesManager::server_network_stats_map() const {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->server_network_stats_map();
 }
 
 bool HttpServerPropertiesManager::SetQuicServerInfo(
     const QuicServerId& server_id,
     const std::string& server_info) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   bool changed =
       http_server_properties_impl_->SetQuicServerInfo(server_id, server_info);
   if (changed)
-    ScheduleUpdatePrefsOnNetworkThread(SET_QUIC_SERVER_INFO);
+    ScheduleUpdatePrefsOnNetworkSequence(SET_QUIC_SERVER_INFO);
   return changed;
 }
 
 const std::string* HttpServerPropertiesManager::GetQuicServerInfo(
     const QuicServerId& server_id) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->GetQuicServerInfo(server_id);
 }
 
 const QuicServerInfoMap& HttpServerPropertiesManager::quic_server_info_map()
     const {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->quic_server_info_map();
 }
 
 size_t HttpServerPropertiesManager::max_server_configs_stored_in_properties()
     const {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_
       ->max_server_configs_stored_in_properties();
 }
 
 void HttpServerPropertiesManager::SetMaxServerConfigsStoredInProperties(
     size_t max_server_configs_stored_in_properties) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   return http_server_properties_impl_->SetMaxServerConfigsStoredInProperties(
       max_server_configs_stored_in_properties);
 }
 
 bool HttpServerPropertiesManager::IsInitialized() const {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
 
   return is_initialized_;
 }
 
 // static
 base::TimeDelta HttpServerPropertiesManager::GetUpdateCacheDelayForTesting() {
   return kUpdateCacheDelay;
 }
 
 // static
 base::TimeDelta HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting() {
   return kUpdatePrefsDelay;
 }
 
 //
 // Update the HttpServerPropertiesImpl's cache with data from preferences.
 //
 void HttpServerPropertiesManager::ScheduleUpdateCacheOnPrefThread() {
-  DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
   // Do not schedule a new update if there is already one scheduled.
   if (pref_cache_update_timer_->IsRunning())
     return;
 
   pref_cache_update_timer_->Start(
       FROM_HERE, kUpdateCacheDelay, this,
-      &HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefThread);
+      &HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence);
 }
 
-void HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefThread() {
+void HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence() {
   // The preferences can only be read on the pref thread.
-  DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
 
   if (!pref_delegate_->HasServerProperties())
     return;
 
   bool detected_corrupted_prefs = false;
   const base::DictionaryValue& http_server_properties_dict =
       pref_delegate_->GetServerProperties();
 
   int version = kMissingVersion;
   if (!http_server_properties_dict.GetIntegerWithoutPathExpansion(kVersionKey,
@@ skipping 90 matching lines @@
   }
 
   if (!AddToQuicServerInfoMap(http_server_properties_dict,
                               quic_server_info_map.get())) {
     detected_corrupted_prefs = true;
   }
 
   network_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
-          &HttpServerPropertiesManager::UpdateCacheFromPrefsOnNetworkThread,
+          &HttpServerPropertiesManager::UpdateCacheFromPrefsOnNetworkSequence,
           base::Unretained(this), base::Owned(spdy_servers.release()),
           base::Owned(alternative_service_map.release()), base::Owned(addr),
           base::Owned(server_network_stats_map.release()),
           base::Owned(quic_server_info_map.release()),
           detected_corrupted_prefs));
 }
 
 bool HttpServerPropertiesManager::AddServersData(
     const base::DictionaryValue& servers_dict,
     ServerList* spdy_servers,
@@ skipping 236 matching lines @@
       DVLOG(1) << "Malformed http_server_properties quic server info: "
                << quic_server_id_str;
       detected_corrupted_prefs = true;
       continue;
     }
     quic_server_info_map->Put(quic_server_id, quic_server_info);
   }
   return !detected_corrupted_prefs;
 }
 
-void HttpServerPropertiesManager::UpdateCacheFromPrefsOnNetworkThread(
+void HttpServerPropertiesManager::UpdateCacheFromPrefsOnNetworkSequence(
     ServerList* spdy_servers,
     AlternativeServiceMap* alternative_service_map,
     IPAddress* last_quic_address,
     ServerNetworkStatsMap* server_network_stats_map,
     QuicServerInfoMap* quic_server_info_map,
     bool detected_corrupted_prefs) {
   // Preferences have the master data because admins might have pushed new
   // preferences. Update the cached data with new data from preferences.
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
 
   UMA_HISTOGRAM_COUNTS("Net.CountOfSpdyServers", spdy_servers->size());
   http_server_properties_impl_->SetSpdyServers(spdy_servers, true);
 
   // Update the cached data and use the new alternative service list from
   // preferences.
   UMA_HISTOGRAM_COUNTS("Net.CountOfAlternateProtocolServers",
                        alternative_service_map->size());
   http_server_properties_impl_->SetAlternativeServiceServers(
       alternative_service_map);
 
   http_server_properties_impl_->SetSupportsQuic(last_quic_address);
 
   http_server_properties_impl_->SetServerNetworkStats(server_network_stats_map);
 
   UMA_HISTOGRAM_COUNTS_1000("Net.CountOfQuicServerInfos",
                             quic_server_info_map->size());
 
   http_server_properties_impl_->SetQuicServerInfoMap(quic_server_info_map);
 
   // Update the prefs with what we have read (delete all corrupted prefs).
   if (detected_corrupted_prefs)
-    ScheduleUpdatePrefsOnNetworkThread(DETECTED_CORRUPTED_PREFS);
+    ScheduleUpdatePrefsOnNetworkSequence(DETECTED_CORRUPTED_PREFS);
 }
 
 //
 // Update Preferences with data from the cached data.
 //
-void HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkThread(
+void HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkSequence(
     Location location) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   // Do not schedule a new update if there is already one scheduled.
   if (network_prefs_update_timer_->IsRunning())
     return;
 
   network_prefs_update_timer_->Start(
       FROM_HERE, kUpdatePrefsDelay, this,
-      &HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkThread);
+      &HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkSequence);
 
   // TODO(rtenneti): Delete the following histogram after collecting some data.
   UMA_HISTOGRAM_ENUMERATION("Net.HttpServerProperties.UpdatePrefs", location,
                             HttpServerPropertiesManager::NUM_LOCATIONS);
 }
 
 // This is required so we can set this as the callback for a timer.
-void HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkThread() {
-  UpdatePrefsFromCacheOnNetworkThread(base::Closure());
+void HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkSequence() {
+  UpdatePrefsFromCacheOnNetworkSequence(base::Closure());
 }
 
-void HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkThread(
+void HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkSequence(
     const base::Closure& completion) {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
 
   // It is in MRU order.
   base::ListValue* spdy_server_list = new base::ListValue;
   http_server_properties_impl_->GetSpdyServerList(
       spdy_server_list, kMaxSupportsSpdyServerHostsToPersist);
 
   AlternativeServiceMap* alternative_service_map =
       new AlternativeServiceMap(kMaxAlternateProtocolHostsToPersist);
   const AlternativeServiceMap& map =
       http_server_properties_impl_->alternative_service_map();
@@ skipping 110 matching lines @@
 void HttpServerPropertiesManager::UpdatePrefsOnPrefThread(
     base::ListValue* spdy_server_list,
     AlternativeServiceMap* alternative_service_map,
     IPAddress* last_quic_address,
     ServerNetworkStatsMap* server_network_stats_map,
     QuicServerInfoMap* quic_server_info_map,
     const base::Closure& completion) {
   typedef base::MRUCache<url::SchemeHostPort, ServerPref> ServerPrefMap;
   ServerPrefMap server_pref_map(ServerPrefMap::NO_AUTO_EVICT);
 
-  DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
 
   // Add servers that support spdy to server_pref_map in the MRU order.
   for (size_t index = spdy_server_list->GetSize(); index > 0; --index) {
     std::string server_str;
     if (spdy_server_list->GetString(index - 1, &server_str)) {
       url::SchemeHostPort server((GURL(server_str)));
       ServerPrefMap::iterator it = server_pref_map.Get(server);
       if (it == server_pref_map.end()) {
         ServerPref server_pref;
         server_pref.supports_spdy = true;
@@ skipping 158 matching lines @@
     quic_server_pref_dict->SetStringWithoutPathExpansion(kServerInfoKey,
                                                          entry.second);
     quic_servers_dict->SetWithoutPathExpansion(
         server_id.ToString(), std::move(quic_server_pref_dict));
   }
   http_server_properties_dict->SetWithoutPathExpansion(
       kQuicServers, std::move(quic_servers_dict));
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
-  DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(pref_task_runner_->RunsTasksInCurrentSequence());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 void HttpServerPropertiesManager::SetInitialized() {
-  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(network_task_runner_->RunsTasksInCurrentSequence());
   is_initialized_ = true;
 }
 
 }  // namespace net