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.
5 #include "net/url_request/test_url_fetcher_factory.h"
10 #include "base/compiler_specific.h"
11 #include "base/memory/weak_ptr.h"
12 #include "base/message_loop/message_loop.h"
13 #include "net/base/host_port_pair.h"
14 #include "net/http/http_response_headers.h"
15 #include "net/url_request/url_fetcher_delegate.h"
16 #include "net/url_request/url_fetcher_impl.h"
17 #include "net/url_request/url_fetcher_response_writer.h"
18 #include "net/url_request/url_request_status.h"
22 ScopedURLFetcherFactory::ScopedURLFetcherFactory(
23 URLFetcherFactory* factory) {
24 DCHECK(!URLFetcherImpl::factory());
25 URLFetcherImpl::set_factory(factory);
28 ScopedURLFetcherFactory::~ScopedURLFetcherFactory() {
29 DCHECK(URLFetcherImpl::factory());
30 URLFetcherImpl::set_factory(NULL);
33 TestURLFetcher::TestURLFetcher(int id,
35 URLFetcherDelegate* d)
40 delegate_for_tests_(NULL),
41 did_receive_last_chunk_(false),
43 fake_response_code_(-1),
44 fake_response_destination_(STRING),
45 fake_was_fetched_via_proxy_(false),
46 fake_max_retries_(0) {
49 TestURLFetcher::~TestURLFetcher() {
50 if (delegate_for_tests_)
51 delegate_for_tests_->OnRequestEnd(id_);
53 owner_->RemoveFetcherFromMap(id_);
56 void TestURLFetcher::SetUploadData(const std::string& upload_content_type,
57 const std::string& upload_content) {
58 upload_data_ = upload_content;
61 void TestURLFetcher::SetUploadFilePath(
62 const std::string& upload_content_type,
63 const base::FilePath& file_path,
66 scoped_refptr<base::TaskRunner> file_task_runner) {
67 upload_file_path_ = file_path;
70 void TestURLFetcher::SetChunkedUpload(const std::string& upload_content_type) {
73 void TestURLFetcher::AppendChunkToUpload(const std::string& data,
75 DCHECK(!did_receive_last_chunk_);
76 did_receive_last_chunk_ = is_last_chunk;
77 chunks_.push_back(data);
78 if (delegate_for_tests_)
79 delegate_for_tests_->OnChunkUpload(id_);
82 void TestURLFetcher::SetLoadFlags(int load_flags) {
83 fake_load_flags_= load_flags;
86 int TestURLFetcher::GetLoadFlags() const {
87 return fake_load_flags_;
90 void TestURLFetcher::SetReferrer(const std::string& referrer) {
93 void TestURLFetcher::SetExtraRequestHeaders(
94 const std::string& extra_request_headers) {
95 fake_extra_request_headers_.Clear();
96 fake_extra_request_headers_.AddHeadersFromString(extra_request_headers);
99 void TestURLFetcher::AddExtraRequestHeader(const std::string& header_line) {
100 fake_extra_request_headers_.AddHeaderFromString(header_line);
103 void TestURLFetcher::GetExtraRequestHeaders(
104 HttpRequestHeaders* headers) const {
105 *headers = fake_extra_request_headers_;
108 void TestURLFetcher::SetRequestContext(
109 URLRequestContextGetter* request_context_getter) {
112 void TestURLFetcher::SetFirstPartyForCookies(
113 const GURL& first_party_for_cookies) {
116 void TestURLFetcher::SetURLRequestUserData(
118 const CreateDataCallback& create_data_callback) {
121 void TestURLFetcher::SetStopOnRedirect(bool stop_on_redirect) {
124 void TestURLFetcher::SetAutomaticallyRetryOn5xx(bool retry) {
127 void TestURLFetcher::SetMaxRetriesOn5xx(int max_retries) {
128 fake_max_retries_ = max_retries;
131 int TestURLFetcher::GetMaxRetriesOn5xx() const {
132 return fake_max_retries_;
135 base::TimeDelta TestURLFetcher::GetBackoffDelay() const {
136 return fake_backoff_delay_;
139 void TestURLFetcher::SetAutomaticallyRetryOnNetworkChanges(int max_retries) {
142 void TestURLFetcher::SaveResponseToFileAtPath(
143 const base::FilePath& file_path,
144 scoped_refptr<base::TaskRunner> file_task_runner) {
147 void TestURLFetcher::SaveResponseToTemporaryFile(
148 scoped_refptr<base::TaskRunner> file_task_runner) {
151 void TestURLFetcher::SaveResponseWithWriter(
152 scoped_ptr<URLFetcherResponseWriter> response_writer) {
155 HttpResponseHeaders* TestURLFetcher::GetResponseHeaders() const {
156 return fake_response_headers_.get();
159 HostPortPair TestURLFetcher::GetSocketAddress() const {
161 return HostPortPair();
164 bool TestURLFetcher::WasFetchedViaProxy() const {
165 return fake_was_fetched_via_proxy_;
168 void TestURLFetcher::Start() {
169 // Overriden to do nothing. It is assumed the caller will notify the delegate.
170 if (delegate_for_tests_)
171 delegate_for_tests_->OnRequestStart(id_);
174 const GURL& TestURLFetcher::GetOriginalURL() const {
175 return original_url_;
178 const GURL& TestURLFetcher::GetURL() const {
182 const URLRequestStatus& TestURLFetcher::GetStatus() const {
186 int TestURLFetcher::GetResponseCode() const {
187 return fake_response_code_;
190 const ResponseCookies& TestURLFetcher::GetCookies() const {
191 return fake_cookies_;
194 void TestURLFetcher::ReceivedContentWasMalformed() {
197 bool TestURLFetcher::GetResponseAsString(
198 std::string* out_response_string) const {
199 if (fake_response_destination_ != STRING)
202 *out_response_string = fake_response_string_;
206 bool TestURLFetcher::GetResponseAsFilePath(
207 bool take_ownership, base::FilePath* out_response_path) const {
208 if (fake_response_destination_ != TEMP_FILE)
211 *out_response_path = fake_response_file_path_;
215 void TestURLFetcher::set_status(const URLRequestStatus& status) {
216 fake_status_ = status;
219 void TestURLFetcher::set_was_fetched_via_proxy(bool flag) {
220 fake_was_fetched_via_proxy_ = flag;
223 void TestURLFetcher::set_response_headers(
224 scoped_refptr<HttpResponseHeaders> headers) {
225 fake_response_headers_ = headers;
228 void TestURLFetcher::set_backoff_delay(base::TimeDelta backoff_delay) {
229 fake_backoff_delay_ = backoff_delay;
232 void TestURLFetcher::SetDelegateForTests(DelegateForTests* delegate_for_tests) {
233 delegate_for_tests_ = delegate_for_tests;
236 void TestURLFetcher::SetResponseString(const std::string& response) {
237 fake_response_destination_ = STRING;
238 fake_response_string_ = response;
241 void TestURLFetcher::SetResponseFilePath(const base::FilePath& path) {
242 fake_response_destination_ = TEMP_FILE;
243 fake_response_file_path_ = path;
246 TestURLFetcherFactory::TestURLFetcherFactory()
247 : ScopedURLFetcherFactory(this),
248 delegate_for_tests_(NULL),
249 remove_fetcher_on_delete_(false) {
252 TestURLFetcherFactory::~TestURLFetcherFactory() {}
254 URLFetcher* TestURLFetcherFactory::CreateURLFetcher(
257 URLFetcher::RequestType request_type,
258 URLFetcherDelegate* d) {
259 TestURLFetcher* fetcher = new TestURLFetcher(id, url, d);
260 if (remove_fetcher_on_delete_)
261 fetcher->set_owner(this);
262 fetcher->SetDelegateForTests(delegate_for_tests_);
263 fetchers_[id] = fetcher;
267 TestURLFetcher* TestURLFetcherFactory::GetFetcherByID(int id) const {
268 Fetchers::const_iterator i = fetchers_.find(id);
269 return i == fetchers_.end() ? NULL : i->second;
272 void TestURLFetcherFactory::RemoveFetcherFromMap(int id) {
273 Fetchers::iterator i = fetchers_.find(id);
274 DCHECK(i != fetchers_.end());
278 void TestURLFetcherFactory::SetDelegateForTests(
279 TestURLFetcherDelegateForTests* delegate_for_tests) {
280 delegate_for_tests_ = delegate_for_tests;
283 FakeURLFetcher::FakeURLFetcher(const GURL& url,
284 URLFetcherDelegate* d,
285 const std::string& response_data,
286 HttpStatusCode response_code)
287 : TestURLFetcher(0, url, d),
288 weak_factory_(this) {
289 set_status(URLRequestStatus(
290 // Status is FAILED for HTTP/5xx server errors, and SUCCESS otherwise.
291 response_code >= HTTP_INTERNAL_SERVER_ERROR ? URLRequestStatus::FAILED :
292 URLRequestStatus::SUCCESS,
294 set_response_code(response_code);
295 SetResponseString(response_data);
298 FakeURLFetcher::~FakeURLFetcher() {}
300 void FakeURLFetcher::Start() {
301 base::MessageLoop::current()->PostTask(
303 base::Bind(&FakeURLFetcher::RunDelegate, weak_factory_.GetWeakPtr()));
306 void FakeURLFetcher::RunDelegate() {
307 delegate()->OnURLFetchComplete(this);
310 const GURL& FakeURLFetcher::GetURL() const {
311 return TestURLFetcher::GetOriginalURL();
314 FakeURLFetcherFactory::FakeURLFetcherFactory(
315 URLFetcherFactory* default_factory)
316 : ScopedURLFetcherFactory(this),
317 creator_(base::Bind(&DefaultFakeURLFetcherCreator)),
318 default_factory_(default_factory) {
321 FakeURLFetcherFactory::FakeURLFetcherFactory(
322 URLFetcherFactory* default_factory,
323 const FakeURLFetcherCreator& creator)
324 : ScopedURLFetcherFactory(this),
326 default_factory_(default_factory) {
329 scoped_ptr<FakeURLFetcher> FakeURLFetcherFactory::DefaultFakeURLFetcherCreator(
331 URLFetcherDelegate* delegate,
332 const std::string& response_data,
333 HttpStatusCode response_code) {
334 return scoped_ptr<FakeURLFetcher>(new FakeURLFetcher(url,
340 FakeURLFetcherFactory::~FakeURLFetcherFactory() {}
342 URLFetcher* FakeURLFetcherFactory::CreateURLFetcher(
345 URLFetcher::RequestType request_type,
346 URLFetcherDelegate* d) {
347 FakeResponseMap::const_iterator it = fake_responses_.find(url);
348 if (it == fake_responses_.end()) {
349 if (default_factory_ == NULL) {
350 // If we don't have a baked response for that URL we return NULL.
351 DLOG(ERROR) << "No baked response for URL: " << url.spec();
354 return default_factory_->CreateURLFetcher(id, url, request_type, d);
358 scoped_ptr<FakeURLFetcher> fake_fetcher =
359 creator_.Run(url, d, it->second.first, it->second.second);
360 // TODO: Make URLFetcherFactory::CreateURLFetcher return a scoped_ptr
361 return fake_fetcher.release();
364 void FakeURLFetcherFactory::SetFakeResponse(
366 const std::string& response_data,
367 HttpStatusCode response_code) {
368 // Overwrite existing URL if it already exists.
369 fake_responses_[url] = std::make_pair(response_data, response_code);
372 void FakeURLFetcherFactory::ClearFakeResponses() {
373 fake_responses_.clear();
376 URLFetcherImplFactory::URLFetcherImplFactory() {}
378 URLFetcherImplFactory::~URLFetcherImplFactory() {}
380 URLFetcher* URLFetcherImplFactory::CreateURLFetcher(
383 URLFetcher::RequestType request_type,
384 URLFetcherDelegate* d) {
385 return new URLFetcherImpl(url, request_type, d);