Introduce AlternativeServiceInfo.

net/http/http_server_properties.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_H_
 #define NET_HTTP_HTTP_SERVER_PROPERTIES_H_
 
 #include <map>
 #include <string>
 #include "base/basictypes.h"
@@ skipping 68 matching lines @@
     ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION -
     ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION + 1,
 };
 
 NET_EXPORT const char* AlternateProtocolToString(AlternateProtocol protocol);
 NET_EXPORT AlternateProtocol AlternateProtocolFromString(
     const std::string& str);
 NET_EXPORT_PRIVATE AlternateProtocol AlternateProtocolFromNextProto(
     NextProto next_proto);
 
+// (protocol, host, port) triple as defined in
+// https://tools.ietf.org/id/draft-ietf-httpbis-alt-svc-06.html
 struct NET_EXPORT AlternativeService {
   AlternativeService()
       : protocol(UNINITIALIZED_ALTERNATE_PROTOCOL), host(), port(0) {}
 
   AlternativeService(AlternateProtocol protocol,
                      const std::string& host,
                      uint16 port)
       : protocol(protocol), host(host), port(port) {}
 
   AlternativeService(AlternateProtocol protocol,
@@ skipping 12 matching lines @@
   }
 
   bool operator<(const AlternativeService& other) const {
     if (protocol != other.protocol)
       return protocol < other.protocol;
     if (host != other.host)
       return host < other.host;
     return port < other.port;
   }
 
+  std::string ToString() const;
+
   AlternateProtocol protocol;
   std::string host;
   uint16 port;
 };
 
-struct NET_EXPORT AlternateProtocolInfo {
-  AlternateProtocolInfo()
-      : port(0), protocol(UNINITIALIZED_ALTERNATE_PROTOCOL), probability(0) {}
+struct NET_EXPORT AlternativeServiceInfo {
+  AlternativeServiceInfo() : alternative_service(), probability(0.0) {}
 
-  AlternateProtocolInfo(uint16 port,
-                        AlternateProtocol protocol,
-                        double probability)
-      : port(port), protocol(protocol), probability(probability) {}
+  AlternativeServiceInfo(const AlternativeService& alternative_service,
+                         double probability)
+      : alternative_service(alternative_service), probability(probability) {}
 
-  bool Equals(const AlternateProtocolInfo& other) const {
-    return port == other.port &&
-        protocol == other.protocol &&
-        probability == other.probability;
+  AlternativeServiceInfo(AlternateProtocol protocol,
+                         const std::string& host,
+                         uint16 port,
+                         double probability)
+      : alternative_service(protocol, host, port), probability(probability) {}
+
+  AlternativeServiceInfo(
+      const AlternativeServiceInfo& alternative_service_info) = default;
+  AlternativeServiceInfo& operator=(
+      const AlternativeServiceInfo& alternative_service_info) = default;
+
+  bool operator==(const AlternativeServiceInfo& other) const {
+    return alternative_service == other.alternative_service &&
+           probability == other.probability;
+  }
+
+  bool operator!=(const AlternativeServiceInfo& other) const {
+    return !this->operator==(other);
   }
 
   std::string ToString() const;
 
-  uint16 port;
-  AlternateProtocol protocol;
+  AlternativeService alternative_service;
   double probability;
 };
 
 struct NET_EXPORT SupportsQuic {
   SupportsQuic() : used_quic(false) {}
   SupportsQuic(bool used_quic, const std::string& address)
       : used_quic(used_quic),
         address(address) {}
 
   bool Equals(const SupportsQuic& other) const {
     return used_quic == other.used_quic && address == other.address;
   }
 
   bool used_quic;
   std::string address;
 };
 
 struct NET_EXPORT ServerNetworkStats {
   ServerNetworkStats() : bandwidth_estimate(QuicBandwidth::Zero()) {}
 
   base::TimeDelta srtt;
   QuicBandwidth bandwidth_estimate;
 };
 
-typedef base::MRUCache<
-    HostPortPair, AlternateProtocolInfo> AlternateProtocolMap;
+typedef base::MRUCache<HostPortPair, AlternativeServiceInfo>
+    AlternativeServiceMap;
 typedef base::MRUCache<HostPortPair, SettingsMap> SpdySettingsMap;
 typedef base::MRUCache<HostPortPair, ServerNetworkStats> ServerNetworkStatsMap;
 
 extern const char kAlternateProtocolHeader[];
 
 // The interface for setting/retrieving the HTTP server properties.
 // Currently, this class manages servers':
 // * SPDY support (based on NPN results)
-// * Alternate-Protocol support
+// * alternative service support
 // * Spdy Settings (like CWND ID field)
 class NET_EXPORT HttpServerProperties {
  public:
   HttpServerProperties() {}
   virtual ~HttpServerProperties() {}
 
   // Gets a weak pointer for this object.
   virtual base::WeakPtr<HttpServerProperties> GetWeakPtr() = 0;
 
   // Deletes all data.
@@ skipping 50 matching lines @@
   virtual bool WasAlternativeServiceRecentlyBroken(
       const AlternativeService& alternative_service) = 0;
 
   // Confirms that |alternative_service| is working.
   virtual void ConfirmAlternativeService(
       const AlternativeService& alternative_service) = 0;
 
   // Clears the alternative service for |origin|.
   virtual void ClearAlternativeService(const HostPortPair& origin) = 0;
 
-  // Returns all Alternate-Protocol mappings.
-  virtual const AlternateProtocolMap& alternate_protocol_map() const = 0;
+  // Returns all alternative service mappings.
+  virtual const AlternativeServiceMap& alternative_service_map() const = 0;
 
   // Sets the threshold to be used when evaluating alternative service
   // advertisments. Only advertisements with a probability greater than or equal
   // to |threshold| will be honored. |threshold| must be between 0.0 and 1.0
   // inclusive. Hence, a threshold of 0.0 implies that all advertisements will
   // be honored.
   virtual void SetAlternateProtocolProbabilityThreshold(
       double threshold) = 0;
 
   // Gets a reference to the SettingsMap stored for a host.
@@ skipping 30 matching lines @@
 
   virtual const ServerNetworkStatsMap& server_network_stats_map() const = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HttpServerProperties);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_SERVER_PROPERTIES_H_