net/http/http_server_properties_manager_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/http/http_server_properties_manager.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/prefs/pref_registry_simple.h"
  10 #include "base/prefs/testing_pref_service.h"
  11 #include "base/run_loop.h"
  12 #include "base/test/test_simple_task_runner.h"
  13 #include "base/values.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "url/gurl.h"
  17
  18 namespace net {
  19
  20 namespace {
  21
  22 using ::testing::_;
  23 using ::testing::Invoke;
  24 using ::testing::Mock;
  25 using ::testing::StrictMock;
  26
  27 const char kTestHttpServerProperties[] = "TestHttpServerProperties";
  28
  29 class TestingHttpServerPropertiesManager : public HttpServerPropertiesManager {
  30  public:
  31   TestingHttpServerPropertiesManager(
  32       PrefService* pref_service,
  33       const char* pref_path,
  34       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
  35       : HttpServerPropertiesManager(pref_service, pref_path, io_task_runner) {
  36     InitializeOnNetworkThread();
  37   }
  38
  39   virtual ~TestingHttpServerPropertiesManager() {}
  40
  41   // Make these methods public for testing.
  42   using HttpServerPropertiesManager::ScheduleUpdateCacheOnPrefThread;
  43   using HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkThread;
  44
  45   // Post tasks without a delay during tests.
  46   virtual void StartPrefsUpdateTimerOnNetworkThread(
  47       base::TimeDelta delay) OVERRIDE {
  48     HttpServerPropertiesManager::StartPrefsUpdateTimerOnNetworkThread(
  49         base::TimeDelta());
  50   }
  51
  52   void UpdateCacheFromPrefsOnUIConcrete() {
  53     HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefThread();
  54   }
  55
  56   // Post tasks without a delay during tests.
  57   virtual void StartCacheUpdateTimerOnPrefThread(
  58       base::TimeDelta delay) OVERRIDE {
  59     HttpServerPropertiesManager::StartCacheUpdateTimerOnPrefThread(
  60         base::TimeDelta());
  61   }
  62
  63   void UpdatePrefsFromCacheOnNetworkThreadConcrete(
  64       const base::Closure& callback) {
  65     HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkThread(callback);
  66   }
  67
  68   MOCK_METHOD0(UpdateCacheFromPrefsOnPrefThread, void());
  69   MOCK_METHOD1(UpdatePrefsFromCacheOnNetworkThread, void(const base::Closure&));
  70   MOCK_METHOD6(UpdateCacheFromPrefsOnNetworkThread,
  71                void(std::vector<std::string>* spdy_servers,
  72                     net::SpdySettingsMap* spdy_settings_map,
  73                     net::AlternateProtocolMap* alternate_protocol_map,
  74                     net::AlternateProtocolExperiment experiment,
  75                     net::SupportsQuicMap* supports_quic_map,
  76                     bool detected_corrupted_prefs));
  77   MOCK_METHOD4(UpdatePrefsOnPref,
  78                void(base::ListValue* spdy_server_list,
  79                     net::SpdySettingsMap* spdy_settings_map,
  80                     net::AlternateProtocolMap* alternate_protocol_map,
  81                     net::SupportsQuicMap* supports_quic_map));
  82
  83  private:
  84   DISALLOW_COPY_AND_ASSIGN(TestingHttpServerPropertiesManager);
  85 };
  86
  87 class HttpServerPropertiesManagerTest : public testing::Test {
  88  protected:
  89   HttpServerPropertiesManagerTest() {}
  90
  91   virtual void SetUp() OVERRIDE {
  92     pref_service_.registry()->RegisterDictionaryPref(kTestHttpServerProperties);
  93     http_server_props_manager_.reset(
  94         new StrictMock<TestingHttpServerPropertiesManager>(
  95             &pref_service_,
  96             kTestHttpServerProperties,
  97             base::MessageLoop::current()->message_loop_proxy()));
  98     ExpectCacheUpdate();
  99     base::RunLoop().RunUntilIdle();
 100   }
 101
 102   virtual void TearDown() OVERRIDE {
 103     if (http_server_props_manager_.get())
 104       http_server_props_manager_->ShutdownOnPrefThread();
 105     base::RunLoop().RunUntilIdle();
 106     http_server_props_manager_.reset();
 107   }
 108
 109   void ExpectCacheUpdate() {
 110     EXPECT_CALL(*http_server_props_manager_, UpdateCacheFromPrefsOnPrefThread())
 111         .WillOnce(Invoke(http_server_props_manager_.get(),
 112                          &TestingHttpServerPropertiesManager::
 113                              UpdateCacheFromPrefsOnUIConcrete));
 114   }
 115
 116   void ExpectPrefsUpdate() {
 117     EXPECT_CALL(*http_server_props_manager_,
 118                 UpdatePrefsFromCacheOnNetworkThread(_))
 119         .WillOnce(Invoke(http_server_props_manager_.get(),
 120                          &TestingHttpServerPropertiesManager::
 121                              UpdatePrefsFromCacheOnNetworkThreadConcrete));
 122   }
 123
 124   void ExpectPrefsUpdateRepeatedly() {
 125     EXPECT_CALL(*http_server_props_manager_,
 126                 UpdatePrefsFromCacheOnNetworkThread(_))
 127         .WillRepeatedly(
 128             Invoke(http_server_props_manager_.get(),
 129                    &TestingHttpServerPropertiesManager::
 130                        UpdatePrefsFromCacheOnNetworkThreadConcrete));
 131   }
 132
 133   //base::RunLoop loop_;
 134   TestingPrefServiceSimple pref_service_;
 135   scoped_ptr<TestingHttpServerPropertiesManager> http_server_props_manager_;
 136
 137  private:
 138   DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesManagerTest);
 139 };
 140
 141 TEST_F(HttpServerPropertiesManagerTest,
 142        SingleUpdateForTwoSpdyServerPrefChanges) {
 143   ExpectCacheUpdate();
 144
 145   // Set up the prefs for www.google.com:80 and mail.google.com:80 and then set
 146   // it twice. Only expect a single cache update.
 147
 148   base::DictionaryValue* server_pref_dict = new base::DictionaryValue;
 149
 150   // Set supports_spdy for www.google.com:80.
 151   server_pref_dict->SetBoolean("supports_spdy", true);
 152
 153   // Set up alternate_protocol for www.google.com:80.
 154   base::DictionaryValue* alternate_protocol = new base::DictionaryValue;
 155   alternate_protocol->SetInteger("port", 443);
 156   alternate_protocol->SetString("protocol_str", "npn-spdy/3");
 157   server_pref_dict->SetWithoutPathExpansion("alternate_protocol",
 158                                             alternate_protocol);
 159
 160   // Set up SupportsQuic for www.google.com:80.
 161   base::DictionaryValue* supports_quic = new base::DictionaryValue;
 162   supports_quic->SetBoolean("used_quic", true);
 163   supports_quic->SetString("address", "foo");
 164   server_pref_dict->SetWithoutPathExpansion("supports_quic", supports_quic);
 165
 166   // Set the server preference for www.google.com:80.
 167   base::DictionaryValue* servers_dict = new base::DictionaryValue;
 168   servers_dict->SetWithoutPathExpansion("www.google.com:80", server_pref_dict);
 169
 170   // Set the preference for mail.google.com server.
 171   base::DictionaryValue* server_pref_dict1 = new base::DictionaryValue;
 172
 173   // Set supports_spdy for mail.google.com:80
 174   server_pref_dict1->SetBoolean("supports_spdy", true);
 175
 176   // Set up alternate_protocol for mail.google.com:80
 177   base::DictionaryValue* alternate_protocol1 = new base::DictionaryValue;
 178   alternate_protocol1->SetInteger("port", 444);
 179   alternate_protocol1->SetString("protocol_str", "npn-spdy/3.1");
 180
 181   server_pref_dict1->SetWithoutPathExpansion("alternate_protocol",
 182                                              alternate_protocol1);
 183
 184   // Set up SupportsQuic for mail.google.com:80
 185   base::DictionaryValue* supports_quic1 = new base::DictionaryValue;
 186   supports_quic1->SetBoolean("used_quic", false);
 187   supports_quic1->SetString("address", "bar");
 188   server_pref_dict1->SetWithoutPathExpansion("supports_quic", supports_quic1);
 189
 190   // Set the server preference for mail.google.com:80.
 191   servers_dict->SetWithoutPathExpansion("mail.google.com:80",
 192                                         server_pref_dict1);
 193
 194   base::DictionaryValue* http_server_properties_dict =
 195       new base::DictionaryValue;
 196   HttpServerPropertiesManager::SetVersion(http_server_properties_dict, -1);
 197   http_server_properties_dict->SetWithoutPathExpansion("servers", servers_dict);
 198
 199   // Set the same value for kHttpServerProperties multiple times.
 200   pref_service_.SetManagedPref(kTestHttpServerProperties,
 201                                http_server_properties_dict);
 202   base::DictionaryValue* http_server_properties_dict2 =
 203       http_server_properties_dict->DeepCopy();
 204   pref_service_.SetManagedPref(kTestHttpServerProperties,
 205                                http_server_properties_dict2);
 206
 207   base::RunLoop().RunUntilIdle();
 208   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 209
 210   // Verify SupportsSpdy.
 211   EXPECT_TRUE(http_server_props_manager_->SupportsSpdy(
 212       net::HostPortPair::FromString("www.google.com:80")));
 213   EXPECT_TRUE(http_server_props_manager_->SupportsSpdy(
 214       net::HostPortPair::FromString("mail.google.com:80")));
 215   EXPECT_FALSE(http_server_props_manager_->SupportsSpdy(
 216       net::HostPortPair::FromString("foo.google.com:1337")));
 217
 218   // Verify AlternateProtocol.
 219   ASSERT_TRUE(http_server_props_manager_->HasAlternateProtocol(
 220       net::HostPortPair::FromString("www.google.com:80")));
 221   ASSERT_TRUE(http_server_props_manager_->HasAlternateProtocol(
 222       net::HostPortPair::FromString("mail.google.com:80")));
 223   net::AlternateProtocolInfo port_alternate_protocol =
 224       http_server_props_manager_->GetAlternateProtocol(
 225           net::HostPortPair::FromString("www.google.com:80"));
 226   EXPECT_EQ(443, port_alternate_protocol.port);
 227   EXPECT_EQ(net::NPN_SPDY_3, port_alternate_protocol.protocol);
 228   port_alternate_protocol = http_server_props_manager_->GetAlternateProtocol(
 229       net::HostPortPair::FromString("mail.google.com:80"));
 230   EXPECT_EQ(444, port_alternate_protocol.port);
 231   EXPECT_EQ(net::NPN_SPDY_3_1, port_alternate_protocol.protocol);
 232
 233   // Verify SupportsQuic.
 234   net::SupportsQuic supports_quic2 =
 235       http_server_props_manager_->GetSupportsQuic(
 236           net::HostPortPair::FromString("www.google.com:80"));
 237   EXPECT_TRUE(supports_quic2.used_quic);
 238   EXPECT_EQ("foo", supports_quic2.address);
 239   supports_quic2 = http_server_props_manager_->GetSupportsQuic(
 240       net::HostPortPair::FromString("mail.google.com:80"));
 241   EXPECT_FALSE(supports_quic2.used_quic);
 242   EXPECT_EQ("bar", supports_quic2.address);
 243 }
 244
 245 TEST_F(HttpServerPropertiesManagerTest, SupportsSpdy) {
 246   ExpectPrefsUpdate();
 247
 248   // Post an update task to the network thread. SetSupportsSpdy calls
 249   // ScheduleUpdatePrefsOnNetworkThread.
 250
 251   // Add mail.google.com:443 as a supporting spdy server.
 252   net::HostPortPair spdy_server_mail("mail.google.com", 443);
 253   EXPECT_FALSE(http_server_props_manager_->SupportsSpdy(spdy_server_mail));
 254   http_server_props_manager_->SetSupportsSpdy(spdy_server_mail, true);
 255
 256   // Run the task.
 257   base::RunLoop().RunUntilIdle();
 258
 259   EXPECT_TRUE(http_server_props_manager_->SupportsSpdy(spdy_server_mail));
 260   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 261 }
 262
 263 TEST_F(HttpServerPropertiesManagerTest, SetSpdySetting) {
 264   ExpectPrefsUpdate();
 265
 266   // Add SpdySetting for mail.google.com:443.
 267   net::HostPortPair spdy_server_mail("mail.google.com", 443);
 268   const net::SpdySettingsIds id1 = net::SETTINGS_UPLOAD_BANDWIDTH;
 269   const net::SpdySettingsFlags flags1 = net::SETTINGS_FLAG_PLEASE_PERSIST;
 270   const uint32 value1 = 31337;
 271   http_server_props_manager_->SetSpdySetting(
 272       spdy_server_mail, id1, flags1, value1);
 273
 274   // Run the task.
 275   base::RunLoop().RunUntilIdle();
 276
 277   const net::SettingsMap& settings_map1_ret =
 278       http_server_props_manager_->GetSpdySettings(spdy_server_mail);
 279   ASSERT_EQ(1U, settings_map1_ret.size());
 280   net::SettingsMap::const_iterator it1_ret = settings_map1_ret.find(id1);
 281   EXPECT_TRUE(it1_ret != settings_map1_ret.end());
 282   net::SettingsFlagsAndValue flags_and_value1_ret = it1_ret->second;
 283   EXPECT_EQ(net::SETTINGS_FLAG_PERSISTED, flags_and_value1_ret.first);
 284   EXPECT_EQ(value1, flags_and_value1_ret.second);
 285
 286   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 287 }
 288
 289 TEST_F(HttpServerPropertiesManagerTest, ClearSpdySetting) {
 290   ExpectPrefsUpdateRepeatedly();
 291
 292   // Add SpdySetting for mail.google.com:443.
 293   net::HostPortPair spdy_server_mail("mail.google.com", 443);
 294   const net::SpdySettingsIds id1 = net::SETTINGS_UPLOAD_BANDWIDTH;
 295   const net::SpdySettingsFlags flags1 = net::SETTINGS_FLAG_PLEASE_PERSIST;
 296   const uint32 value1 = 31337;
 297   http_server_props_manager_->SetSpdySetting(
 298       spdy_server_mail, id1, flags1, value1);
 299
 300   // Run the task.
 301   base::RunLoop().RunUntilIdle();
 302
 303   const net::SettingsMap& settings_map1_ret =
 304       http_server_props_manager_->GetSpdySettings(spdy_server_mail);
 305   ASSERT_EQ(1U, settings_map1_ret.size());
 306   net::SettingsMap::const_iterator it1_ret = settings_map1_ret.find(id1);
 307   EXPECT_TRUE(it1_ret != settings_map1_ret.end());
 308   net::SettingsFlagsAndValue flags_and_value1_ret = it1_ret->second;
 309   EXPECT_EQ(net::SETTINGS_FLAG_PERSISTED, flags_and_value1_ret.first);
 310   EXPECT_EQ(value1, flags_and_value1_ret.second);
 311
 312   // Clear SpdySetting for mail.google.com:443.
 313   http_server_props_manager_->ClearSpdySettings(spdy_server_mail);
 314
 315   // Run the task.
 316   base::RunLoop().RunUntilIdle();
 317
 318   // Verify that there are no entries in the settings map for
 319   // mail.google.com:443.
 320   const net::SettingsMap& settings_map2_ret =
 321       http_server_props_manager_->GetSpdySettings(spdy_server_mail);
 322   ASSERT_EQ(0U, settings_map2_ret.size());
 323
 324   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 325 }
 326
 327 TEST_F(HttpServerPropertiesManagerTest, ClearAllSpdySetting) {
 328   ExpectPrefsUpdateRepeatedly();
 329
 330   // Add SpdySetting for mail.google.com:443.
 331   net::HostPortPair spdy_server_mail("mail.google.com", 443);
 332   const net::SpdySettingsIds id1 = net::SETTINGS_UPLOAD_BANDWIDTH;
 333   const net::SpdySettingsFlags flags1 = net::SETTINGS_FLAG_PLEASE_PERSIST;
 334   const uint32 value1 = 31337;
 335   http_server_props_manager_->SetSpdySetting(
 336       spdy_server_mail, id1, flags1, value1);
 337
 338   // Run the task.
 339   base::RunLoop().RunUntilIdle();
 340
 341   const net::SettingsMap& settings_map1_ret =
 342       http_server_props_manager_->GetSpdySettings(spdy_server_mail);
 343   ASSERT_EQ(1U, settings_map1_ret.size());
 344   net::SettingsMap::const_iterator it1_ret = settings_map1_ret.find(id1);
 345   EXPECT_TRUE(it1_ret != settings_map1_ret.end());
 346   net::SettingsFlagsAndValue flags_and_value1_ret = it1_ret->second;
 347   EXPECT_EQ(net::SETTINGS_FLAG_PERSISTED, flags_and_value1_ret.first);
 348   EXPECT_EQ(value1, flags_and_value1_ret.second);
 349
 350   // Clear All SpdySettings.
 351   http_server_props_manager_->ClearAllSpdySettings();
 352
 353   // Run the task.
 354   base::RunLoop().RunUntilIdle();
 355
 356   // Verify that there are no entries in the settings map.
 357   const net::SpdySettingsMap& spdy_settings_map2_ret =
 358       http_server_props_manager_->spdy_settings_map();
 359   ASSERT_EQ(0U, spdy_settings_map2_ret.size());
 360
 361   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 362 }
 363
 364 TEST_F(HttpServerPropertiesManagerTest, HasAlternateProtocol) {
 365   ExpectPrefsUpdate();
 366
 367   net::HostPortPair spdy_server_mail("mail.google.com", 80);
 368   EXPECT_FALSE(
 369       http_server_props_manager_->HasAlternateProtocol(spdy_server_mail));
 370   http_server_props_manager_->SetAlternateProtocol(
 371       spdy_server_mail, 443, net::NPN_SPDY_3, 1);
 372
 373   // Run the task.
 374   base::RunLoop().RunUntilIdle();
 375   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 376
 377   ASSERT_TRUE(
 378       http_server_props_manager_->HasAlternateProtocol(spdy_server_mail));
 379   net::AlternateProtocolInfo port_alternate_protocol =
 380       http_server_props_manager_->GetAlternateProtocol(spdy_server_mail);
 381   EXPECT_EQ(443, port_alternate_protocol.port);
 382   EXPECT_EQ(net::NPN_SPDY_3, port_alternate_protocol.protocol);
 383 }
 384
 385 TEST_F(HttpServerPropertiesManagerTest, SupportsQuic) {
 386   ExpectPrefsUpdate();
 387
 388   net::HostPortPair quic_server_mail("mail.google.com", 80);
 389   net::SupportsQuic supports_quic = http_server_props_manager_->GetSupportsQuic(
 390       quic_server_mail);
 391   EXPECT_FALSE(supports_quic.used_quic);
 392   EXPECT_EQ("", supports_quic.address);
 393   http_server_props_manager_->SetSupportsQuic(quic_server_mail, true, "foo");
 394
 395   // Run the task.
 396   base::RunLoop().RunUntilIdle();
 397   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 398
 399   net::SupportsQuic supports_quic1 =
 400       http_server_props_manager_->GetSupportsQuic(quic_server_mail);
 401   EXPECT_TRUE(supports_quic1.used_quic);
 402   EXPECT_EQ("foo", supports_quic1.address);
 403 }
 404
 405 TEST_F(HttpServerPropertiesManagerTest, Clear) {
 406   ExpectPrefsUpdate();
 407
 408   net::HostPortPair spdy_server_mail("mail.google.com", 443);
 409   http_server_props_manager_->SetSupportsSpdy(spdy_server_mail, true);
 410   http_server_props_manager_->SetAlternateProtocol(
 411       spdy_server_mail, 443, net::NPN_SPDY_3, 1);
 412   http_server_props_manager_->SetSupportsQuic(spdy_server_mail, true, "foo");
 413
 414   const net::SpdySettingsIds id1 = net::SETTINGS_UPLOAD_BANDWIDTH;
 415   const net::SpdySettingsFlags flags1 = net::SETTINGS_FLAG_PLEASE_PERSIST;
 416   const uint32 value1 = 31337;
 417   http_server_props_manager_->SetSpdySetting(
 418       spdy_server_mail, id1, flags1, value1);
 419
 420   // Run the task.
 421   base::RunLoop().RunUntilIdle();
 422
 423   EXPECT_TRUE(http_server_props_manager_->SupportsSpdy(spdy_server_mail));
 424   EXPECT_TRUE(
 425       http_server_props_manager_->HasAlternateProtocol(spdy_server_mail));
 426   net::SupportsQuic supports_quic = http_server_props_manager_->GetSupportsQuic(
 427       spdy_server_mail);
 428   EXPECT_TRUE(supports_quic.used_quic);
 429   EXPECT_EQ("foo", supports_quic.address);
 430
 431   // Check SPDY settings values.
 432   const net::SettingsMap& settings_map1_ret =
 433       http_server_props_manager_->GetSpdySettings(spdy_server_mail);
 434   ASSERT_EQ(1U, settings_map1_ret.size());
 435   net::SettingsMap::const_iterator it1_ret = settings_map1_ret.find(id1);
 436   EXPECT_TRUE(it1_ret != settings_map1_ret.end());
 437   net::SettingsFlagsAndValue flags_and_value1_ret = it1_ret->second;
 438   EXPECT_EQ(net::SETTINGS_FLAG_PERSISTED, flags_and_value1_ret.first);
 439   EXPECT_EQ(value1, flags_and_value1_ret.second);
 440
 441   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 442
 443   ExpectPrefsUpdate();
 444
 445   // Clear http server data, time out if we do not get a completion callback.
 446   http_server_props_manager_->Clear(base::MessageLoop::QuitClosure());
 447   base::RunLoop().Run();
 448
 449   EXPECT_FALSE(http_server_props_manager_->SupportsSpdy(spdy_server_mail));
 450   EXPECT_FALSE(
 451       http_server_props_manager_->HasAlternateProtocol(spdy_server_mail));
 452   net::SupportsQuic supports_quic1 =
 453       http_server_props_manager_->GetSupportsQuic(spdy_server_mail);
 454   EXPECT_FALSE(supports_quic1.used_quic);
 455   EXPECT_EQ("", supports_quic1.address);
 456
 457   const net::SettingsMap& settings_map2_ret =
 458       http_server_props_manager_->GetSpdySettings(spdy_server_mail);
 459   EXPECT_EQ(0U, settings_map2_ret.size());
 460
 461   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 462 }
 463
 464 TEST_F(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdateCache0) {
 465   // Post an update task to the UI thread.
 466   http_server_props_manager_->ScheduleUpdateCacheOnPrefThread();
 467   // Shutdown comes before the task is executed.
 468   http_server_props_manager_->ShutdownOnPrefThread();
 469   http_server_props_manager_.reset();
 470   // Run the task after shutdown and deletion.
 471   base::RunLoop().RunUntilIdle();
 472 }
 473
 474 TEST_F(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdateCache1) {
 475   // Post an update task.
 476   http_server_props_manager_->ScheduleUpdateCacheOnPrefThread();
 477   // Shutdown comes before the task is executed.
 478   http_server_props_manager_->ShutdownOnPrefThread();
 479   // Run the task after shutdown, but before deletion.
 480   base::RunLoop().RunUntilIdle();
 481   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 482   http_server_props_manager_.reset();
 483   base::RunLoop().RunUntilIdle();
 484 }
 485
 486 TEST_F(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdateCache2) {
 487   http_server_props_manager_->UpdateCacheFromPrefsOnUIConcrete();
 488   // Shutdown comes before the task is executed.
 489   http_server_props_manager_->ShutdownOnPrefThread();
 490   // Run the task after shutdown, but before deletion.
 491   base::RunLoop().RunUntilIdle();
 492   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 493   http_server_props_manager_.reset();
 494   base::RunLoop().RunUntilIdle();
 495 }
 496
 497 //
 498 // Tests for shutdown when updating prefs.
 499 //
 500 TEST_F(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdatePrefs0) {
 501   // Post an update task to the IO thread.
 502   http_server_props_manager_->ScheduleUpdatePrefsOnNetworkThread();
 503   // Shutdown comes before the task is executed.
 504   http_server_props_manager_->ShutdownOnPrefThread();
 505   http_server_props_manager_.reset();
 506   // Run the task after shutdown and deletion.
 507   base::RunLoop().RunUntilIdle();
 508 }
 509
 510 TEST_F(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdatePrefs1) {
 511   ExpectPrefsUpdate();
 512   // Post an update task.
 513   http_server_props_manager_->ScheduleUpdatePrefsOnNetworkThread();
 514   // Shutdown comes before the task is executed.
 515   http_server_props_manager_->ShutdownOnPrefThread();
 516   // Run the task after shutdown, but before deletion.
 517   base::RunLoop().RunUntilIdle();
 518   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 519   http_server_props_manager_.reset();
 520   base::RunLoop().RunUntilIdle();
 521 }
 522
 523 TEST_F(HttpServerPropertiesManagerTest, ShutdownWithPendingUpdatePrefs2) {
 524   // This posts a task to the UI thread.
 525   http_server_props_manager_->UpdatePrefsFromCacheOnNetworkThreadConcrete(
 526       base::Closure());
 527   // Shutdown comes before the task is executed.
 528   http_server_props_manager_->ShutdownOnPrefThread();
 529   // Run the task after shutdown, but before deletion.
 530   base::RunLoop().RunUntilIdle();
 531   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 532   http_server_props_manager_.reset();
 533   base::RunLoop().RunUntilIdle();
 534 }
 535
 536 }  // namespace
 537
 538 }  // namespace net