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:
TestingHttpServerPropertiesManager(PrefService * pref_service,const char * pref_path,scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)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
~TestingHttpServerPropertiesManager()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.
StartPrefsUpdateTimerOnNetworkThread(base::TimeDelta delay)46 virtual void StartPrefsUpdateTimerOnNetworkThread(
47 base::TimeDelta delay) OVERRIDE {
48 HttpServerPropertiesManager::StartPrefsUpdateTimerOnNetworkThread(
49 base::TimeDelta());
50 }
51
UpdateCacheFromPrefsOnUIConcrete()52 void UpdateCacheFromPrefsOnUIConcrete() {
53 HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefThread();
54 }
55
56 // Post tasks without a delay during tests.
StartCacheUpdateTimerOnPrefThread(base::TimeDelta delay)57 virtual void StartCacheUpdateTimerOnPrefThread(
58 base::TimeDelta delay) OVERRIDE {
59 HttpServerPropertiesManager::StartCacheUpdateTimerOnPrefThread(
60 base::TimeDelta());
61 }
62
UpdatePrefsFromCacheOnNetworkThreadConcrete(const base::Closure & callback)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:
HttpServerPropertiesManagerTest()89 HttpServerPropertiesManagerTest() {}
90
SetUp()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
TearDown()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
ExpectCacheUpdate()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
ExpectPrefsUpdate()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
ExpectPrefsUpdateRepeatedly()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
TEST_F(HttpServerPropertiesManagerTest,SingleUpdateForTwoSpdyServerPrefChanges)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
TEST_F(HttpServerPropertiesManagerTest,SupportsSpdy)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
TEST_F(HttpServerPropertiesManagerTest,SetSpdySetting)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
TEST_F(HttpServerPropertiesManagerTest,ClearSpdySetting)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
TEST_F(HttpServerPropertiesManagerTest,ClearAllSpdySetting)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
TEST_F(HttpServerPropertiesManagerTest,HasAlternateProtocol)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
TEST_F(HttpServerPropertiesManagerTest,SupportsQuic)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
TEST_F(HttpServerPropertiesManagerTest,Clear)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
TEST_F(HttpServerPropertiesManagerTest,ShutdownWithPendingUpdateCache0)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
TEST_F(HttpServerPropertiesManagerTest,ShutdownWithPendingUpdateCache1)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
TEST_F(HttpServerPropertiesManagerTest,ShutdownWithPendingUpdateCache2)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 //
TEST_F(HttpServerPropertiesManagerTest,ShutdownWithPendingUpdatePrefs0)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
TEST_F(HttpServerPropertiesManagerTest,ShutdownWithPendingUpdatePrefs1)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
TEST_F(HttpServerPropertiesManagerTest,ShutdownWithPendingUpdatePrefs2)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
539