1 // Copyright (c) 2012 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 "chrome/browser/net/http_server_properties_manager.h"
6
7 #include "base/bind.h"
8 #include "base/metrics/histogram.h"
9 #include "base/prefs/pref_service.h"
10 #include "base/stl_util.h"
11 #include "base/strings/string_number_conversions.h"
12 #include "base/strings/stringprintf.h"
13 #include "base/values.h"
14 #include "chrome/browser/chrome_notification_types.h"
15 #include "chrome/common/pref_names.h"
16 #include "components/user_prefs/pref_registry_syncable.h"
17 #include "content/public/browser/browser_thread.h"
18 #include "content/public/browser/notification_details.h"
19 #include "content/public/browser/notification_source.h"
20
21 using content::BrowserThread;
22
23 namespace chrome_browser_net {
24
25 namespace {
26
27 // Time to wait before starting an update the http_server_properties_impl_ cache
28 // from preferences. Scheduling another update during this period will reset the
29 // timer.
30 const int64 kUpdateCacheDelayMs = 1000;
31
32 // Time to wait before starting an update the preferences from the
33 // http_server_properties_impl_ cache. Scheduling another update during this
34 // period will reset the timer.
35 const int64 kUpdatePrefsDelayMs = 5000;
36
37 // "version" 0 indicates, http_server_properties doesn't have "version"
38 // property.
39 const int kMissingVersion = 0;
40
41 // The version number of persisted http_server_properties.
42 const int kVersionNumber = 2;
43
44 typedef std::vector<std::string> StringVector;
45
46 } // namespace
47
48 ////////////////////////////////////////////////////////////////////////////////
49 // HttpServerPropertiesManager
50
HttpServerPropertiesManager(PrefService * pref_service)51 HttpServerPropertiesManager::HttpServerPropertiesManager(
52 PrefService* pref_service)
53 : pref_service_(pref_service),
54 setting_prefs_(false) {
55 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
56 DCHECK(pref_service);
57 ui_weak_ptr_factory_.reset(
58 new base::WeakPtrFactory<HttpServerPropertiesManager>(this));
59 ui_weak_ptr_ = ui_weak_ptr_factory_->GetWeakPtr();
60 ui_cache_update_timer_.reset(
61 new base::OneShotTimer<HttpServerPropertiesManager>);
62 pref_change_registrar_.Init(pref_service_);
63 pref_change_registrar_.Add(
64 prefs::kHttpServerProperties,
65 base::Bind(&HttpServerPropertiesManager::OnHttpServerPropertiesChanged,
66 base::Unretained(this)));
67 }
68
~HttpServerPropertiesManager()69 HttpServerPropertiesManager::~HttpServerPropertiesManager() {
70 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
71 io_weak_ptr_factory_.reset();
72 }
73
InitializeOnIOThread()74 void HttpServerPropertiesManager::InitializeOnIOThread() {
75 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
76 io_weak_ptr_factory_.reset(
77 new base::WeakPtrFactory<HttpServerPropertiesManager>(this));
78 http_server_properties_impl_.reset(new net::HttpServerPropertiesImpl());
79
80 io_prefs_update_timer_.reset(
81 new base::OneShotTimer<HttpServerPropertiesManager>);
82
83 BrowserThread::PostTask(
84 BrowserThread::UI,
85 FROM_HERE,
86 base::Bind(&HttpServerPropertiesManager::UpdateCacheFromPrefsOnUI,
87 ui_weak_ptr_));
88 }
89
ShutdownOnUIThread()90 void HttpServerPropertiesManager::ShutdownOnUIThread() {
91 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
92 // Cancel any pending updates, and stop listening for pref change updates.
93 ui_cache_update_timer_->Stop();
94 ui_weak_ptr_factory_.reset();
95 pref_change_registrar_.RemoveAll();
96 }
97
98 // static
RegisterProfilePrefs(user_prefs::PrefRegistrySyncable * prefs)99 void HttpServerPropertiesManager::RegisterProfilePrefs(
100 user_prefs::PrefRegistrySyncable* prefs) {
101 prefs->RegisterDictionaryPref(
102 prefs::kHttpServerProperties,
103 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
104 }
105
106 // static
SetVersion(base::DictionaryValue * http_server_properties_dict,int version_number)107 void HttpServerPropertiesManager::SetVersion(
108 base::DictionaryValue* http_server_properties_dict,
109 int version_number) {
110 if (version_number < 0)
111 version_number = kVersionNumber;
112 DCHECK_LE(version_number, kVersionNumber);
113 if (version_number <= kVersionNumber)
114 http_server_properties_dict->SetInteger("version", version_number);
115 }
116
117 // This is required for conformance with the HttpServerProperties interface.
118 base::WeakPtr<net::HttpServerProperties>
GetWeakPtr()119 HttpServerPropertiesManager::GetWeakPtr() {
120 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
121 return io_weak_ptr_factory_->GetWeakPtr();
122 }
123
Clear()124 void HttpServerPropertiesManager::Clear() {
125 Clear(base::Closure());
126 }
127
Clear(const base::Closure & completion)128 void HttpServerPropertiesManager::Clear(const base::Closure& completion) {
129 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
130
131 http_server_properties_impl_->Clear();
132 UpdatePrefsFromCacheOnIO(completion);
133 }
134
SupportsSpdy(const net::HostPortPair & server) const135 bool HttpServerPropertiesManager::SupportsSpdy(
136 const net::HostPortPair& server) const {
137 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
138 return http_server_properties_impl_->SupportsSpdy(server);
139 }
140
SetSupportsSpdy(const net::HostPortPair & server,bool support_spdy)141 void HttpServerPropertiesManager::SetSupportsSpdy(
142 const net::HostPortPair& server,
143 bool support_spdy) {
144 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
145
146 http_server_properties_impl_->SetSupportsSpdy(server, support_spdy);
147 ScheduleUpdatePrefsOnIO();
148 }
149
HasAlternateProtocol(const net::HostPortPair & server) const150 bool HttpServerPropertiesManager::HasAlternateProtocol(
151 const net::HostPortPair& server) const {
152 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
153 return http_server_properties_impl_->HasAlternateProtocol(server);
154 }
155
156 net::PortAlternateProtocolPair
GetAlternateProtocol(const net::HostPortPair & server) const157 HttpServerPropertiesManager::GetAlternateProtocol(
158 const net::HostPortPair& server) const {
159 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
160 return http_server_properties_impl_->GetAlternateProtocol(server);
161 }
162
SetAlternateProtocol(const net::HostPortPair & server,uint16 alternate_port,net::AlternateProtocol alternate_protocol)163 void HttpServerPropertiesManager::SetAlternateProtocol(
164 const net::HostPortPair& server,
165 uint16 alternate_port,
166 net::AlternateProtocol alternate_protocol) {
167 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
168 http_server_properties_impl_->SetAlternateProtocol(
169 server, alternate_port, alternate_protocol);
170 ScheduleUpdatePrefsOnIO();
171 }
172
SetBrokenAlternateProtocol(const net::HostPortPair & server)173 void HttpServerPropertiesManager::SetBrokenAlternateProtocol(
174 const net::HostPortPair& server) {
175 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
176 http_server_properties_impl_->SetBrokenAlternateProtocol(server);
177 ScheduleUpdatePrefsOnIO();
178 }
179
180 const net::AlternateProtocolMap&
alternate_protocol_map() const181 HttpServerPropertiesManager::alternate_protocol_map() const {
182 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
183 return http_server_properties_impl_->alternate_protocol_map();
184 }
185
186 const net::SettingsMap&
GetSpdySettings(const net::HostPortPair & host_port_pair) const187 HttpServerPropertiesManager::GetSpdySettings(
188 const net::HostPortPair& host_port_pair) const {
189 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
190 return http_server_properties_impl_->GetSpdySettings(host_port_pair);
191 }
192
SetSpdySetting(const net::HostPortPair & host_port_pair,net::SpdySettingsIds id,net::SpdySettingsFlags flags,uint32 value)193 bool HttpServerPropertiesManager::SetSpdySetting(
194 const net::HostPortPair& host_port_pair,
195 net::SpdySettingsIds id,
196 net::SpdySettingsFlags flags,
197 uint32 value) {
198 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
199 bool persist = http_server_properties_impl_->SetSpdySetting(
200 host_port_pair, id, flags, value);
201 if (persist)
202 ScheduleUpdatePrefsOnIO();
203 return persist;
204 }
205
ClearSpdySettings(const net::HostPortPair & host_port_pair)206 void HttpServerPropertiesManager::ClearSpdySettings(
207 const net::HostPortPair& host_port_pair) {
208 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
209 http_server_properties_impl_->ClearSpdySettings(host_port_pair);
210 ScheduleUpdatePrefsOnIO();
211 }
212
ClearAllSpdySettings()213 void HttpServerPropertiesManager::ClearAllSpdySettings() {
214 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
215 http_server_properties_impl_->ClearAllSpdySettings();
216 ScheduleUpdatePrefsOnIO();
217 }
218
219 const net::SpdySettingsMap&
spdy_settings_map() const220 HttpServerPropertiesManager::spdy_settings_map() const {
221 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
222 return http_server_properties_impl_->spdy_settings_map();
223 }
224
225 net::HttpPipelinedHostCapability
GetPipelineCapability(const net::HostPortPair & origin)226 HttpServerPropertiesManager::GetPipelineCapability(
227 const net::HostPortPair& origin) {
228 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
229 return http_server_properties_impl_->GetPipelineCapability(origin);
230 }
231
SetPipelineCapability(const net::HostPortPair & origin,net::HttpPipelinedHostCapability capability)232 void HttpServerPropertiesManager::SetPipelineCapability(
233 const net::HostPortPair& origin,
234 net::HttpPipelinedHostCapability capability) {
235 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
236 http_server_properties_impl_->SetPipelineCapability(origin, capability);
237 ScheduleUpdatePrefsOnIO();
238 }
239
ClearPipelineCapabilities()240 void HttpServerPropertiesManager::ClearPipelineCapabilities() {
241 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
242 http_server_properties_impl_->ClearPipelineCapabilities();
243 ScheduleUpdatePrefsOnIO();
244 }
245
246 net::PipelineCapabilityMap
GetPipelineCapabilityMap() const247 HttpServerPropertiesManager::GetPipelineCapabilityMap() const {
248 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
249 return http_server_properties_impl_->GetPipelineCapabilityMap();
250 }
251
252 //
253 // Update the HttpServerPropertiesImpl's cache with data from preferences.
254 //
ScheduleUpdateCacheOnUI()255 void HttpServerPropertiesManager::ScheduleUpdateCacheOnUI() {
256 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
257 // Cancel pending updates, if any.
258 ui_cache_update_timer_->Stop();
259 StartCacheUpdateTimerOnUI(
260 base::TimeDelta::FromMilliseconds(kUpdateCacheDelayMs));
261 }
262
StartCacheUpdateTimerOnUI(base::TimeDelta delay)263 void HttpServerPropertiesManager::StartCacheUpdateTimerOnUI(
264 base::TimeDelta delay) {
265 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
266 ui_cache_update_timer_->Start(
267 FROM_HERE, delay, this,
268 &HttpServerPropertiesManager::UpdateCacheFromPrefsOnUI);
269 }
270
UpdateCacheFromPrefsOnUI()271 void HttpServerPropertiesManager::UpdateCacheFromPrefsOnUI() {
272 // The preferences can only be read on the UI thread.
273 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
274
275 if (!pref_service_->HasPrefPath(prefs::kHttpServerProperties))
276 return;
277
278 bool detected_corrupted_prefs = false;
279 const base::DictionaryValue& http_server_properties_dict =
280 *pref_service_->GetDictionary(prefs::kHttpServerProperties);
281
282 int version = kMissingVersion;
283 if (!http_server_properties_dict.GetIntegerWithoutPathExpansion(
284 "version", &version)) {
285 DVLOG(1) << "Missing version. Clearing all properties.";
286 return;
287 }
288
289 // The properties for a given server is in
290 // http_server_properties_dict["servers"][server].
291 const base::DictionaryValue* servers_dict = NULL;
292 if (!http_server_properties_dict.GetDictionaryWithoutPathExpansion(
293 "servers", &servers_dict)) {
294 DVLOG(1) << "Malformed http_server_properties for servers.";
295 return;
296 }
297
298 // TODO(rtenneti): Mark entries with an LRU sequence number (date of access?),
299 // and then truncate down deleting old stuff.
300 if (version != kVersionNumber && servers_dict->size() > 300) {
301 DVLOG(1) << "Size is too large. Clearing all properties.";
302 return;
303 }
304
305 // String is host/port pair of spdy server.
306 scoped_ptr<StringVector> spdy_servers(new StringVector);
307 scoped_ptr<net::SpdySettingsMap> spdy_settings_map(new net::SpdySettingsMap);
308 scoped_ptr<net::PipelineCapabilityMap> pipeline_capability_map(
309 new net::PipelineCapabilityMap);
310 scoped_ptr<net::AlternateProtocolMap> alternate_protocol_map(
311 new net::AlternateProtocolMap);
312
313 for (base::DictionaryValue::Iterator it(*servers_dict); !it.IsAtEnd();
314 it.Advance()) {
315 // Get server's host/pair.
316 const std::string& server_str = it.key();
317 net::HostPortPair server = net::HostPortPair::FromString(server_str);
318 if (server.host().empty()) {
319 DVLOG(1) << "Malformed http_server_properties for server: " << server_str;
320 detected_corrupted_prefs = true;
321 continue;
322 }
323
324 const base::DictionaryValue* server_pref_dict = NULL;
325 if (!it.value().GetAsDictionary(&server_pref_dict)) {
326 DVLOG(1) << "Malformed http_server_properties server: " << server_str;
327 detected_corrupted_prefs = true;
328 continue;
329 }
330
331 // Get if server supports Spdy.
332 bool supports_spdy = false;
333 if ((server_pref_dict->GetBoolean(
334 "supports_spdy", &supports_spdy)) && supports_spdy) {
335 spdy_servers->push_back(server_str);
336 }
337
338 // Get SpdySettings.
339 DCHECK(!ContainsKey(*spdy_settings_map, server));
340 const base::DictionaryValue* spdy_settings_dict = NULL;
341 if (server_pref_dict->GetDictionaryWithoutPathExpansion(
342 "settings", &spdy_settings_dict)) {
343 net::SettingsMap settings_map;
344 for (base::DictionaryValue::Iterator dict_it(*spdy_settings_dict);
345 !dict_it.IsAtEnd(); dict_it.Advance()) {
346 const std::string& id_str = dict_it.key();
347 int id = 0;
348 if (!base::StringToInt(id_str, &id)) {
349 DVLOG(1) << "Malformed id in SpdySettings for server: " <<
350 server_str;
351 NOTREACHED();
352 continue;
353 }
354 int value = 0;
355 if (!dict_it.value().GetAsInteger(&value)) {
356 DVLOG(1) << "Malformed value in SpdySettings for server: " <<
357 server_str;
358 NOTREACHED();
359 continue;
360 }
361 net::SettingsFlagsAndValue flags_and_value(
362 net::SETTINGS_FLAG_PERSISTED, value);
363 settings_map[static_cast<net::SpdySettingsIds>(id)] = flags_and_value;
364 }
365 (*spdy_settings_map)[server] = settings_map;
366 }
367
368 int pipeline_capability = net::PIPELINE_UNKNOWN;
369 if ((server_pref_dict->GetInteger(
370 "pipeline_capability", &pipeline_capability)) &&
371 pipeline_capability != net::PIPELINE_UNKNOWN) {
372 (*pipeline_capability_map)[server] =
373 static_cast<net::HttpPipelinedHostCapability>(pipeline_capability);
374 }
375
376 // Get alternate_protocol server.
377 DCHECK(!ContainsKey(*alternate_protocol_map, server));
378 const base::DictionaryValue* port_alternate_protocol_dict = NULL;
379 if (!server_pref_dict->GetDictionaryWithoutPathExpansion(
380 "alternate_protocol", &port_alternate_protocol_dict)) {
381 continue;
382 }
383
384 do {
385 int port = 0;
386 if (!port_alternate_protocol_dict->GetIntegerWithoutPathExpansion(
387 "port", &port) || (port > (1 << 16))) {
388 DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
389 detected_corrupted_prefs = true;
390 continue;
391 }
392 std::string protocol_str;
393 if (!port_alternate_protocol_dict->GetStringWithoutPathExpansion(
394 "protocol_str", &protocol_str)) {
395 DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
396 detected_corrupted_prefs = true;
397 continue;
398 }
399 net::AlternateProtocol protocol =
400 net::AlternateProtocolFromString(protocol_str);
401 if (!net::IsAlternateProtocolValid(protocol)) {
402 DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
403 detected_corrupted_prefs = true;
404 continue;
405 }
406
407 net::PortAlternateProtocolPair port_alternate_protocol;
408 port_alternate_protocol.port = port;
409 port_alternate_protocol.protocol = protocol;
410
411 (*alternate_protocol_map)[server] = port_alternate_protocol;
412 } while (false);
413 }
414
415 BrowserThread::PostTask(
416 BrowserThread::IO,
417 FROM_HERE,
418 base::Bind(&HttpServerPropertiesManager::
419 UpdateCacheFromPrefsOnIO,
420 base::Unretained(this),
421 base::Owned(spdy_servers.release()),
422 base::Owned(spdy_settings_map.release()),
423 base::Owned(alternate_protocol_map.release()),
424 base::Owned(pipeline_capability_map.release()),
425 detected_corrupted_prefs));
426 }
427
UpdateCacheFromPrefsOnIO(StringVector * spdy_servers,net::SpdySettingsMap * spdy_settings_map,net::AlternateProtocolMap * alternate_protocol_map,net::PipelineCapabilityMap * pipeline_capability_map,bool detected_corrupted_prefs)428 void HttpServerPropertiesManager::UpdateCacheFromPrefsOnIO(
429 StringVector* spdy_servers,
430 net::SpdySettingsMap* spdy_settings_map,
431 net::AlternateProtocolMap* alternate_protocol_map,
432 net::PipelineCapabilityMap* pipeline_capability_map,
433 bool detected_corrupted_prefs) {
434 // Preferences have the master data because admins might have pushed new
435 // preferences. Update the cached data with new data from preferences.
436 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
437
438 UMA_HISTOGRAM_COUNTS("Net.CountOfSpdyServers", spdy_servers->size());
439 http_server_properties_impl_->InitializeSpdyServers(spdy_servers, true);
440
441 // Clear the cached data and use the new spdy_settings from preferences.
442 UMA_HISTOGRAM_COUNTS("Net.CountOfSpdySettings", spdy_settings_map->size());
443 http_server_properties_impl_->InitializeSpdySettingsServers(
444 spdy_settings_map);
445
446 // Clear the cached data and use the new Alternate-Protocol server list from
447 // preferences.
448 UMA_HISTOGRAM_COUNTS("Net.CountOfAlternateProtocolServers",
449 alternate_protocol_map->size());
450 http_server_properties_impl_->InitializeAlternateProtocolServers(
451 alternate_protocol_map);
452
453 UMA_HISTOGRAM_COUNTS("Net.CountOfPipelineCapableServers",
454 pipeline_capability_map->size());
455 http_server_properties_impl_->InitializePipelineCapabilities(
456 pipeline_capability_map);
457
458 // Update the prefs with what we have read (delete all corrupted prefs).
459 if (detected_corrupted_prefs)
460 ScheduleUpdatePrefsOnIO();
461 }
462
463
464 //
465 // Update Preferences with data from the cached data.
466 //
ScheduleUpdatePrefsOnIO()467 void HttpServerPropertiesManager::ScheduleUpdatePrefsOnIO() {
468 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
469 // Cancel pending updates, if any.
470 io_prefs_update_timer_->Stop();
471 StartPrefsUpdateTimerOnIO(
472 base::TimeDelta::FromMilliseconds(kUpdatePrefsDelayMs));
473 }
474
StartPrefsUpdateTimerOnIO(base::TimeDelta delay)475 void HttpServerPropertiesManager::StartPrefsUpdateTimerOnIO(
476 base::TimeDelta delay) {
477 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
478 // This is overridden in tests to post the task without the delay.
479 io_prefs_update_timer_->Start(
480 FROM_HERE, delay, this,
481 &HttpServerPropertiesManager::UpdatePrefsFromCacheOnIO);
482 }
483
484 // This is required so we can set this as the callback for a timer.
UpdatePrefsFromCacheOnIO()485 void HttpServerPropertiesManager::UpdatePrefsFromCacheOnIO() {
486 UpdatePrefsFromCacheOnIO(base::Closure());
487 }
488
UpdatePrefsFromCacheOnIO(const base::Closure & completion)489 void HttpServerPropertiesManager::UpdatePrefsFromCacheOnIO(
490 const base::Closure& completion) {
491 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
492
493 base::ListValue* spdy_server_list = new base::ListValue;
494 http_server_properties_impl_->GetSpdyServerList(spdy_server_list);
495
496 net::SpdySettingsMap* spdy_settings_map = new net::SpdySettingsMap;
497 *spdy_settings_map = http_server_properties_impl_->spdy_settings_map();
498
499 net::AlternateProtocolMap* alternate_protocol_map =
500 new net::AlternateProtocolMap;
501 *alternate_protocol_map =
502 http_server_properties_impl_->alternate_protocol_map();
503
504 net::PipelineCapabilityMap* pipeline_capability_map =
505 new net::PipelineCapabilityMap;
506 *pipeline_capability_map =
507 http_server_properties_impl_->GetPipelineCapabilityMap();
508
509 // Update the preferences on the UI thread.
510 BrowserThread::PostTask(
511 BrowserThread::UI,
512 FROM_HERE,
513 base::Bind(&HttpServerPropertiesManager::UpdatePrefsOnUI,
514 ui_weak_ptr_,
515 base::Owned(spdy_server_list),
516 base::Owned(spdy_settings_map),
517 base::Owned(alternate_protocol_map),
518 base::Owned(pipeline_capability_map),
519 completion));
520 }
521
522 // A local or temporary data structure to hold |supports_spdy|, SpdySettings,
523 // PortAlternateProtocolPair, and |pipeline_capability| preferences for a
524 // server. This is used only in UpdatePrefsOnUI.
525 struct ServerPref {
ServerPrefchrome_browser_net::ServerPref526 ServerPref()
527 : supports_spdy(false),
528 settings_map(NULL),
529 alternate_protocol(NULL),
530 pipeline_capability(net::PIPELINE_UNKNOWN) {
531 }
ServerPrefchrome_browser_net::ServerPref532 ServerPref(bool supports_spdy,
533 const net::SettingsMap* settings_map,
534 const net::PortAlternateProtocolPair* alternate_protocol)
535 : supports_spdy(supports_spdy),
536 settings_map(settings_map),
537 alternate_protocol(alternate_protocol),
538 pipeline_capability(net::PIPELINE_UNKNOWN) {
539 }
540 bool supports_spdy;
541 const net::SettingsMap* settings_map;
542 const net::PortAlternateProtocolPair* alternate_protocol;
543 net::HttpPipelinedHostCapability pipeline_capability;
544 };
545
UpdatePrefsOnUI(base::ListValue * spdy_server_list,net::SpdySettingsMap * spdy_settings_map,net::AlternateProtocolMap * alternate_protocol_map,net::PipelineCapabilityMap * pipeline_capability_map,const base::Closure & completion)546 void HttpServerPropertiesManager::UpdatePrefsOnUI(
547 base::ListValue* spdy_server_list,
548 net::SpdySettingsMap* spdy_settings_map,
549 net::AlternateProtocolMap* alternate_protocol_map,
550 net::PipelineCapabilityMap* pipeline_capability_map,
551 const base::Closure& completion) {
552
553 typedef std::map<net::HostPortPair, ServerPref> ServerPrefMap;
554 ServerPrefMap server_pref_map;
555
556 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
557
558 // Add servers that support spdy to server_pref_map.
559 std::string s;
560 for (base::ListValue::const_iterator list_it = spdy_server_list->begin();
561 list_it != spdy_server_list->end(); ++list_it) {
562 if ((*list_it)->GetAsString(&s)) {
563 net::HostPortPair server = net::HostPortPair::FromString(s);
564
565 ServerPrefMap::iterator it = server_pref_map.find(server);
566 if (it == server_pref_map.end()) {
567 ServerPref server_pref(true, NULL, NULL);
568 server_pref_map[server] = server_pref;
569 } else {
570 it->second.supports_spdy = true;
571 }
572 }
573 }
574
575 // Add servers that have SpdySettings to server_pref_map.
576 for (net::SpdySettingsMap::iterator map_it =
577 spdy_settings_map->begin();
578 map_it != spdy_settings_map->end(); ++map_it) {
579 const net::HostPortPair& server = map_it->first;
580
581 ServerPrefMap::iterator it = server_pref_map.find(server);
582 if (it == server_pref_map.end()) {
583 ServerPref server_pref(false, &map_it->second, NULL);
584 server_pref_map[server] = server_pref;
585 } else {
586 it->second.settings_map = &map_it->second;
587 }
588 }
589
590 // Add AlternateProtocol servers to server_pref_map.
591 for (net::AlternateProtocolMap::const_iterator map_it =
592 alternate_protocol_map->begin();
593 map_it != alternate_protocol_map->end(); ++map_it) {
594 const net::HostPortPair& server = map_it->first;
595 const net::PortAlternateProtocolPair& port_alternate_protocol =
596 map_it->second;
597 if (!net::IsAlternateProtocolValid(port_alternate_protocol.protocol)) {
598 continue;
599 }
600
601 ServerPrefMap::iterator it = server_pref_map.find(server);
602 if (it == server_pref_map.end()) {
603 ServerPref server_pref(false, NULL, &map_it->second);
604 server_pref_map[server] = server_pref;
605 } else {
606 it->second.alternate_protocol = &map_it->second;
607 }
608 }
609
610 for (net::PipelineCapabilityMap::const_iterator map_it =
611 pipeline_capability_map->begin();
612 map_it != pipeline_capability_map->end(); ++map_it) {
613 const net::HostPortPair& server = map_it->first;
614 const net::HttpPipelinedHostCapability& pipeline_capability =
615 map_it->second;
616
617 ServerPrefMap::iterator it = server_pref_map.find(server);
618 if (it == server_pref_map.end()) {
619 ServerPref server_pref;
620 server_pref.pipeline_capability = pipeline_capability;
621 server_pref_map[server] = server_pref;
622 } else {
623 it->second.pipeline_capability = pipeline_capability;
624 }
625 }
626
627 // Persist the prefs::kHttpServerProperties.
628 base::DictionaryValue http_server_properties_dict;
629 base::DictionaryValue* servers_dict = new base::DictionaryValue;
630 for (ServerPrefMap::const_iterator map_it =
631 server_pref_map.begin();
632 map_it != server_pref_map.end(); ++map_it) {
633 const net::HostPortPair& server = map_it->first;
634 const ServerPref& server_pref = map_it->second;
635
636 base::DictionaryValue* server_pref_dict = new base::DictionaryValue;
637
638 // Save supports_spdy.
639 server_pref_dict->SetBoolean("supports_spdy", server_pref.supports_spdy);
640
641 // Save SPDY settings.
642 if (server_pref.settings_map) {
643 base::DictionaryValue* spdy_settings_dict = new base::DictionaryValue;
644 for (net::SettingsMap::const_iterator it =
645 server_pref.settings_map->begin();
646 it != server_pref.settings_map->end(); ++it) {
647 net::SpdySettingsIds id = it->first;
648 uint32 value = it->second.second;
649 std::string key = base::StringPrintf("%u", id);
650 spdy_settings_dict->SetInteger(key, value);
651 }
652 server_pref_dict->SetWithoutPathExpansion("settings", spdy_settings_dict);
653 }
654
655 // Save alternate_protocol.
656 if (server_pref.alternate_protocol) {
657 base::DictionaryValue* port_alternate_protocol_dict =
658 new base::DictionaryValue;
659 const net::PortAlternateProtocolPair* port_alternate_protocol =
660 server_pref.alternate_protocol;
661 port_alternate_protocol_dict->SetInteger(
662 "port", port_alternate_protocol->port);
663 const char* protocol_str =
664 net::AlternateProtocolToString(port_alternate_protocol->protocol);
665 port_alternate_protocol_dict->SetString("protocol_str", protocol_str);
666 server_pref_dict->SetWithoutPathExpansion(
667 "alternate_protocol", port_alternate_protocol_dict);
668 }
669
670 if (server_pref.pipeline_capability != net::PIPELINE_UNKNOWN) {
671 server_pref_dict->SetInteger("pipeline_capability",
672 server_pref.pipeline_capability);
673 }
674
675 servers_dict->SetWithoutPathExpansion(server.ToString(), server_pref_dict);
676 }
677
678 http_server_properties_dict.SetWithoutPathExpansion("servers", servers_dict);
679 SetVersion(&http_server_properties_dict, kVersionNumber);
680 setting_prefs_ = true;
681 pref_service_->Set(prefs::kHttpServerProperties,
682 http_server_properties_dict);
683 setting_prefs_ = false;
684
685 // Note that |completion| will be fired after we have written everything to
686 // the Preferences, but likely before these changes are serialized to disk.
687 // This is not a problem though, as JSONPrefStore guarantees that this will
688 // happen, pretty soon, and even in the case we shut down immediately.
689 if (!completion.is_null())
690 completion.Run();
691 }
692
OnHttpServerPropertiesChanged()693 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
694 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
695 if (!setting_prefs_)
696 ScheduleUpdateCacheOnUI();
697 }
698
699 } // namespace chrome_browser_net
700