Add IsAlternativeServiceBroken(), remove is_broken.

net/http/http_server_properties_manager.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_server_properties_manager.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 186 matching lines @@
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
 void HttpServerPropertiesManager::SetBrokenAlternateProtocol(
     const HostPortPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   http_server_properties_impl_->SetBrokenAlternateProtocol(server);
   ScheduleUpdatePrefsOnNetworkThread();
 }
 
+bool HttpServerPropertiesManager::IsAlternativeServiceBroken(
+    const AlternativeService& alternative_service) {
+  DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
+  return http_server_properties_impl_->IsAlternativeServiceBroken(
+      alternative_service);
+}
+
 bool HttpServerPropertiesManager::WasAlternateProtocolRecentlyBroken(
     const HostPortPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
   return http_server_properties_impl_->WasAlternateProtocolRecentlyBroken(
       server);
 }
 
 void HttpServerPropertiesManager::ConfirmAlternateProtocol(
     const HostPortPair& server) {
   DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 233 matching lines @@
   spdy_settings_map->Put(server, settings_map);
 }
 
 AlternateProtocolInfo HttpServerPropertiesManager::ParseAlternateProtocolDict(
     const base::DictionaryValue& alternate_protocol_dict,
     const std::string& server_str) {
   AlternateProtocolInfo alternate_protocol;
   int port = 0;
   if (!alternate_protocol_dict.GetInteger(kPortKey, &port) ||
       !IsPortValid(port)) {
-    DVLOG(1) << "Malformed AltSvc port for server: " << server_str;
+    DVLOG(1) << "Malformed alternative service port for server: " << server_str;
     return alternate_protocol;
   }
   alternate_protocol.port = static_cast<uint16>(port);
 
   double probability = 1.0;
   if (alternate_protocol_dict.HasKey(kProbabilityKey) &&
       !alternate_protocol_dict.GetDoubleWithoutPathExpansion(kProbabilityKey,
                                                              &probability)) {
-    DVLOG(1) << "Malformed AltSvc probability for server: " << server_str;
+    DVLOG(1) << "Malformed alternative service probability for server: "
+             << server_str;
     return alternate_protocol;
   }
   alternate_protocol.probability = probability;
 
   std::string protocol_str;
   if (!alternate_protocol_dict.GetStringWithoutPathExpansion(kProtocolKey,
                                                              &protocol_str)) {
-    DVLOG(1) << "Malformed AltSvc protocol string for server: " << server_str;
+    DVLOG(1) << "Malformed alternative service protocol string for server: "
+             << server_str;
     return alternate_protocol;
   }
   AlternateProtocol protocol = AlternateProtocolFromString(protocol_str);
   if (!IsAlternateProtocolValid(protocol)) {
-    DVLOG(1) << "Invalid AltSvc protocol string for server: " << server_str;
+    DVLOG(1) << "Invalid alternative service protocol string for server: "
+             << server_str;
     return alternate_protocol;
   }
   alternate_protocol.protocol = protocol;
 
   return alternate_protocol;
 }
 
 bool HttpServerPropertiesManager::AddToAlternateProtocolMap(
     const HostPortPair& server,
     const base::DictionaryValue& server_pref_dict,
@@ skipping 275 matching lines @@
        ++map_it) {
     const HostPortPair& server = map_it->first;
     const ServerPref& server_pref = map_it->second;
 
     base::DictionaryValue* server_pref_dict = new base::DictionaryValue;
 
     // Save supports_spdy.
     if (server_pref.supports_spdy)
       server_pref_dict->SetBoolean(kSupportsSpdyKey, server_pref.supports_spdy);
     SaveSpdySettingsToServerPrefs(server_pref.settings_map, server_pref_dict);
     SaveAlternateProtocolToServerPrefs(server_pref.alternate_protocol,

[Ryan Hamilton, 2015/03/10 21:05:46]

Can you check IsBroken here to resolve your TODO below?

[Bence, 2015/03/10 21:46:13]

I'd rather not, because it does not belong here, but I can pass |server| to
SaveAlternateProtocolToServerPrefs.  Note that this is all temporary, because
soon we will be passing AlternativeServices around.

[Ryan Hamilton, 2015/03/10 22:15:26]

The only reason I suggest it is that as currently written, this CL changes the
behavior slightly, and doing adding the check here, while not the best solution,
would leave behavior unchanged. Even if it's temporary it seems like a good idea
not to change behavior.

[Bence, 2015/03/10 22:54:41]

Good call.  I think with this change the behavior is mostly unchanged.  (Except
for the grotesque case of host:80 and host:81 both having host:443 as an
alternate protocol, now if it's broken for one, it's broken for the other one
too.)

                                        server_pref_dict);
     SaveNetworkStatsToServerPrefs(server_pref.server_network_stats,
                                   server_pref_dict);
 
     servers_dict->SetWithoutPathExpansion(server.ToString(), server_pref_dict);
   }
 
   http_server_properties_dict.SetWithoutPathExpansion(kServersKey,
                                                       servers_dict);
   SetVersion(&http_server_properties_dict, kVersionNumber);
@@ skipping 25 matching lines @@
     uint32 value = it->second.second;
     std::string key = base::StringPrintf("%u", id);
     spdy_settings_dict->SetInteger(key, value);
   }
   server_pref_dict->SetWithoutPathExpansion(kSettingsKey, spdy_settings_dict);
 }
 
 void HttpServerPropertiesManager::SaveAlternateProtocolToServerPrefs(
     const AlternateProtocolInfo* port_alternate_protocol,
     base::DictionaryValue* server_pref_dict) {
-  if (!port_alternate_protocol || port_alternate_protocol->is_broken)
+  // TODO(bnc):  Do not save alternative service if broken.
+  if (!port_alternate_protocol)
     return;
 
   base::DictionaryValue* port_alternate_protocol_dict =
       new base::DictionaryValue;
   port_alternate_protocol_dict->SetInteger(kPortKey,
                                            port_alternate_protocol->port);
   const char* protocol_str =
       AlternateProtocolToString(port_alternate_protocol->protocol);
   port_alternate_protocol_dict->SetString(kProtocolKey, protocol_str);
   port_alternate_protocol_dict->SetDouble(kProbabilityKey,
@@ skipping 32 matching lines @@
                                             server_network_stats_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net