Revert of 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 alternative service port for server: " << server_str;
+    DVLOG(1) << "Malformed AltSvc 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 alternative service probability for server: "
-             << server_str;
+    DVLOG(1) << "Malformed AltSvc 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 alternative service protocol string for server: "
-             << server_str;
+    DVLOG(1) << "Malformed AltSvc protocol string for server: " << server_str;
     return alternate_protocol;
   }
   AlternateProtocol protocol = AlternateProtocolFromString(protocol_str);
   if (!IsAlternateProtocolValid(protocol)) {
-    DVLOG(1) << "Invalid alternative service protocol string for server: "
-             << server_str;
+    DVLOG(1) << "Invalid AltSvc 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 249 matching lines @@
 
   // Add AlternateProtocol servers to server_pref_map.
   for (AlternateProtocolMap::const_iterator map_it =
            alternate_protocol_map->begin();
        map_it != alternate_protocol_map->end(); ++map_it) {
     const HostPortPair& server = map_it->first;
     const AlternateProtocolInfo& port_alternate_protocol = map_it->second;
     if (!IsAlternateProtocolValid(port_alternate_protocol.protocol)) {
       continue;
     }
-    const AlternativeService alternative_service(
-        port_alternate_protocol.protocol, server.host(),
-        port_alternate_protocol.port);
-    if (IsAlternativeServiceBroken(alternative_service)) {
-      continue;
-    }
-
     server_pref_map[server].alternate_protocol = &map_it->second;
   }
 
   // Add ServerNetworkStats servers to server_pref_map.
   for (ServerNetworkStatsMap::const_iterator map_it =
            server_network_stats_map->begin();
        map_it != server_network_stats_map->end(); ++map_it) {
     const HostPortPair& server = map_it->first;
     server_pref_map[server].server_network_stats = &map_it->second;
   }
@@ skipping 52 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)
+  if (!port_alternate_protocol || port_alternate_protocol->is_broken)
     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