blob: fb2608f59db1d8786a37eab31ab65b889e524006 (
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
|
// Copyright (c) 2010 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 represents contextual information (cookies, cache, etc.)
// that's useful when processing resource requests.
// The class is reference-counted so that it can be cleaned up after any
// requests that are using it have been completed.
#ifndef NET_URL_REQUEST_URL_REQUEST_CONTEXT_H_
#define NET_URL_REQUEST_URL_REQUEST_CONTEXT_H_
#include "base/ref_counted.h"
#include "base/string_util.h"
#include "net/base/cookie_store.h"
#include "net/base/host_resolver.h"
#include "net/base/ssl_config_service.h"
#include "net/base/transport_security_state.h"
#include "net/ftp/ftp_auth_cache.h"
#include "net/proxy/proxy_service.h"
#include "net/url_request/request_tracker.h"
namespace net {
class CookiePolicy;
class FtpTransactionFactory;
class HttpAuthHandlerFactory;
class HttpTransactionFactory;
class SocketStream;
}
class URLRequest;
// Subclass to provide application-specific context for URLRequest instances.
class URLRequestContext :
public base::RefCountedThreadSafe<URLRequestContext> {
public:
URLRequestContext()
: http_transaction_factory_(NULL),
ftp_transaction_factory_(NULL),
cookie_policy_(NULL),
transport_security_state_(NULL) {
}
net::HostResolver* host_resolver() const {
return host_resolver_;
}
// Get the proxy service for this context.
net::ProxyService* proxy_service() const {
return proxy_service_;
}
// Get the ssl config service for this context.
net::SSLConfigService* ssl_config_service() const {
return ssl_config_service_;
}
// Gets the http transaction factory for this context.
net::HttpTransactionFactory* http_transaction_factory() const {
return http_transaction_factory_;
}
// Gets the ftp transaction factory for this context.
net::FtpTransactionFactory* ftp_transaction_factory() {
return ftp_transaction_factory_;
}
// Gets the cookie store for this context (may be null, in which case
// cookies are not stored).
net::CookieStore* cookie_store() { return cookie_store_.get(); }
// Gets the cookie policy for this context (may be null, in which case
// cookies are allowed).
net::CookiePolicy* cookie_policy() { return cookie_policy_; }
net::TransportSecurityState* transport_security_state() {
return transport_security_state_; }
// Gets the FTP authentication cache for this context.
net::FtpAuthCache* ftp_auth_cache() { return &ftp_auth_cache_; }
// Gets the HTTP Authentication Handler Factory for this context.
// The factory is only valid for the lifetime of this URLRequestContext
net::HttpAuthHandlerFactory* http_auth_handler_factory() {
return http_auth_handler_factory_;
}
// Gets the value of 'Accept-Charset' header field.
const std::string& accept_charset() const { return accept_charset_; }
// Gets the value of 'Accept-Language' header field.
const std::string& accept_language() const { return accept_language_; }
// Gets the tracker for URLRequests associated with this context.
RequestTracker<URLRequest>* url_request_tracker() {
return &url_request_tracker_;
}
// Gets the tracker for SocketStreams associated with this context.
RequestTracker<net::SocketStream>* socket_stream_tracker() {
return &socket_stream_tracker_;
}
// Gets the UA string to use for the given URL. Pass an invalid URL (such as
// GURL()) to get the default UA string. Subclasses should override this
// method to provide a UA string.
virtual const std::string& GetUserAgent(const GURL& url) const {
return EmptyString();
}
// In general, referrer_charset is not known when URLRequestContext is
// constructed. So, we need a setter.
const std::string& referrer_charset() const { return referrer_charset_; }
void set_referrer_charset(const std::string& charset) {
referrer_charset_ = charset;
}
// Called before adding cookies to requests. Returns true if cookie can
// be added to the request. The cookie might still be modified though.
virtual bool InterceptRequestCookies(const URLRequest* request,
const std::string& cookies) const {
return true;
}
// Called before adding cookies from respones to the cookie monster. Returns
// true if the cookie can be added. The cookie might still be modified though.
virtual bool InterceptResponseCookie(const URLRequest* request,
const std::string& cookie) const {
return true;
}
protected:
friend class base::RefCountedThreadSafe<URLRequestContext>;
virtual ~URLRequestContext() {}
// The following members are expected to be initialized and owned by
// subclasses.
scoped_refptr<net::HostResolver> host_resolver_;
scoped_refptr<net::ProxyService> proxy_service_;
scoped_refptr<net::SSLConfigService> ssl_config_service_;
net::HttpTransactionFactory* http_transaction_factory_;
net::FtpTransactionFactory* ftp_transaction_factory_;
net::HttpAuthHandlerFactory* http_auth_handler_factory_;
scoped_refptr<net::CookieStore> cookie_store_;
net::CookiePolicy* cookie_policy_;
scoped_refptr<net::TransportSecurityState> transport_security_state_;
net::FtpAuthCache ftp_auth_cache_;
std::string accept_language_;
std::string accept_charset_;
// The charset of the referrer where this request comes from. It's not
// used in communication with a server but is used to construct a suggested
// filename for file download.
std::string referrer_charset_;
// Tracks the requests associated with this context.
RequestTracker<URLRequest> url_request_tracker_;
// Trakcs the socket streams associated with this context.
RequestTracker<net::SocketStream> socket_stream_tracker_;
private:
DISALLOW_COPY_AND_ASSIGN(URLRequestContext);
};
#endif // NET_URL_REQUEST_URL_REQUEST_CONTEXT_H_
|
