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
207
208
209
210
211
|
// 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.
// This class is useful for building a simple URLRequestContext. Most creators
// of new URLRequestContexts should use this helper class to construct it. Call
// any configuration params, and when done, invoke Build() to construct the
// URLRequestContext. This URLRequestContext will own all its own storage.
//
// URLRequestContextBuilder and its associated params classes are initially
// populated with "sane" default values. Read through the comments to figure out
// what these are.
#ifndef NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_
#define NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/files/file_path.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "build/build_config.h"
#include "net/base/net_export.h"
#include "net/base/network_delegate.h"
#include "net/dns/host_resolver.h"
#include "net/proxy/proxy_config_service.h"
#include "net/proxy/proxy_service.h"
#include "net/socket/next_proto.h"
namespace net {
class FtpTransactionFactory;
class HostMappingRules;
class HttpAuthHandlerFactory;
class ProxyConfigService;
class URLRequestContext;
class NET_EXPORT URLRequestContextBuilder {
public:
struct NET_EXPORT HttpCacheParams {
enum Type {
IN_MEMORY,
DISK,
};
HttpCacheParams();
~HttpCacheParams();
// The type of HTTP cache. Default is IN_MEMORY.
Type type;
// The max size of the cache in bytes. Default is algorithmically determined
// based off available disk space.
int max_size;
// The cache path (when type is DISK).
base::FilePath path;
};
struct NET_EXPORT HttpNetworkSessionParams {
HttpNetworkSessionParams();
~HttpNetworkSessionParams();
// These fields mirror those in net::HttpNetworkSession::Params;
bool ignore_certificate_errors;
HostMappingRules* host_mapping_rules;
uint16 testing_fixed_http_port;
uint16 testing_fixed_https_port;
NextProtoVector next_protos;
std::string trusted_spdy_proxy;
bool use_alternate_protocols;
};
URLRequestContextBuilder();
~URLRequestContextBuilder();
// These functions are mutually exclusive. The ProxyConfigService, if
// set, will be used to construct a ProxyService.
void set_proxy_config_service(ProxyConfigService* proxy_config_service) {
proxy_config_service_.reset(proxy_config_service);
}
void set_proxy_service(ProxyService* proxy_service) {
proxy_service_.reset(proxy_service);
}
// Call these functions to specify hard-coded Accept-Language
// or User-Agent header values for all requests that don't
// have the headers already set.
void set_accept_language(const std::string& accept_language) {
accept_language_ = accept_language;
}
void set_user_agent(const std::string& user_agent) {
user_agent_ = user_agent;
}
// Control support for data:// requests. By default it's disabled.
void set_data_enabled(bool enable) {
data_enabled_ = enable;
}
#if !defined(DISABLE_FILE_SUPPORT)
// Control support for file:// requests. By default it's disabled.
void set_file_enabled(bool enable) {
file_enabled_ = enable;
}
#endif
#if !defined(DISABLE_FTP_SUPPORT)
// Control support for ftp:// requests. By default it's disabled.
void set_ftp_enabled(bool enable) {
ftp_enabled_ = enable;
}
#endif
// TODO(mmenke): Probably makes sense to get rid of this, and have consumers
// set their own NetLog::Observers instead.
void set_net_log(NetLog* net_log) {
net_log_.reset(net_log);
}
// By default host_resolver is constructed with CreateDefaultResolver.
void set_host_resolver(HostResolver* host_resolver) {
host_resolver_.reset(host_resolver);
}
// Uses BasicNetworkDelegate by default. Note that calling Build will unset
// any custom delegate in builder, so this must be called each time before
// Build is called.
void set_network_delegate(NetworkDelegate* delegate) {
network_delegate_.reset(delegate);
}
// Adds additional auth handler factories to be used in addition to what is
// provided in the default |HttpAuthHandlerRegistryFactory|. The auth |scheme|
// and |factory| are provided. The builder takes ownership of the factory and
// Build() must be called after this method.
void add_http_auth_handler_factory(const std::string& scheme,
net::HttpAuthHandlerFactory* factory) {
extra_http_auth_handlers_.push_back(SchemeFactory(scheme, factory));
}
// By default HttpCache is enabled with a default constructed HttpCacheParams.
void EnableHttpCache(const HttpCacheParams& params);
void DisableHttpCache();
// Override default net::HttpNetworkSession::Params settings.
void set_http_network_session_params(
const HttpNetworkSessionParams& http_network_session_params) {
http_network_session_params_ = http_network_session_params;
}
void set_transport_security_persister_path(
const base::FilePath& transport_security_persister_path) {
transport_security_persister_path_ = transport_security_persister_path;
}
// Adjust |http_network_session_params_.next_protos| to enable SPDY and QUIC.
void SetSpdyAndQuicEnabled(bool spdy_enabled,
bool quic_enabled);
void set_throttling_enabled(bool throttling_enabled) {
throttling_enabled_ = throttling_enabled;
}
URLRequestContext* Build();
private:
struct NET_EXPORT SchemeFactory {
SchemeFactory(const std::string& scheme,
net::HttpAuthHandlerFactory* factory);
~SchemeFactory();
std::string scheme;
net::HttpAuthHandlerFactory* factory;
};
std::string accept_language_;
std::string user_agent_;
// Include support for data:// requests.
bool data_enabled_;
#if !defined(DISABLE_FILE_SUPPORT)
// Include support for file:// requests.
bool file_enabled_;
#endif
#if !defined(DISABLE_FTP_SUPPORT)
// Include support for ftp:// requests.
bool ftp_enabled_;
#endif
bool http_cache_enabled_;
bool throttling_enabled_;
HttpCacheParams http_cache_params_;
HttpNetworkSessionParams http_network_session_params_;
base::FilePath transport_security_persister_path_;
scoped_ptr<NetLog> net_log_;
scoped_ptr<HostResolver> host_resolver_;
scoped_ptr<ProxyConfigService> proxy_config_service_;
scoped_ptr<ProxyService> proxy_service_;
scoped_ptr<NetworkDelegate> network_delegate_;
scoped_ptr<FtpTransactionFactory> ftp_transaction_factory_;
std::vector<SchemeFactory> extra_http_auth_handlers_;
DISALLOW_COPY_AND_ASSIGN(URLRequestContextBuilder);
};
} // namespace net
#endif // NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_
|
