Rename TaskRunner::RunsTasksOnCurrentThread() in //net

net/http/http_server_properties_manager_unittest.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 <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 73 matching lines @@
       HttpServerPropertiesManager::PrefDelegate* pref_delegate,
       scoped_refptr<TestMockTimeTaskRunner> pref_task_runner,
       scoped_refptr<TestMockTimeTaskRunner> net_task_runner)
       : HttpServerPropertiesManager(pref_delegate,
                                     pref_task_runner,
                                     net_task_runner),
         pref_task_runner_(std::move(pref_task_runner)),
         net_task_runner_(std::move(net_task_runner)) {
     // This call must run in the context of |net_task_runner_|.
     TestMockTimeTaskRunner::ScopedContext scoped_context(net_task_runner_);
-    HttpServerPropertiesManager::InitializeOnNetworkThread();
+    HttpServerPropertiesManager::InitializeOnNetworkSequence();
   }
 
   ~TestingHttpServerPropertiesManager() override {}
 
   // Make these methods public for testing.
   using HttpServerPropertiesManager::ScheduleUpdateCacheOnPrefThread;
 
   void UpdateCacheFromPrefsOnUIConcrete() {
     TestMockTimeTaskRunner::ScopedContext scoped_context(pref_task_runner_);
-    HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefThread();
+    HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefSequence();
   }
 
-  void UpdatePrefsFromCacheOnNetworkThreadConcrete(
+  void UpdatePrefsFromCacheOnNetworkSequenceConcrete(
       const base::Closure& callback) {
     TestMockTimeTaskRunner::ScopedContext scoped_context(net_task_runner_);
-    HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkThread(callback);
+    HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkSequence(
+        callback);
   }
 
-  void ScheduleUpdatePrefsOnNetworkThreadConcrete(Location location) {
+  void ScheduleUpdatePrefsOnNetworkSequenceConcrete(Location location) {
     TestMockTimeTaskRunner::ScopedContext scoped_context(net_task_runner_);
-    HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkThread(location);
+    HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkSequence(location);
   }
 
-  void ScheduleUpdatePrefsOnNetworkThreadDefault() {
+  void ScheduleUpdatePrefsOnNetworkSequenceDefault() {
     TestMockTimeTaskRunner::ScopedContext scoped_context(net_task_runner_);
     // Picked a random Location as caller.
-    HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkThread(
+    HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkSequence(
         DETECTED_CORRUPTED_PREFS);
   }
 
-  MOCK_METHOD0(UpdateCacheFromPrefsOnPrefThread, void());
-  MOCK_METHOD1(UpdatePrefsFromCacheOnNetworkThread, void(const base::Closure&));
-  MOCK_METHOD1(ScheduleUpdatePrefsOnNetworkThread, void(Location location));
-  MOCK_METHOD6(UpdateCacheFromPrefsOnNetworkThread,
+  MOCK_METHOD0(UpdateCacheFromPrefsOnPrefSequence, void());
+  MOCK_METHOD1(UpdatePrefsFromCacheOnNetworkSequence,
+               void(const base::Closure&));
+  MOCK_METHOD1(ScheduleUpdatePrefsOnNetworkSequence, void(Location location));
+  MOCK_METHOD6(UpdateCacheFromPrefsOnNetworkSequence,
                void(std::vector<std::string>* spdy_servers,
                     AlternativeServiceMap* alternative_service_map,
                     IPAddress* last_quic_address,
                     ServerNetworkStatsMap* server_network_stats_map,
                     QuicServerInfoMap* quic_server_info_map,
                     bool detected_corrupted_prefs));
   MOCK_METHOD6(UpdatePrefsOnPrefThread,
                void(base::ListValue* spdy_server_list,
                     AlternativeServiceMap* alternative_service_map,
                     IPAddress* last_quic_address,
@@ skipping 33 matching lines @@
     EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
     pref_test_task_runner_->RunUntilIdle();
     net_test_task_runner_->RunUntilIdle();
     EXPECT_TRUE(http_server_props_manager_->IsInitialized());
     EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
     EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   }
 
   void TearDown() override {
     if (http_server_props_manager_.get())
-      http_server_props_manager_->ShutdownOnPrefThread();
+      http_server_props_manager_->ShutdownOnPrefSequence();
     // Run pending non-delayed tasks but don't FastForwardUntilNoTasksRemain()
     // as some delayed tasks may forever repost (e.g. because impl doesn't use a
     // mock clock and doesn't see timings as having expired, ref.
     // HttpServerPropertiesImpl::
     //     ScheduleBrokenAlternateProtocolMappingsExpiration()).
     pref_test_task_runner_->RunUntilIdle();
     net_test_task_runner_->RunUntilIdle();
     http_server_props_manager_.reset();
   }
 
   void ExpectCacheUpdate() {
-    EXPECT_CALL(*http_server_props_manager_, UpdateCacheFromPrefsOnPrefThread())
+    EXPECT_CALL(*http_server_props_manager_,
+                UpdateCacheFromPrefsOnPrefSequence())
         .WillOnce(Invoke(http_server_props_manager_.get(),
                          &TestingHttpServerPropertiesManager::
                              UpdateCacheFromPrefsOnUIConcrete));
   }
 
-  void ExpectScheduleUpdatePrefsOnNetworkThread() {
+  void ExpectScheduleUpdatePrefsOnNetworkSequence() {
     EXPECT_CALL(*http_server_props_manager_,
-                ScheduleUpdatePrefsOnNetworkThread(_))
+                ScheduleUpdatePrefsOnNetworkSequence(_))
         .WillOnce(Invoke(http_server_props_manager_.get(),
                          &TestingHttpServerPropertiesManager::
-                             ScheduleUpdatePrefsOnNetworkThreadConcrete));
+                             ScheduleUpdatePrefsOnNetworkSequenceConcrete));
   }
 
-  void ExpectScheduleUpdatePrefsOnNetworkThreadRepeatedly(int times) {
+  void ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(int times) {
     EXPECT_CALL(*http_server_props_manager_,
-                ScheduleUpdatePrefsOnNetworkThread(_))
+                ScheduleUpdatePrefsOnNetworkSequence(_))
         .Times(AtLeast(times))
-        .WillRepeatedly(Invoke(http_server_props_manager_.get(),
-                               &TestingHttpServerPropertiesManager::
-                                   ScheduleUpdatePrefsOnNetworkThreadConcrete));
+        .WillRepeatedly(
+            Invoke(http_server_props_manager_.get(),
+                   &TestingHttpServerPropertiesManager::
+                       ScheduleUpdatePrefsOnNetworkSequenceConcrete));
   }
 
   void ExpectPrefsUpdate(int times) {
     EXPECT_CALL(*http_server_props_manager_,
-                UpdatePrefsFromCacheOnNetworkThread(_))
+                UpdatePrefsFromCacheOnNetworkSequence(_))
         .Times(times)
         .WillRepeatedly(
             Invoke(http_server_props_manager_.get(),
                    &TestingHttpServerPropertiesManager::
-                       UpdatePrefsFromCacheOnNetworkThreadConcrete));
+                       UpdatePrefsFromCacheOnNetworkSequenceConcrete));
   }
 
   bool HasAlternativeService(const url::SchemeHostPort& server) {
     const AlternativeServiceInfoVector alternative_service_info_vector =
         http_server_props_manager_->GetAlternativeServiceInfos(server);
     return !alternative_service_info_vector.empty();
   }
 
   MockPrefDelegate* pref_delegate_;  // Owned by HttpServerPropertiesManager.
   std::unique_ptr<TestingHttpServerPropertiesManager>
@@ skipping 236 matching lines @@
   EXPECT_EQ(quic_server_info2, *http_server_props_manager_->GetQuicServerInfo(
                                    mail_quic_server_id));
   EXPECT_EQ(quic_server_info3, *http_server_props_manager_->GetQuicServerInfo(
                                    play_quic_server_id));
 }
 
 TEST_P(HttpServerPropertiesManagerTest, BadCachedHostPortPair) {
   ExpectCacheUpdate();
   // The prefs are automatically updated in the case corruption is detected.
   ExpectPrefsUpdate(1);
-  ExpectScheduleUpdatePrefsOnNetworkThread();
+  ExpectScheduleUpdatePrefsOnNetworkSequence();
 
   auto server_pref_dict = base::MakeUnique<base::DictionaryValue>();
 
   // Set supports_spdy for www.google.com:65536.
   server_pref_dict->SetBoolean("supports_spdy", true);
 
   // Set up alternative_service for www.google.com:65536.
   auto alternative_service_dict = base::MakeUnique<base::DictionaryValue>();
   alternative_service_dict->SetString("protocol_str", "h2");
   alternative_service_dict->SetInteger("port", 80);
@@ skipping 68 matching lines @@
   const ServerNetworkStats* stats1 =
       http_server_props_manager_->GetServerNetworkStats(gooler_server);
   EXPECT_EQ(nullptr, stats1);
   EXPECT_EQ(0u, http_server_props_manager_->quic_server_info_map().size());
 }
 
 TEST_P(HttpServerPropertiesManagerTest, BadCachedAltProtocolPort) {
   ExpectCacheUpdate();
   // The prefs are automatically updated in the case corruption is detected.
   ExpectPrefsUpdate(1);
-  ExpectScheduleUpdatePrefsOnNetworkThread();
+  ExpectScheduleUpdatePrefsOnNetworkSequence();
 
   auto server_pref_dict = base::MakeUnique<base::DictionaryValue>();
 
   // Set supports_spdy for www.google.com:80.
   server_pref_dict->SetBoolean("supports_spdy", true);
 
   // Set up alternative_service for www.google.com:80.
   auto alternative_service_dict = base::MakeUnique<base::DictionaryValue>();
   alternative_service_dict->SetString("protocol_str", "h2");
   alternative_service_dict->SetInteger("port", 65536);
@@ skipping 40 matching lines @@
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   // Verify alternative service is not set.
   EXPECT_FALSE(
       HasAlternativeService(url::SchemeHostPort("http", "www.google.com", 80)));
 }
 
 TEST_P(HttpServerPropertiesManagerTest, SupportsSpdy) {
   ExpectPrefsUpdate(1);
-  ExpectScheduleUpdatePrefsOnNetworkThread();
+  ExpectScheduleUpdatePrefsOnNetworkSequence();
 
   // Post an update task to the network thread. SetSupportsSpdy calls
-  // ScheduleUpdatePrefsOnNetworkThread.
+  // ScheduleUpdatePrefsOnNetworkSequence.
 
   // Add mail.google.com:443 as a supporting spdy server.
   url::SchemeHostPort spdy_server("https", "mail.google.com", 443);
   EXPECT_FALSE(
       http_server_props_manager_->SupportsRequestPriority(spdy_server));
   http_server_props_manager_->SetSupportsSpdy(spdy_server, true);
-  // ExpectScheduleUpdatePrefsOnNetworkThread() should be called only once.
+  // ExpectScheduleUpdatePrefsOnNetworkSequence() should be called only once.
   http_server_props_manager_->SetSupportsSpdy(spdy_server, true);
 
   // Run the task.
   EXPECT_TRUE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   net_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 
   EXPECT_TRUE(http_server_props_manager_->SupportsRequestPriority(spdy_server));
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 }
 
 // Regression test for crbug.com/670519. Test that there is only one pref update
 // scheduled if multiple updates happen in a given time period. Subsequent pref
 // update could also be scheduled once the previous scheduled update is
 // completed.
 TEST_P(HttpServerPropertiesManagerTest,
        SinglePrefUpdateForTwoSpdyServerCacheChanges) {
   ExpectPrefsUpdate(2);
-  ExpectScheduleUpdatePrefsOnNetworkThreadRepeatedly(3);
+  ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(3);
 
   // Post an update task to the network thread. SetSupportsSpdy calls
-  // ScheduleUpdatePrefsOnNetworkThread with a delay of 60ms.
+  // ScheduleUpdatePrefsOnNetworkSequence with a delay of 60ms.
   url::SchemeHostPort spdy_server("https", "mail.google.com", 443);
   EXPECT_FALSE(
       http_server_props_manager_->SupportsRequestPriority(spdy_server));
   http_server_props_manager_->SetSupportsSpdy(spdy_server, true);
   // The pref update task should be scheduled to network thread.
   EXPECT_EQ(1u, net_test_task_runner_->GetPendingTaskCount());
 
   // Move forward the task runner short by 20ms.
   net_test_task_runner_->FastForwardBy(
       HttpServerPropertiesManager::GetUpdatePrefsDelayForTesting() -
       base::TimeDelta::FromMilliseconds(20));
 
   // Set another spdy server to trigger another call to
-  // ScheduleUpdatePrefsOnNetworkThread. There should be no new update posted to
-  // the network thread.
+  // ScheduleUpdatePrefsOnNetworkSequence. There should be no new update posted
+  // to the network thread.
   url::SchemeHostPort spdy_server2("https", "drive.google.com", 443);
   http_server_props_manager_->SetSupportsSpdy(spdy_server2, true);
   EXPECT_EQ(1u, net_test_task_runner_->GetPendingTaskCount());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 
   // Move forward the extra 20ms. The pref update should be executed.
   net_test_task_runner_->FastForwardBy(base::TimeDelta::FromMilliseconds(20));
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 
   EXPECT_TRUE(http_server_props_manager_->SupportsRequestPriority(spdy_server));
   EXPECT_TRUE(
       http_server_props_manager_->SupportsRequestPriority(spdy_server2));
   // Set the third spdy server to trigger one more call to
-  // ScheduleUpdatePrefsOnNetworkThread. A new update task should be posted to
+  // ScheduleUpdatePrefsOnNetworkSequence. A new update task should be posted to
   // network thread now since the previous one is completed.
   url::SchemeHostPort spdy_server3("https", "maps.google.com", 443);
   http_server_props_manager_->SetSupportsSpdy(spdy_server3, true);
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_EQ(1u, net_test_task_runner_->GetPendingTaskCount());
 
   // Run the task.
   EXPECT_TRUE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   net_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 }
 
 TEST_P(HttpServerPropertiesManagerTest, GetAlternativeServiceInfos) {
   ExpectPrefsUpdate(1);
-  ExpectScheduleUpdatePrefsOnNetworkThread();
+  ExpectScheduleUpdatePrefsOnNetworkSequence();
 
   url::SchemeHostPort spdy_server_mail("http", "mail.google.com", 80);
   EXPECT_FALSE(HasAlternativeService(spdy_server_mail));
   const AlternativeService alternative_service(kProtoHTTP2, "mail.google.com",
                                                443);
   http_server_props_manager_->SetAlternativeService(
       spdy_server_mail, alternative_service, one_day_from_now_);
-  // ExpectScheduleUpdatePrefsOnNetworkThread() should be called only once.
+  // ExpectScheduleUpdatePrefsOnNetworkSequence() should be called only once.
   http_server_props_manager_->SetAlternativeService(
       spdy_server_mail, alternative_service, one_day_from_now_);
 
   // Run the task.
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_TRUE(net_test_task_runner_->HasPendingTask());
   net_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   AlternativeServiceInfoVector alternative_service_info_vector =
       http_server_props_manager_->GetAlternativeServiceInfos(spdy_server_mail);
   ASSERT_EQ(1u, alternative_service_info_vector.size());
   EXPECT_EQ(alternative_service,
             alternative_service_info_vector[0].alternative_service);
 }
 
 TEST_P(HttpServerPropertiesManagerTest, SetAlternativeServices) {
   ExpectPrefsUpdate(1);
-  ExpectScheduleUpdatePrefsOnNetworkThread();
+  ExpectScheduleUpdatePrefsOnNetworkSequence();
 
   url::SchemeHostPort spdy_server_mail("http", "mail.google.com", 80);
   EXPECT_FALSE(HasAlternativeService(spdy_server_mail));
   AlternativeServiceInfoVector alternative_service_info_vector;
   const AlternativeService alternative_service1(kProtoHTTP2, "mail.google.com",
                                                 443);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service1, one_day_from_now_));
   const AlternativeService alternative_service2(kProtoQUIC, "mail.google.com",
                                                 1234);
   alternative_service_info_vector.push_back(
       AlternativeServiceInfo(alternative_service2, one_day_from_now_));
   http_server_props_manager_->SetAlternativeServices(
       spdy_server_mail, alternative_service_info_vector);
-  // ExpectScheduleUpdatePrefsOnNetworkThread() should be called only once.
+  // ExpectScheduleUpdatePrefsOnNetworkSequence() should be called only once.
   http_server_props_manager_->SetAlternativeServices(
       spdy_server_mail, alternative_service_info_vector);
 
   // Run the task.
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_TRUE(net_test_task_runner_->HasPendingTask());
   net_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
@@ skipping 11 matching lines @@
 }
 
 TEST_P(HttpServerPropertiesManagerTest, SetAlternativeServicesEmpty) {
   url::SchemeHostPort spdy_server_mail("http", "mail.google.com", 80);
   EXPECT_FALSE(HasAlternativeService(spdy_server_mail));
   const AlternativeService alternative_service(kProtoHTTP2, "mail.google.com",
                                                443);
   http_server_props_manager_->SetAlternativeServices(
       spdy_server_mail, AlternativeServiceInfoVector());
 
-  // ExpectScheduleUpdatePrefsOnNetworkThread() should not be called.
+  // ExpectScheduleUpdatePrefsOnNetworkSequence() should not be called.
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   EXPECT_FALSE(HasAlternativeService(spdy_server_mail));
 }
 
 TEST_P(HttpServerPropertiesManagerTest, ConfirmAlternativeService) {
   ExpectPrefsUpdate(1);
 
   url::SchemeHostPort spdy_server_mail;
   AlternativeService alternative_service;
 
   {
     TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_);
 
     spdy_server_mail = url::SchemeHostPort("http", "mail.google.com", 80);
     EXPECT_FALSE(HasAlternativeService(spdy_server_mail));
     alternative_service =
         AlternativeService(kProtoHTTP2, "mail.google.com", 443);
 
-    ExpectScheduleUpdatePrefsOnNetworkThread();
+    ExpectScheduleUpdatePrefsOnNetworkSequence();
     http_server_props_manager_->SetAlternativeService(
         spdy_server_mail, alternative_service, one_day_from_now_);
 
     EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken(
         alternative_service));
     EXPECT_FALSE(
         http_server_props_manager_->WasAlternativeServiceRecentlyBroken(
             alternative_service));
 
-    ExpectScheduleUpdatePrefsOnNetworkThread();
+    ExpectScheduleUpdatePrefsOnNetworkSequence();
     http_server_props_manager_->MarkAlternativeServiceBroken(
         alternative_service);
     EXPECT_TRUE(http_server_props_manager_->IsAlternativeServiceBroken(
         alternative_service));
     EXPECT_TRUE(http_server_props_manager_->WasAlternativeServiceRecentlyBroken(
         alternative_service));
 
-    ExpectScheduleUpdatePrefsOnNetworkThread();
+    ExpectScheduleUpdatePrefsOnNetworkSequence();
     http_server_props_manager_->ConfirmAlternativeService(alternative_service);
     EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken(
         alternative_service));
     EXPECT_FALSE(
         http_server_props_manager_->WasAlternativeServiceRecentlyBroken(
             alternative_service));
-    // ExpectScheduleUpdatePrefsOnNetworkThread() should be called only once.
+    // ExpectScheduleUpdatePrefsOnNetworkSequence() should be called only once.
     http_server_props_manager_->ConfirmAlternativeService(alternative_service);
     EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken(
         alternative_service));
     EXPECT_FALSE(
         http_server_props_manager_->WasAlternativeServiceRecentlyBroken(
             alternative_service));
   }
 
   // Run the task.
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
@@ skipping 11 matching lines @@
     EXPECT_FALSE(http_server_props_manager_->IsAlternativeServiceBroken(
         alternative_service));
     EXPECT_FALSE(
         http_server_props_manager_->WasAlternativeServiceRecentlyBroken(
             alternative_service));
   }
 }
 
 TEST_P(HttpServerPropertiesManagerTest, SupportsQuic) {
   ExpectPrefsUpdate(1);
-  ExpectScheduleUpdatePrefsOnNetworkThread();
+  ExpectScheduleUpdatePrefsOnNetworkSequence();
 
   IPAddress address;
   EXPECT_FALSE(http_server_props_manager_->GetSupportsQuic(&address));
 
   IPAddress actual_address(127, 0, 0, 1);
   http_server_props_manager_->SetSupportsQuic(true, actual_address);
-  // ExpectScheduleUpdatePrefsOnNetworkThread() should be called only once.
+  // ExpectScheduleUpdatePrefsOnNetworkSequence() should be called only once.
   http_server_props_manager_->SetSupportsQuic(true, actual_address);
 
   // Run the task.
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_TRUE(net_test_task_runner_->HasPendingTask());
   net_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   EXPECT_TRUE(http_server_props_manager_->GetSupportsQuic(&address));
   EXPECT_EQ(actual_address, address);
 }
 
 TEST_P(HttpServerPropertiesManagerTest, ServerNetworkStats) {
   ExpectPrefsUpdate(1);
-  ExpectScheduleUpdatePrefsOnNetworkThread();
+  ExpectScheduleUpdatePrefsOnNetworkSequence();
 
   url::SchemeHostPort mail_server("http", "mail.google.com", 80);
   const ServerNetworkStats* stats =
       http_server_props_manager_->GetServerNetworkStats(mail_server);
   EXPECT_EQ(nullptr, stats);
   ServerNetworkStats stats1;
   stats1.srtt = base::TimeDelta::FromMicroseconds(10);
   http_server_props_manager_->SetServerNetworkStats(mail_server, stats1);
-  // ExpectScheduleUpdatePrefsOnNetworkThread() should be called only once.
+  // ExpectScheduleUpdatePrefsOnNetworkSequence() should be called only once.
   http_server_props_manager_->SetServerNetworkStats(mail_server, stats1);
 
   // Run the task.
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_TRUE(net_test_task_runner_->HasPendingTask());
   net_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   const ServerNetworkStats* stats2 =
       http_server_props_manager_->GetServerNetworkStats(mail_server);
   EXPECT_EQ(10, stats2->srtt.ToInternalValue());
 
   ExpectPrefsUpdate(1);
-  ExpectScheduleUpdatePrefsOnNetworkThread();
+  ExpectScheduleUpdatePrefsOnNetworkSequence();
 
   http_server_props_manager_->ClearServerNetworkStats(mail_server);
 
   // Run the task.
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_TRUE(net_test_task_runner_->HasPendingTask());
   net_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
   EXPECT_EQ(nullptr,
             http_server_props_manager_->GetServerNetworkStats(mail_server));
 }
 
 TEST_P(HttpServerPropertiesManagerTest, QuicServerInfo) {
   ExpectPrefsUpdate(1);
-  ExpectScheduleUpdatePrefsOnNetworkThread();
+  ExpectScheduleUpdatePrefsOnNetworkSequence();
 
   QuicServerId mail_quic_server_id("mail.google.com", 80);
   EXPECT_EQ(nullptr,
             http_server_props_manager_->GetQuicServerInfo(mail_quic_server_id));
   std::string quic_server_info1("quic_server_info1");
   http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id,
                                                 quic_server_info1);
-  // ExpectScheduleUpdatePrefsOnNetworkThread() should be called only once.
+  // ExpectScheduleUpdatePrefsOnNetworkSequence() should be called only once.
   http_server_props_manager_->SetQuicServerInfo(mail_quic_server_id,
                                                 quic_server_info1);
 
   // Run the task.
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   EXPECT_TRUE(net_test_task_runner_->HasPendingTask());
   net_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   EXPECT_EQ(quic_server_info1, *http_server_props_manager_->GetQuicServerInfo(
                                    mail_quic_server_id));
 }
 
 TEST_P(HttpServerPropertiesManagerTest, Clear) {
   ExpectPrefsUpdate(1);
-  ExpectScheduleUpdatePrefsOnNetworkThreadRepeatedly(5);
+  ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(5);
 
   const url::SchemeHostPort spdy_server("https", "mail.google.com", 443);
   const IPAddress actual_address(127, 0, 0, 1);
   const QuicServerId mail_quic_server_id("mail.google.com", 80);
   const std::string quic_server_info1("quic_server_info1");
 
   {
     TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_);
 
     http_server_props_manager_->SetSupportsSpdy(spdy_server, true);
@@ skipping 152 matching lines @@
     EXPECT_EQ(i, alternative_service_info_vector[0].alternative_service.port);
   }
 
   // Verify SupportsQuic.
   IPAddress address;
   ASSERT_TRUE(http_server_props_manager_->GetSupportsQuic(&address));
   EXPECT_EQ("127.0.0.1", address.ToString());
 }
 
 TEST_P(HttpServerPropertiesManagerTest, UpdatePrefsWithCache) {
-  ExpectScheduleUpdatePrefsOnNetworkThreadRepeatedly(5);
+  ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(5);
 
   const url::SchemeHostPort server_www("https", "www.google.com", 80);
   const url::SchemeHostPort server_mail("https", "mail.google.com", 80);
 
   // #1 & #2: Set alternate protocol.
   AlternativeServiceInfoVector alternative_service_info_vector;
   AlternativeService www_alternative_service1(kProtoHTTP2, "", 443);
   base::Time expiration1;
   ASSERT_TRUE(base::Time::FromUTCString("2036-12-01 10:00:00", &expiration1));
   alternative_service_info_vector.push_back(
@@ skipping 164 matching lines @@
   EXPECT_FALSE(http_server_props_manager_->AddToAlternativeServiceMap(
       server, *server_dict, &alternative_service_map));
 
   AlternativeServiceMap::iterator it = alternative_service_map.Get(server);
   EXPECT_EQ(alternative_service_map.end(), it);
 }
 
 // Do not persist expired or broken alternative service entries to disk.
 TEST_P(HttpServerPropertiesManagerTest,
        DoNotPersistExpiredOrBrokenAlternativeService) {
-  ExpectScheduleUpdatePrefsOnNetworkThreadRepeatedly(2);
+  ExpectScheduleUpdatePrefsOnNetworkSequenceRepeatedly(2);
 
   {
     TestMockTimeTaskRunner::ScopedContext scoped_context(net_test_task_runner_);
 
     AlternativeServiceInfoVector alternative_service_info_vector;
 
     const AlternativeService broken_alternative_service(
         kProtoHTTP2, "broken.example.com", 443);
     const base::Time time_one_day_later =
         base::Time::Now() + base::TimeDelta::FromDays(1);
@@ skipping 107 matching lines @@
   EXPECT_EQ("valid.example.com",
             alternative_service_info_vector[0].alternative_service.host);
   EXPECT_EQ(443, alternative_service_info_vector[0].alternative_service.port);
   EXPECT_EQ(one_day_from_now_, alternative_service_info_vector[0].expiration);
 }
 
 TEST_P(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdateCache0) {
   // Post an update task to the UI thread.
   http_server_props_manager_->ScheduleUpdateCacheOnPrefThread();
   // Shutdown comes before the task is executed.
-  http_server_props_manager_->ShutdownOnPrefThread();
+  http_server_props_manager_->ShutdownOnPrefSequence();
   http_server_props_manager_.reset();
   // Run the task after shutdown and deletion.
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 }
 
 TEST_P(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdateCache1) {
   // Post an update task.
   http_server_props_manager_->ScheduleUpdateCacheOnPrefThread();
   // Shutdown comes before the task is executed.
-  http_server_props_manager_->ShutdownOnPrefThread();
+  http_server_props_manager_->ShutdownOnPrefSequence();
   // Run the task after shutdown, but before deletion.
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
   http_server_props_manager_.reset();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 }
 
 TEST_P(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdateCache2) {
   http_server_props_manager_->UpdateCacheFromPrefsOnUIConcrete();
   // Shutdown comes before the task is executed.
-  http_server_props_manager_->ShutdownOnPrefThread();
+  http_server_props_manager_->ShutdownOnPrefSequence();
   // There should be no tasks to run.
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
   http_server_props_manager_.reset();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 }
 
 //
 // Tests for shutdown when updating prefs.
 //
 TEST_P(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdatePrefs0) {
   // Post an update task to the IO thread.
-  http_server_props_manager_->ScheduleUpdatePrefsOnNetworkThreadDefault();
+  http_server_props_manager_->ScheduleUpdatePrefsOnNetworkSequenceDefault();
   // Shutdown comes before the task is executed.
-  http_server_props_manager_->ShutdownOnPrefThread();
+  http_server_props_manager_->ShutdownOnPrefSequence();
   http_server_props_manager_.reset();
   // Run the task after shutdown and deletion.
   EXPECT_TRUE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   net_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 }
 
 TEST_P(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdatePrefs1) {
   ExpectPrefsUpdate(1);
   // Post an update task.
-  http_server_props_manager_->ScheduleUpdatePrefsOnNetworkThreadDefault();
+  http_server_props_manager_->ScheduleUpdatePrefsOnNetworkSequenceDefault();
   // Shutdown comes before the task is executed.
-  http_server_props_manager_->ShutdownOnPrefThread();
+  http_server_props_manager_->ShutdownOnPrefSequence();
   // Run the task after shutdown, but before deletion.
   EXPECT_TRUE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   net_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
   http_server_props_manager_.reset();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 }
 
 TEST_P(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdatePrefs2) {
   // This posts a task to the UI thread.
-  http_server_props_manager_->UpdatePrefsFromCacheOnNetworkThreadConcrete(
+  http_server_props_manager_->UpdatePrefsFromCacheOnNetworkSequenceConcrete(
       base::Closure());
   // Shutdown comes before the task is executed.
-  http_server_props_manager_->ShutdownOnPrefThread();
+  http_server_props_manager_->ShutdownOnPrefSequence();
   // Run the task after shutdown, but before deletion.
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_TRUE(pref_test_task_runner_->HasPendingTask());
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
   http_server_props_manager_.reset();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 }
 
 }  // namespace net