1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
// 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"
#include "base/containers/mru_cache.h"
#include "base/memory/weak_ptr.h"
#include "base/time/time.h"
#include "net/base/host_port_pair.h"
#include "net/base/net_export.h"
#include "net/http/http_pipelined_host_capability.h"
#include "net/socket/next_proto.h"
#include "net/spdy/spdy_framer.h" // TODO(willchan): Reconsider this.
namespace net {
enum AlternateProtocolUsage {
// Alternate Protocol was used without racing a normal connection.
ALTERNATE_PROTOCOL_USAGE_NO_RACE = 0,
// Alternate Protocol was used by winning a race with a normal connection.
ALTERNATE_PROTOCOL_USAGE_WON_RACE = 1,
// Alternate Protocol was not used by losing a race with a normal connection.
ALTERNATE_PROTOCOL_USAGE_LOST_RACE = 2,
// Alternate Protocol was not used because no Alternate-Protocol information
// was available when the request was issued, but an Alternate-Protocol header
// was present in the response.
ALTERNATE_PROTOCOL_USAGE_MAPPING_MISSING = 3,
// Alternate Protocol was not used because it was marked broken.
ALTERNATE_PROTOCOL_USAGE_BROKEN = 4,
// Maximum value for the enum.
ALTERNATE_PROTOCOL_USAGE_MAX,
};
// Log a histogram to reflect |usage|.
NET_EXPORT void HistogramAlternateProtocolUsage(AlternateProtocolUsage usage);
enum BrokenAlternateProtocolLocation {
BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB = 0,
BROKEN_ALTERNATE_PROTOCOL_LOCATION_QUIC_STREAM_FACTORY = 1,
BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_ALT = 2,
BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_MAIN = 3,
BROKEN_ALTERNATE_PROTOCOL_LOCATION_MAX,
};
// Log a histogram to reflect |location|.
NET_EXPORT void HistogramBrokenAlternateProtocolLocation(
BrokenAlternateProtocolLocation location);
enum AlternateProtocol {
DEPRECATED_NPN_SPDY_2 = 0,
ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION = DEPRECATED_NPN_SPDY_2,
NPN_SPDY_MINIMUM_VERSION = DEPRECATED_NPN_SPDY_2,
NPN_SPDY_3,
NPN_SPDY_3_1,
NPN_SPDY_4, // SPDY4 is HTTP/2.
NPN_SPDY_MAXIMUM_VERSION = NPN_SPDY_4,
QUIC,
ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION = QUIC,
ALTERNATE_PROTOCOL_BROKEN, // The alternate protocol is known to be broken.
UNINITIALIZED_ALTERNATE_PROTOCOL,
};
// Simply returns whether |protocol| is between
// ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION and
// ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION (inclusive).
NET_EXPORT bool IsAlternateProtocolValid(AlternateProtocol protocol);
enum AlternateProtocolSize {
NUM_VALID_ALTERNATE_PROTOCOLS =
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);
struct NET_EXPORT PortAlternateProtocolPair {
bool Equals(const PortAlternateProtocolPair& other) const {
return port == other.port && protocol == other.protocol;
}
std::string ToString() const;
uint16 port;
AlternateProtocol protocol;
};
typedef base::MRUCache<
HostPortPair, PortAlternateProtocolPair> AlternateProtocolMap;
typedef base::MRUCache<HostPortPair, SettingsMap> SpdySettingsMap;
typedef std::map<HostPortPair,
HttpPipelinedHostCapability> PipelineCapabilityMap;
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
// * Spdy Settings (like CWND ID field)
class NET_EXPORT HttpServerProperties {
public:
struct NetworkStats {
base::TimeDelta srtt;
uint64 bandwidth_estimate;
};
HttpServerProperties() {}
virtual ~HttpServerProperties() {}
// Gets a weak pointer for this object.
virtual base::WeakPtr<HttpServerProperties> GetWeakPtr() = 0;
// Deletes all data.
virtual void Clear() = 0;
// Returns true if |server| supports SPDY.
virtual bool SupportsSpdy(const HostPortPair& server) = 0;
// Add |server| into the persistent store. Should only be called from IO
// thread.
virtual void SetSupportsSpdy(const HostPortPair& server,
bool support_spdy) = 0;
// Returns true if |server| has an Alternate-Protocol header.
virtual bool HasAlternateProtocol(const HostPortPair& server) = 0;
// Returns the Alternate-Protocol and port for |server|.
// HasAlternateProtocol(server) must be true.
virtual PortAlternateProtocolPair GetAlternateProtocol(
const HostPortPair& server) = 0;
// Sets the Alternate-Protocol for |server|.
virtual void SetAlternateProtocol(const HostPortPair& server,
uint16 alternate_port,
AlternateProtocol alternate_protocol) = 0;
// Sets the Alternate-Protocol for |server| to be BROKEN.
virtual void SetBrokenAlternateProtocol(const HostPortPair& server) = 0;
// Returns true if Alternate-Protocol for |server| was recently BROKEN.
virtual bool WasAlternateProtocolRecentlyBroken(
const HostPortPair& server) = 0;
// Confirms that Alternate-Protocol for |server| is working.
virtual void ConfirmAlternateProtocol(const HostPortPair& server) = 0;
// Clears the Alternate-Protocol for |server|.
virtual void ClearAlternateProtocol(const HostPortPair& server) = 0;
// Returns all Alternate-Protocol mappings.
virtual const AlternateProtocolMap& alternate_protocol_map() const = 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,
uint32 value) = 0;
// Clears all SPDY settings for a host.
virtual void ClearSpdySettings(const HostPortPair& host_port_pair) = 0;
// Clears all SPDY settings for all hosts.
virtual void ClearAllSpdySettings() = 0;
// Returns all persistent SPDY settings.
virtual const SpdySettingsMap& spdy_settings_map() const = 0;
virtual void SetServerNetworkStats(const HostPortPair& host_port_pair,
NetworkStats stats) = 0;
virtual const NetworkStats* GetServerNetworkStats(
const HostPortPair& host_port_pair) const = 0;
virtual HttpPipelinedHostCapability GetPipelineCapability(
const HostPortPair& origin) = 0;
virtual void SetPipelineCapability(
const HostPortPair& origin,
HttpPipelinedHostCapability capability) = 0;
virtual void ClearPipelineCapabilities() = 0;
virtual PipelineCapabilityMap GetPipelineCapabilityMap() const = 0;
private:
DISALLOW_COPY_AND_ASSIGN(HttpServerProperties);
};
} // namespace net
#endif // NET_HTTP_HTTP_SERVER_PROPERTIES_H_
|
