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
|
// Copyright (c) 2011 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 <map>
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/gtest_prod_util.h"
#include "base/hash_tables.h"
#include "base/memory/mru_cache.h"
#include "base/threading/non_thread_safe.h"
#include "base/values.h"
#include "net/base/host_port_pair.h"
#include "net/base/net_export.h"
#include "net/http/http_pipelined_host_capability.h"
#include "net/http/http_server_properties.h"
namespace base {
class ListValue;
}
namespace net {
// The implementation for setting/retrieving the HTTP server properties.
class NET_EXPORT HttpServerPropertiesImpl
: public HttpServerProperties,
NON_EXPORTED_BASE(public base::NonThreadSafe) {
public:
HttpServerPropertiesImpl();
virtual ~HttpServerPropertiesImpl();
// Initializes |spdy_servers_table_| with the servers (host/port) from
// |spdy_servers| that either support SPDY or not.
void InitializeSpdyServers(std::vector<std::string>* spdy_servers,
bool support_spdy);
void InitializeAlternateProtocolServers(
AlternateProtocolMap* alternate_protocol_servers);
void InitializeSpdySettingsServers(SpdySettingsMap* spdy_settings_map);
// Initializes |pipeline_capability_map_| with the servers (host/port) from
// |pipeline_capability_map| that either support HTTP pipelining or not.
void InitializePipelineCapabilities(
const PipelineCapabilityMap* pipeline_capability_map);
// Get the list of servers (host/port) that support SPDY.
void GetSpdyServerList(base::ListValue* spdy_server_list) const;
// Returns flattened string representation of the |host_port_pair|. Used by
// unittests.
static std::string GetFlattenedSpdyServer(
const net::HostPortPair& host_port_pair);
// Debugging to simulate presence of an AlternateProtocol.
// If we don't have an alternate protocol in the map for any given host/port
// pair, force this ProtocolPortPair.
static void ForceAlternateProtocol(const PortAlternateProtocolPair& pair);
static void DisableForcedAlternateProtocol();
// Changes the number of host/port pairs we remember pipelining capability
// for. A larger number means we're more likely to be able to pipeline
// immediately if a host is known good, but uses more memory. This function
// can only be called if |pipeline_capability_map_| is empty.
void SetNumPipelinedHostsToRemember(int max_size);
// -----------------------------
// HttpServerProperties methods:
// -----------------------------
// Deletes all data.
virtual void Clear() OVERRIDE;
// Returns true if |server| supports SPDY.
virtual bool SupportsSpdy(const HostPortPair& server) const OVERRIDE;
// Add |server| into the persistent store.
virtual void SetSupportsSpdy(const HostPortPair& server,
bool support_spdy) OVERRIDE;
// Returns true if |server| has an Alternate-Protocol header.
virtual bool HasAlternateProtocol(const HostPortPair& server) const OVERRIDE;
// Returns the Alternate-Protocol and port for |server|.
// HasAlternateProtocol(server) must be true.
virtual PortAlternateProtocolPair GetAlternateProtocol(
const HostPortPair& server) const OVERRIDE;
// Sets the Alternate-Protocol for |server|.
virtual void SetAlternateProtocol(
const HostPortPair& server,
uint16 alternate_port,
AlternateProtocol alternate_protocol) OVERRIDE;
// Sets the Alternate-Protocol for |server| to be BROKEN.
virtual void SetBrokenAlternateProtocol(const HostPortPair& server) OVERRIDE;
// Returns all Alternate-Protocol mappings.
virtual const AlternateProtocolMap& alternate_protocol_map() const OVERRIDE;
// Gets a reference to the SpdySettings stored for a host.
// If no settings are stored, returns an empty set of settings.
virtual const spdy::SpdySettings& GetSpdySettings(
const HostPortPair& host_port_pair) const OVERRIDE;
// Saves settings for a host. Returns true if SpdySettings are to be
// persisted because |spdy_settings_map_| has been updated.
virtual bool SetSpdySettings(const HostPortPair& host_port_pair,
const spdy::SpdySettings& settings) OVERRIDE;
// Clears all spdy_settings.
virtual void ClearSpdySettings() OVERRIDE;
// Returns all persistent SpdySettings.
virtual const SpdySettingsMap& spdy_settings_map() const OVERRIDE;
virtual HttpPipelinedHostCapability GetPipelineCapability(
const HostPortPair& origin) OVERRIDE;
virtual void SetPipelineCapability(
const HostPortPair& origin,
HttpPipelinedHostCapability capability) OVERRIDE;
virtual void ClearPipelineCapabilities() OVERRIDE;
virtual PipelineCapabilityMap GetPipelineCapabilityMap() const OVERRIDE;
private:
typedef base::MRUCache<
HostPortPair, HttpPipelinedHostCapability> CachedPipelineCapabilityMap;
// |spdy_servers_table_| has flattened representation of servers (host/port
// pair) that either support or not support SPDY protocol.
typedef base::hash_map<std::string, bool> SpdyServerHostPortTable;
SpdyServerHostPortTable spdy_servers_table_;
AlternateProtocolMap alternate_protocol_map_;
SpdySettingsMap spdy_settings_map_;
scoped_ptr<CachedPipelineCapabilityMap> pipeline_capability_map_;
DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesImpl);
};
} // namespace net
#endif // NET_HTTP_HTTP_SERVER_PROPERTIES_IMPL_H_
|
