blob: 1226c9cf5dd1a3b33b9f175554c0d79480b8d022 (
plain)
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
|
// 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.
#include "net/http/http_server_properties_impl.h"
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/stl_util.h"
#include "base/stringprintf.h"
namespace net {
HttpServerPropertiesImpl::HttpServerPropertiesImpl() {
}
HttpServerPropertiesImpl::~HttpServerPropertiesImpl() {
}
void HttpServerPropertiesImpl::InitializeSpdyServers(
std::vector<std::string>* spdy_servers,
bool support_spdy) {
DCHECK(CalledOnValidThread());
spdy_servers_table_.clear();
if (!spdy_servers)
return;
for (std::vector<std::string>::iterator it = spdy_servers->begin();
it != spdy_servers->end(); ++it) {
spdy_servers_table_[*it] = support_spdy;
}
}
void HttpServerPropertiesImpl::GetSpdyServerList(
base::ListValue* spdy_server_list) const {
DCHECK(CalledOnValidThread());
DCHECK(spdy_server_list);
spdy_server_list->Clear();
// Get the list of servers (host/port) that support SPDY.
for (SpdyServerHostPortTable::const_iterator it = spdy_servers_table_.begin();
it != spdy_servers_table_.end(); ++it) {
const std::string spdy_server_host_port = it->first;
if (it->second)
spdy_server_list->Append(new StringValue(spdy_server_host_port));
}
}
// static
std::string HttpServerPropertiesImpl::GetFlattenedSpdyServer(
const net::HostPortPair& host_port_pair) {
std::string spdy_server;
spdy_server.append(host_port_pair.host());
spdy_server.append(":");
base::StringAppendF(&spdy_server, "%d", host_port_pair.port());
return spdy_server;
}
static const PortAlternateProtocolPair* g_forced_alternate_protocol = NULL;
// static
void HttpServerPropertiesImpl::ForceAlternateProtocol(
const PortAlternateProtocolPair& pair) {
// Note: we're going to leak this.
if (g_forced_alternate_protocol)
delete g_forced_alternate_protocol;
g_forced_alternate_protocol = new PortAlternateProtocolPair(pair);
}
// static
void HttpServerPropertiesImpl::DisableForcedAlternateProtocol() {
delete g_forced_alternate_protocol;
g_forced_alternate_protocol = NULL;
}
void HttpServerPropertiesImpl::DeleteAll() {
DCHECK(CalledOnValidThread());
spdy_servers_table_.clear();
alternate_protocol_map_.clear();
}
bool HttpServerPropertiesImpl::SupportsSpdy(
const net::HostPortPair& host_port_pair) const {
DCHECK(CalledOnValidThread());
if (host_port_pair.host().empty())
return false;
std::string spdy_server = GetFlattenedSpdyServer(host_port_pair);
SpdyServerHostPortTable::const_iterator spdy_host_port =
spdy_servers_table_.find(spdy_server);
if (spdy_host_port != spdy_servers_table_.end())
return spdy_host_port->second;
return false;
}
void HttpServerPropertiesImpl::SetSupportsSpdy(
const net::HostPortPair& host_port_pair,
bool support_spdy) {
DCHECK(CalledOnValidThread());
if (host_port_pair.host().empty())
return;
std::string spdy_server = GetFlattenedSpdyServer(host_port_pair);
SpdyServerHostPortTable::iterator spdy_host_port =
spdy_servers_table_.find(spdy_server);
if ((spdy_host_port != spdy_servers_table_.end()) &&
(spdy_host_port->second == support_spdy)) {
return;
}
// Cache the data.
spdy_servers_table_[spdy_server] = support_spdy;
}
bool HttpServerPropertiesImpl::HasAlternateProtocol(
const HostPortPair& server) const {
return ContainsKey(alternate_protocol_map_, server) ||
g_forced_alternate_protocol;
}
PortAlternateProtocolPair
HttpServerPropertiesImpl::GetAlternateProtocol(
const HostPortPair& server) const {
DCHECK(HasAlternateProtocol(server));
// First check the map.
AlternateProtocolMap::const_iterator it =
alternate_protocol_map_.find(server);
if (it != alternate_protocol_map_.end())
return it->second;
// We must be forcing an alternate.
DCHECK(g_forced_alternate_protocol);
return *g_forced_alternate_protocol;
}
void HttpServerPropertiesImpl::SetAlternateProtocol(
const HostPortPair& server,
uint16 alternate_port,
AlternateProtocol alternate_protocol) {
if (alternate_protocol == ALTERNATE_PROTOCOL_BROKEN) {
LOG(DFATAL) << "Call MarkBrokenAlternateProtocolFor() instead.";
return;
}
PortAlternateProtocolPair alternate;
alternate.port = alternate_port;
alternate.protocol = alternate_protocol;
if (HasAlternateProtocol(server)) {
const PortAlternateProtocolPair existing_alternate =
GetAlternateProtocol(server);
if (existing_alternate.protocol == ALTERNATE_PROTOCOL_BROKEN) {
DVLOG(1) << "Ignore alternate protocol since it's known to be broken.";
return;
}
if (alternate_protocol != ALTERNATE_PROTOCOL_BROKEN &&
!existing_alternate.Equals(alternate)) {
LOG(WARNING) << "Changing the alternate protocol for: "
<< server.ToString()
<< " from [Port: " << existing_alternate.port
<< ", Protocol: " << existing_alternate.protocol
<< "] to [Port: " << alternate_port
<< ", Protocol: " << alternate_protocol
<< "].";
}
}
alternate_protocol_map_[server] = alternate;
}
void HttpServerPropertiesImpl::SetBrokenAlternateProtocol(
const HostPortPair& server) {
alternate_protocol_map_[server].protocol = ALTERNATE_PROTOCOL_BROKEN;
}
const AlternateProtocolMap&
HttpServerPropertiesImpl::alternate_protocol_map() const {
return alternate_protocol_map_;
}
} // namespace net
|
