blob: 67b378a653e21d2be6c927db4f01bc57da72dad5 (
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
|
// Copyright (c) 2006-2008 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_policy.h"
#include "net/base/cookie_store.h"
#include "net/base/host_resolver.h"
#include "net/base/ssl_config_service.h"
#include "net/base/strict_transport_security_state.h"
#include "net/ftp/ftp_auth_cache.h"
#include "net/proxy/proxy_service.h"
#include "net/url_request/url_request_tracker.h"
namespace net {
class FtpTransactionFactory;
class HttpTransactionFactory;
}
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_store_(NULL),
strict_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.
net::CookieStore* cookie_store() { return cookie_store_.get(); }
// Gets the cookie policy for this context.
net::CookiePolicy* cookie_policy() { return &cookie_policy_; }
net::StrictTransportSecurityState* strict_transport_security_state() {
return strict_transport_security_state_; }
// Gets the FTP authentication cache for this context.
net::FtpAuthCache* ftp_auth_cache() { return &ftp_auth_cache_; }
// 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.
URLRequestTracker* request_tracker() { return &request_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 for each cookie returning for the given request. A pointer to
// the cookie is passed so that it can be modified. Returns true if the
// cookie was not dropped (it could still be modified though).
virtual bool InterceptCookie(const URLRequest* request, std::string* cookie) {
return true;
}
// Called before adding cookies to sent requests. Allows overriding
// requests to block sending of cookies.
virtual bool AllowSendingCookies(const URLRequest* request) 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_;
scoped_refptr<net::CookieStore> cookie_store_;
net::CookiePolicy cookie_policy_;
scoped_refptr<net::StrictTransportSecurityState>
strict_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.
URLRequestTracker request_tracker_;
private:
DISALLOW_COPY_AND_ASSIGN(URLRequestContext);
};
#endif // NET_URL_REQUEST_URL_REQUEST_CONTEXT_H_
|
