1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef NET_HTTP_HTTP_SERVER_PROPERTIES_H_
6#define NET_HTTP_HTTP_SERVER_PROPERTIES_H_
7
8#include <map>
9#include <string>
10#include "base/basictypes.h"
11#include "base/containers/mru_cache.h"
12#include "base/memory/weak_ptr.h"
13#include "base/time/time.h"
14#include "net/base/host_port_pair.h"
15#include "net/base/net_export.h"
16#include "net/socket/next_proto.h"
17#include "net/spdy/spdy_framer.h"  // TODO(willchan): Reconsider this.
18
19namespace net {
20
21enum AlternateProtocolExperiment {
22  // 200 alternate_protocol servers are loaded (persisted 200 MRU servers).
23  ALTERNATE_PROTOCOL_NOT_PART_OF_EXPERIMENT = 0,
24  // 200 alternate_protocol servers are loaded (persisted 1000 MRU servers).
25  ALTERNATE_PROTOCOL_TRUNCATED_200_SERVERS,
26  // 1000 alternate_protocol servers are loaded (persisted 1000 MRU servers).
27  ALTERNATE_PROTOCOL_TRUNCATED_1000_SERVERS,
28};
29
30enum AlternateProtocolUsage {
31  // Alternate Protocol was used without racing a normal connection.
32  ALTERNATE_PROTOCOL_USAGE_NO_RACE = 0,
33  // Alternate Protocol was used by winning a race with a normal connection.
34  ALTERNATE_PROTOCOL_USAGE_WON_RACE = 1,
35  // Alternate Protocol was not used by losing a race with a normal connection.
36  ALTERNATE_PROTOCOL_USAGE_LOST_RACE = 2,
37  // Alternate Protocol was not used because no Alternate-Protocol information
38  // was available when the request was issued, but an Alternate-Protocol header
39  // was present in the response.
40  ALTERNATE_PROTOCOL_USAGE_MAPPING_MISSING = 3,
41  // Alternate Protocol was not used because it was marked broken.
42  ALTERNATE_PROTOCOL_USAGE_BROKEN = 4,
43  // Maximum value for the enum.
44  ALTERNATE_PROTOCOL_USAGE_MAX,
45};
46
47// Log a histogram to reflect |usage| and |alternate_protocol_experiment|.
48NET_EXPORT void HistogramAlternateProtocolUsage(
49    AlternateProtocolUsage usage,
50    AlternateProtocolExperiment alternate_protocol_experiment);
51
52enum BrokenAlternateProtocolLocation {
53  BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB = 0,
54  BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_STREAM_FACTORY = 1,
55  BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_ALT = 2,
56  BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_MAIN = 3,
57  BROKEN_ALTERNATE_PROTOCOL_LOCATION_MAX,
58};
59
60// Log a histogram to reflect |location|.
61NET_EXPORT void HistogramBrokenAlternateProtocolLocation(
62    BrokenAlternateProtocolLocation location);
63
64enum AlternateProtocol {
65  DEPRECATED_NPN_SPDY_2 = 0,
66  ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION = DEPRECATED_NPN_SPDY_2,
67  NPN_SPDY_MINIMUM_VERSION = DEPRECATED_NPN_SPDY_2,
68  NPN_SPDY_3,
69  NPN_SPDY_3_1,
70  NPN_SPDY_4,  // SPDY4 is HTTP/2.
71  NPN_SPDY_MAXIMUM_VERSION = NPN_SPDY_4,
72  QUIC,
73  ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION = QUIC,
74  ALTERNATE_PROTOCOL_BROKEN,  // The alternate protocol is known to be broken.
75  UNINITIALIZED_ALTERNATE_PROTOCOL,
76};
77
78// Simply returns whether |protocol| is between
79// ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION and
80// ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION (inclusive).
81NET_EXPORT bool IsAlternateProtocolValid(AlternateProtocol protocol);
82
83enum AlternateProtocolSize {
84  NUM_VALID_ALTERNATE_PROTOCOLS =
85    ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION -
86    ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION + 1,
87};
88
89NET_EXPORT const char* AlternateProtocolToString(AlternateProtocol protocol);
90NET_EXPORT AlternateProtocol AlternateProtocolFromString(
91    const std::string& str);
92NET_EXPORT_PRIVATE AlternateProtocol AlternateProtocolFromNextProto(
93    NextProto next_proto);
94
95struct NET_EXPORT AlternateProtocolInfo {
96  AlternateProtocolInfo(uint16 port,
97                        AlternateProtocol protocol,
98                        double probability)
99      : port(port),
100        protocol(protocol),
101        probability(probability) {}
102
103  bool Equals(const AlternateProtocolInfo& other) const {
104    return port == other.port &&
105        protocol == other.protocol &&
106        probability == other.probability;
107  }
108
109  std::string ToString() const;
110
111  uint16 port;
112  AlternateProtocol protocol;
113  double probability;
114};
115
116struct NET_EXPORT SupportsQuic {
117  SupportsQuic() : used_quic(false) {}
118  SupportsQuic(bool used_quic, const std::string& address)
119      : used_quic(used_quic),
120        address(address) {}
121
122  bool Equals(const SupportsQuic& other) const {
123    return used_quic == other.used_quic && address == other.address;
124  }
125
126  bool used_quic;
127  std::string address;
128};
129
130typedef base::MRUCache<
131    HostPortPair, AlternateProtocolInfo> AlternateProtocolMap;
132typedef base::MRUCache<HostPortPair, SettingsMap> SpdySettingsMap;
133typedef std::map<HostPortPair, SupportsQuic> SupportsQuicMap;
134
135extern const char kAlternateProtocolHeader[];
136
137// The interface for setting/retrieving the HTTP server properties.
138// Currently, this class manages servers':
139// * SPDY support (based on NPN results)
140// * Alternate-Protocol support
141// * Spdy Settings (like CWND ID field)
142class NET_EXPORT HttpServerProperties {
143 public:
144  struct NetworkStats {
145    base::TimeDelta srtt;
146    uint64 bandwidth_estimate;
147  };
148
149  HttpServerProperties() {}
150  virtual ~HttpServerProperties() {}
151
152  // Gets a weak pointer for this object.
153  virtual base::WeakPtr<HttpServerProperties> GetWeakPtr() = 0;
154
155  // Deletes all data.
156  virtual void Clear() = 0;
157
158  // Returns true if |server| supports SPDY.
159  virtual bool SupportsSpdy(const HostPortPair& server) = 0;
160
161  // Add |server| into the persistent store. Should only be called from IO
162  // thread.
163  virtual void SetSupportsSpdy(const HostPortPair& server,
164                               bool support_spdy) = 0;
165
166  // Returns true if |server| has an Alternate-Protocol header.
167  virtual bool HasAlternateProtocol(const HostPortPair& server) = 0;
168
169  // Returns the Alternate-Protocol and port for |server|.
170  // HasAlternateProtocol(server) must be true.
171  virtual AlternateProtocolInfo GetAlternateProtocol(
172      const HostPortPair& server) = 0;
173
174  // Sets the Alternate-Protocol for |server|.
175  virtual void SetAlternateProtocol(const HostPortPair& server,
176                                    uint16 alternate_port,
177                                    AlternateProtocol alternate_protocol,
178                                    double probability) = 0;
179
180  // Sets the Alternate-Protocol for |server| to be BROKEN.
181  virtual void SetBrokenAlternateProtocol(const HostPortPair& server) = 0;
182
183  // Returns true if Alternate-Protocol for |server| was recently BROKEN.
184  virtual bool WasAlternateProtocolRecentlyBroken(
185      const HostPortPair& server) = 0;
186
187  // Confirms that Alternate-Protocol for |server| is working.
188  virtual void ConfirmAlternateProtocol(const HostPortPair& server) = 0;
189
190  // Clears the Alternate-Protocol for |server|.
191  virtual void ClearAlternateProtocol(const HostPortPair& server) = 0;
192
193  // Returns all Alternate-Protocol mappings.
194  virtual const AlternateProtocolMap& alternate_protocol_map() const = 0;
195
196  virtual void SetAlternateProtocolExperiment(
197      AlternateProtocolExperiment experiment) = 0;
198
199  // Sets the threshold to be used when evaluating Alternate-Protocol
200  // advertisments. Only advertisements with a with a probability
201  // greater than |threshold| will be honored. |threshold| must be
202  // between 0 and 1 inclusive. Hence, a threshold of 0 implies that
203  // all advertisements will be honored.
204  virtual void SetAlternateProtocolProbabilityThreshold(
205      double threshold) = 0;
206
207  virtual AlternateProtocolExperiment GetAlternateProtocolExperiment()
208      const = 0;
209
210  // Gets a reference to the SettingsMap stored for a host.
211  // If no settings are stored, returns an empty SettingsMap.
212  virtual const SettingsMap& GetSpdySettings(
213      const HostPortPair& host_port_pair) = 0;
214
215  // Saves an individual SPDY setting for a host. Returns true if SPDY setting
216  // is to be persisted.
217  virtual bool SetSpdySetting(const HostPortPair& host_port_pair,
218                              SpdySettingsIds id,
219                              SpdySettingsFlags flags,
220                              uint32 value) = 0;
221
222  // Clears all SPDY settings for a host.
223  virtual void ClearSpdySettings(const HostPortPair& host_port_pair) = 0;
224
225  // Clears all SPDY settings for all hosts.
226  virtual void ClearAllSpdySettings() = 0;
227
228  // Returns all persistent SPDY settings.
229  virtual const SpdySettingsMap& spdy_settings_map() const = 0;
230
231  // TODO(rtenneti): Make SupportsQuic a global (instead of per host_port_pair).
232  virtual SupportsQuic GetSupportsQuic(
233      const HostPortPair& host_port_pair) const = 0;
234
235  virtual void SetSupportsQuic(const HostPortPair& host_port_pair,
236                               bool used_quic,
237                               const std::string& address) = 0;
238
239  virtual const SupportsQuicMap& supports_quic_map() const = 0;
240
241  virtual void SetServerNetworkStats(const HostPortPair& host_port_pair,
242                                     NetworkStats stats) = 0;
243
244  virtual const NetworkStats* GetServerNetworkStats(
245      const HostPortPair& host_port_pair) const = 0;
246
247 private:
248  DISALLOW_COPY_AND_ASSIGN(HttpServerProperties);
249};
250
251}  // namespace net
252
253#endif  // NET_HTTP_HTTP_SERVER_PROPERTIES_H_
254