url_fetcher.h revision 2a99a7e74a7f215066514fe81d2bfa6639d9eddd
1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef NET_URL_REQUEST_URL_FETCHER_H_ 6#define NET_URL_REQUEST_URL_FETCHER_H_ 7 8#include <string> 9#include <vector> 10 11#include "base/callback_forward.h" 12#include "base/memory/ref_counted.h" 13#include "base/supports_user_data.h" 14#include "base/task_runner.h" 15#include "net/base/net_export.h" 16 17class GURL; 18 19namespace base { 20class FilePath; 21class MessageLoopProxy; 22class TimeDelta; 23} 24 25namespace net { 26class HostPortPair; 27class HttpRequestHeaders; 28class HttpResponseHeaders; 29class URLFetcherDelegate; 30class URLRequestContextGetter; 31class URLRequestStatus; 32typedef std::vector<std::string> ResponseCookies; 33 34// To use this class, create an instance with the desired URL and a pointer to 35// the object to be notified when the URL has been loaded: 36// URLFetcher* fetcher = URLFetcher::Create("http://www.google.com", 37// URLFetcher::GET, this); 38// 39// You must also set a request context getter: 40// 41// fetcher->SetRequestContext(&my_request_context_getter); 42// 43// Then, optionally set properties on this object, like the request context or 44// extra headers: 45// fetcher->set_extra_request_headers("X-Foo: bar"); 46// 47// Finally, start the request: 48// fetcher->Start(); 49// 50// 51// The object you supply as a delegate must inherit from 52// URLFetcherDelegate; when the fetch is completed, 53// OnURLFetchComplete() will be called with a pointer to the URLFetcher. From 54// that point until the original URLFetcher instance is destroyed, you may use 55// accessor methods to see the result of the fetch. You should copy these 56// objects if you need them to live longer than the URLFetcher instance. If the 57// URLFetcher instance is destroyed before the callback happens, the fetch will 58// be canceled and no callback will occur. 59// 60// You may create the URLFetcher instance on any thread; OnURLFetchComplete() 61// will be called back on the same thread you use to create the instance. 62// 63// 64// NOTE: By default URLFetcher requests are NOT intercepted, except when 65// interception is explicitly enabled in tests. 66class NET_EXPORT URLFetcher { 67 public: 68 // Imposible http response code. Used to signal that no http response code 69 // was received. 70 enum ResponseCode { 71 RESPONSE_CODE_INVALID = -1 72 }; 73 74 enum RequestType { 75 GET, 76 POST, 77 HEAD, 78 DELETE_REQUEST, // DELETE is already taken on Windows. 79 // <winnt.h> defines a DELETE macro. 80 PUT, 81 PATCH, 82 }; 83 84 // Used by SetURLRequestUserData. The callback should make a fresh 85 // base::SupportsUserData::Data object every time it's called. 86 typedef base::Callback<base::SupportsUserData::Data*()> CreateDataCallback; 87 88 virtual ~URLFetcher(); 89 90 // |url| is the URL to send the request to. 91 // |request_type| is the type of request to make. 92 // |d| the object that will receive the callback on fetch completion. 93 static URLFetcher* Create(const GURL& url, 94 URLFetcher::RequestType request_type, 95 URLFetcherDelegate* d); 96 97 // Like above, but if there's a URLFetcherFactory registered with the 98 // implementation it will be used. |id| may be used during testing to identify 99 // who is creating the URLFetcher. 100 static URLFetcher* Create(int id, 101 const GURL& url, 102 URLFetcher::RequestType request_type, 103 URLFetcherDelegate* d); 104 105 // Cancels all existing URLFetchers. Will notify the URLFetcherDelegates. 106 // Note that any new URLFetchers created while this is running will not be 107 // cancelled. Typically, one would call this in the CleanUp() method of an IO 108 // thread, so that no new URLRequests would be able to start on the IO thread 109 // anyway. This doesn't prevent new URLFetchers from trying to post to the IO 110 // thread though, even though the task won't ever run. 111 static void CancelAll(); 112 113 // Normally interception is disabled for URLFetcher, but you can use this 114 // to enable it for tests. Also see ScopedURLFetcherFactory for another way 115 // of testing code that uses an URLFetcher. 116 static void SetEnableInterceptionForTests(bool enabled); 117 118 // Normally, URLFetcher will abort loads that request SSL client certificate 119 // authentication, but this method may be used to cause URLFetchers to ignore 120 // requests for client certificates and continue anonymously. Because such 121 // behaviour affects the URLRequestContext's shared network state and socket 122 // pools, it should only be used for testing. 123 static void SetIgnoreCertificateRequests(bool ignored); 124 125 // Sets data only needed by POSTs. All callers making POST requests should 126 // call one of the SetUpload* methods before the request is started. 127 // |upload_content_type| is the MIME type of the content, while 128 // |upload_content| is the data to be sent (the Content-Length header value 129 // will be set to the length of this data). 130 virtual void SetUploadData(const std::string& upload_content_type, 131 const std::string& upload_content) = 0; 132 133 // Sets data only needed by POSTs. All callers making POST requests should 134 // call one of the SetUpload* methods before the request is started. 135 // |upload_content_type| is the MIME type of the content, while 136 // |file_path| is the path to the file containing the data to be sent (the 137 // Content-Length header value will be set to the length of this file). 138 // |file_task_runner| will be used for all file operations. 139 virtual void SetUploadFilePath( 140 const std::string& upload_content_type, 141 const base::FilePath& file_path, 142 scoped_refptr<base::TaskRunner> file_task_runner) = 0; 143 144 // Indicates that the POST data is sent via chunked transfer encoding. 145 // This may only be called before calling Start(). 146 // Use AppendChunkToUpload() to give the data chunks after calling Start(). 147 virtual void SetChunkedUpload(const std::string& upload_content_type) = 0; 148 149 // Adds the given bytes to a request's POST data transmitted using chunked 150 // transfer encoding. 151 // This method should be called ONLY after calling Start(). 152 virtual void AppendChunkToUpload(const std::string& data, 153 bool is_last_chunk) = 0; 154 155 // Set one or more load flags as defined in net/base/load_flags.h. Must be 156 // called before the request is started. 157 virtual void SetLoadFlags(int load_flags) = 0; 158 159 // Returns the current load flags. 160 virtual int GetLoadFlags() const = 0; 161 162 // The referrer URL for the request. Must be called before the request is 163 // started. 164 virtual void SetReferrer(const std::string& referrer) = 0; 165 166 // Set extra headers on the request. Must be called before the request 167 // is started. 168 // This replaces the entire extra request headers. 169 virtual void SetExtraRequestHeaders( 170 const std::string& extra_request_headers) = 0; 171 172 // Add header (with format field-name ":" [ field-value ]) to the request 173 // headers. Must be called before the request is started. 174 // This appends the header to the current extra request headers. 175 virtual void AddExtraRequestHeader(const std::string& header_line) = 0; 176 177 virtual void GetExtraRequestHeaders( 178 HttpRequestHeaders* headers) const = 0; 179 180 // Set the URLRequestContext on the request. Must be called before the 181 // request is started. 182 virtual void SetRequestContext( 183 URLRequestContextGetter* request_context_getter) = 0; 184 185 // Set the URL that should be consulted for the third-party cookie 186 // blocking policy. 187 virtual void SetFirstPartyForCookies( 188 const GURL& first_party_for_cookies) = 0; 189 190 // Set the key and data callback that is used when setting the user 191 // data on any URLRequest objects this object creates. 192 virtual void SetURLRequestUserData( 193 const void* key, 194 const CreateDataCallback& create_data_callback) = 0; 195 196 // If |stop_on_redirect| is true, 3xx responses will cause the fetch to halt 197 // immediately rather than continue through the redirect. OnURLFetchComplete 198 // will be called, with the URLFetcher's URL set to the redirect destination, 199 // its status set to CANCELED, and its response code set to the relevant 3xx 200 // server response code. 201 virtual void SetStopOnRedirect(bool stop_on_redirect) = 0; 202 203 // If |retry| is false, 5xx responses will be propagated to the observer, 204 // if it is true URLFetcher will automatically re-execute the request, 205 // after backoff_delay() elapses. URLFetcher has it set to true by default. 206 virtual void SetAutomaticallyRetryOn5xx(bool retry) = 0; 207 208 virtual void SetMaxRetriesOn5xx(int max_retries) = 0; 209 virtual int GetMaxRetriesOn5xx() const = 0; 210 211 // Returns the back-off delay before the request will be retried, 212 // when a 5xx response was received. 213 virtual base::TimeDelta GetBackoffDelay() const = 0; 214 215 // Retries up to |max_retries| times when requests fail with 216 // ERR_NETWORK_CHANGED. If ERR_NETWORK_CHANGED is received after having 217 // retried |max_retries| times then it is propagated to the observer. 218 virtual void SetAutomaticallyRetryOnNetworkChanges(int max_retries) = 0; 219 220 // By default, the response is saved in a string. Call this method to save the 221 // response to a file instead. Must be called before Start(). 222 // |file_task_runner| will be used for all file operations. 223 // To save to a temporary file, use SaveResponseToTemporaryFile(). 224 // The created file is removed when the URLFetcher is deleted unless you 225 // take ownership by calling GetResponseAsFilePath(). 226 virtual void SaveResponseToFileAtPath( 227 const base::FilePath& file_path, 228 scoped_refptr<base::TaskRunner> file_task_runner) = 0; 229 230 // By default, the response is saved in a string. Call this method to save the 231 // response to a temporary file instead. Must be called before Start(). 232 // |file_task_runner| will be used for all file operations. 233 // The created file is removed when the URLFetcher is deleted unless you 234 // take ownership by calling GetResponseAsFilePath(). 235 virtual void SaveResponseToTemporaryFile( 236 scoped_refptr<base::TaskRunner> file_task_runner) = 0; 237 238 // Retrieve the response headers from the request. Must only be called after 239 // the OnURLFetchComplete callback has run. 240 virtual HttpResponseHeaders* GetResponseHeaders() const = 0; 241 242 // Retrieve the remote socket address from the request. Must only 243 // be called after the OnURLFetchComplete callback has run and if 244 // the request has not failed. 245 virtual HostPortPair GetSocketAddress() const = 0; 246 247 // Returns true if the request was delivered through a proxy. Must only 248 // be called after the OnURLFetchComplete callback has run and the request 249 // has not failed. 250 virtual bool WasFetchedViaProxy() const = 0; 251 252 // Start the request. After this is called, you may not change any other 253 // settings. 254 virtual void Start() = 0; 255 256 // Return the URL that we were asked to fetch. 257 virtual const GURL& GetOriginalURL() const = 0; 258 259 // Return the URL that this fetcher is processing. 260 virtual const GURL& GetURL() const = 0; 261 262 // The status of the URL fetch. 263 virtual const URLRequestStatus& GetStatus() const = 0; 264 265 // The http response code received. Will return RESPONSE_CODE_INVALID 266 // if an error prevented any response from being received. 267 virtual int GetResponseCode() const = 0; 268 269 // Cookies recieved. 270 virtual const ResponseCookies& GetCookies() const = 0; 271 272 // Return true if any file system operation failed. If so, set |error_code| 273 // to the net error code. File system errors are only possible if user called 274 // SaveResponseToTemporaryFile(). 275 virtual bool FileErrorOccurred(int* out_error_code) const = 0; 276 277 // Reports that the received content was malformed. 278 virtual void ReceivedContentWasMalformed() = 0; 279 280 // Get the response as a string. Return false if the fetcher was not 281 // set to store the response as a string. 282 virtual bool GetResponseAsString(std::string* out_response_string) const = 0; 283 284 // Get the path to the file containing the response body. Returns false 285 // if the response body was not saved to a file. If take_ownership is 286 // true, caller takes responsibility for the file, and it will not 287 // be removed once the URLFetcher is destroyed. User should not take 288 // ownership more than once, or call this method after taking ownership. 289 virtual bool GetResponseAsFilePath( 290 bool take_ownership, 291 base::FilePath* out_response_path) const = 0; 292}; 293 294} // namespace net 295 296#endif // NET_URL_REQUEST_URL_FETCHER_H_ 297