Revert of Remove support for Alt-Svc/Alternate Protocol Probability

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 <stdint.h>
 
 #include <map>
@@ skipping 120 matching lines @@
   }
 
   std::string ToString() const;
 
   AlternateProtocol protocol;
   std::string host;
   uint16_t port;
 };
 
 struct NET_EXPORT AlternativeServiceInfo {
-  AlternativeServiceInfo() : alternative_service() {}
+  AlternativeServiceInfo() : alternative_service(), probability(0.0) {}
 
   AlternativeServiceInfo(const AlternativeService& alternative_service,
+                         double probability,
                          base::Time expiration)
       : alternative_service(alternative_service),
+        probability(probability),
         expiration(expiration) {}
 
   AlternativeServiceInfo(AlternateProtocol protocol,
                          const std::string& host,
                          uint16_t port,
+                         double probability,
                          base::Time expiration)
       : alternative_service(protocol, host, port),
+        probability(probability),
         expiration(expiration) {}
 
   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 &&
-           expiration == other.expiration;
+           probability == other.probability && expiration == other.expiration;
   }
 
   bool operator!=(const AlternativeServiceInfo& other) const {
     return !this->operator==(other);
   }
 
   std::string ToString() const;
 
   AlternativeService alternative_service;
+  double probability;
   base::Time expiration;
 };
 
 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 {
@@ skipping 71 matching lines @@
   // Require HTTP/1.1 on subsequent connections.  Not persisted.
   virtual void SetHTTP11Required(const HostPortPair& server) = 0;
 
   // Modify SSLConfig to force HTTP/1.1.
   static void ForceHTTP11(SSLConfig* ssl_config);
 
   // Modify SSLConfig to force HTTP/1.1 if necessary.
   virtual void MaybeForceHTTP11(const HostPortPair& server,
                                 SSLConfig* ssl_config) = 0;
 
-  // Return all alternative services for |origin|, including broken ones.
+  // Return all alternative services for |origin| with probability greater than
+  // or equal to the threshold, including broken ones.
   // Returned alternative services never have empty hostnames.
   virtual AlternativeServiceVector GetAlternativeServices(
       const HostPortPair& origin) = 0;
 
   // Set a single alternative service for |origin|.  Previous alternative
   // services for |origin| are discarded.
   // |alternative_service.host| may be empty.
   // Return true if |alternative_service_map_| is changed.
   virtual bool SetAlternativeService(
       const HostPortPair& origin,
       const AlternativeService& alternative_service,
+      double alternative_probability,
       base::Time expiration) = 0;
 
   // Set alternative services for |origin|.  Previous alternative services for
   // |origin| are discarded.
   // Hostnames in |alternative_service_info_vector| may be empty.
   // Return true if |alternative_service_map_| is changed.
   virtual bool SetAlternativeServices(
       const HostPortPair& origin,
       const AlternativeServiceInfoVector& alternative_service_info_vector) = 0;
 
@@ skipping 26 matching lines @@
   virtual void ClearAlternativeServices(const HostPortPair& origin) = 0;
 
   // Returns all alternative service mappings.
   // Returned alternative services may have empty hostnames.
   virtual const AlternativeServiceMap& alternative_service_map() const = 0;
 
   // Returns all alternative service mappings as human readable strings.
   // Empty alternative service hostnames will be printed as such.
   virtual scoped_ptr<base::Value> GetAlternativeServiceInfoAsValue() 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 SetAlternativeServiceProbabilityThreshold(double threshold) = 0;
+
   // Gets a reference to the SettingsMap stored for a host.
   // If no settings are stored, returns an empty SettingsMap.
   virtual const SettingsMap& GetSpdySettings(
       const HostPortPair& host_port_pair) = 0;
 
   // Saves an individual SPDY setting for a host. Returns true if SPDY setting
   // is to be persisted.
   virtual bool SetSpdySetting(const HostPortPair& host_port_pair,
                               SpdySettingsIds id,
                               SpdySettingsFlags flags,
@@ skipping 41 matching lines @@
   virtual void SetMaxServerConfigsStoredInProperties(
       size_t max_server_configs_stored_in_properties) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HttpServerProperties);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_SERVER_PROPERTIES_H_