Introduce AlternativeService in BrokenAlternateProtol{List,Map}.

net/http/http_server_properties_impl.h

 // Copyright (c) 2012 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.
 
 #ifndef NET_HTTP_HTTP_SERVER_PROPERTIES_IMPL_H_
 #define NET_HTTP_HTTP_SERVER_PROPERTIES_IMPL_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 99 matching lines @@
   const ServerNetworkStatsMap& server_network_stats_map() const override;
 
  private:
   // |spdy_servers_map_| has flattened representation of servers (host, port)
   // that either support or not support SPDY protocol.
   typedef base::MRUCache<std::string, bool> SpdyServerHostPortMap;
   typedef std::map<HostPortPair, HostPortPair> CanonicalHostMap;
   typedef std::vector<std::string> CanonicalSufficList;
   typedef std::set<HostPortPair> Http11ServerHostPortSet;
 
-  // Server, port, and AlternateProtocol: an entity that can be broken.  (Once
-  // we use AlternativeService, the same AltSvc can be broken for one server but
-  // not for another depending on what certificate it can offer.)
-  struct BrokenAlternateProtocolEntry {
-    BrokenAlternateProtocolEntry(const BrokenAlternateProtocolEntry&) = default;
-    BrokenAlternateProtocolEntry(const HostPortPair& server,
-                                 uint16 port,
-                                 AlternateProtocol protocol)
-        : server(server), port(port), protocol(protocol) {}
+  // Broken alternative service with expiration time.
+  struct BrokenAlternateProtocolEntryWithTime {
+    BrokenAlternateProtocolEntryWithTime(const AlternativeService& altsvc,
+                                         base::TimeTicks when)
+        : altsvc(altsvc), when(when) {}
 
-    bool operator<(const BrokenAlternateProtocolEntry& other) const {
-      if (!server.Equals(other.server))
-        return server < other.server;
-      if (port != other.port)
-        return port < other.port;
-      return protocol < other.protocol;
-    }
-
-    HostPortPair server;
-    uint16 port;
-    AlternateProtocol protocol;
-  };
-  // BrokenAlternateProtocolEntry with expiration time.
-  struct BrokenAlternateProtocolEntryWithTime {
-    BrokenAlternateProtocolEntryWithTime(
-        const BrokenAlternateProtocolEntry& broken_alternate_protocol_entry,
-        base::TimeTicks when)
-        : broken_alternate_protocol_entry(broken_alternate_protocol_entry),
-          when(when) {}
-
-    BrokenAlternateProtocolEntry broken_alternate_protocol_entry;
+    AlternativeService altsvc;

[Ryan Hamilton, 2015/03/06 23:01:12]

The style guide is not a fan of abbreviations. How about "alternative"?

[Bence, 2015/03/08 18:09:04]

I would argue that altsvc is a standard abbrevatiation: for example, it is used
in the HTTP/1.1 header, it is the name of the HTTP/2 frame, and it is used in
the filename of the specification.  I agree that it is not as widely known as
DNS, brought as an example in the style guide, but I feel like we do not hurt
anybody by using altsvc in the code, especially because the type is called
AlternativeService, so one does not have to look far.

However, if you insist on not using it, I would advocate for
|alternative_service|.  I fear that |alternative| is too generic.

[Ryan Hamilton, 2015/03/09 13:48:50]

I ping'd sleevi to get a second opinion. He like your choice of
alternative_service. So let's go with that.

     base::TimeTicks when;
   };
   // Deque of BrokenAlternateProtocolEntryWithTime items, ordered by expiration
   // time.
   typedef std::deque<BrokenAlternateProtocolEntryWithTime>
       BrokenAlternateProtocolList;
   // Map from (server, alternate protocol and port) to the number of
   // times that alternate protocol has been marked broken for that server.
-  typedef std::map<BrokenAlternateProtocolEntry, int>
-      BrokenAlternateProtocolMap;
+  typedef std::map<AlternativeService, int> BrokenAlternateProtocolMap;
 
   // Return the iterator for |server|, or for its canonical host, or end.
   AlternateProtocolMap::const_iterator GetAlternateProtocolIterator(
       const HostPortPair& server);
 
   // Return the canonical host for |server|, or end if none exists.
   CanonicalHostMap::const_iterator GetCanonicalHost(HostPortPair server) const;
 
   void RemoveCanonicalHost(const HostPortPair& server);
   void ExpireBrokenAlternateProtocolMappings();
@@ skipping 20 matching lines @@
   double alternate_protocol_probability_threshold_;
 
   base::WeakPtrFactory<HttpServerPropertiesImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesImpl);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_SERVER_PROPERTIES_IMPL_H_