test_url_fetcher_factory.cc revision 4e180b6a0b4720a9b8e9e959a882386f690f08ff
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#include "net/url_request/test_url_fetcher_factory.h" 6 7#include <string> 8 9#include "base/bind.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" 19 20namespace net { 21 22ScopedURLFetcherFactory::ScopedURLFetcherFactory( 23 URLFetcherFactory* factory) { 24 DCHECK(!URLFetcherImpl::factory()); 25 URLFetcherImpl::set_factory(factory); 26} 27 28ScopedURLFetcherFactory::~ScopedURLFetcherFactory() { 29 DCHECK(URLFetcherImpl::factory()); 30 URLFetcherImpl::set_factory(NULL); 31} 32 33TestURLFetcher::TestURLFetcher(int id, 34 const GURL& url, 35 URLFetcherDelegate* d) 36 : owner_(NULL), 37 id_(id), 38 original_url_(url), 39 delegate_(d), 40 delegate_for_tests_(NULL), 41 did_receive_last_chunk_(false), 42 fake_load_flags_(0), 43 fake_response_code_(-1), 44 fake_response_destination_(STRING), 45 fake_was_fetched_via_proxy_(false), 46 fake_max_retries_(0) { 47} 48 49TestURLFetcher::~TestURLFetcher() { 50 if (delegate_for_tests_) 51 delegate_for_tests_->OnRequestEnd(id_); 52 if (owner_) 53 owner_->RemoveFetcherFromMap(id_); 54} 55 56void TestURLFetcher::SetUploadData(const std::string& upload_content_type, 57 const std::string& upload_content) { 58 upload_data_ = upload_content; 59} 60 61void TestURLFetcher::SetUploadFilePath( 62 const std::string& upload_content_type, 63 const base::FilePath& file_path, 64 uint64 range_offset, 65 uint64 range_length, 66 scoped_refptr<base::TaskRunner> file_task_runner) { 67 upload_file_path_ = file_path; 68} 69 70void TestURLFetcher::SetChunkedUpload(const std::string& upload_content_type) { 71} 72 73void TestURLFetcher::AppendChunkToUpload(const std::string& data, 74 bool is_last_chunk) { 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_); 80} 81 82void TestURLFetcher::SetLoadFlags(int load_flags) { 83 fake_load_flags_= load_flags; 84} 85 86int TestURLFetcher::GetLoadFlags() const { 87 return fake_load_flags_; 88} 89 90void TestURLFetcher::SetReferrer(const std::string& referrer) { 91} 92 93void TestURLFetcher::SetExtraRequestHeaders( 94 const std::string& extra_request_headers) { 95 fake_extra_request_headers_.Clear(); 96 fake_extra_request_headers_.AddHeadersFromString(extra_request_headers); 97} 98 99void TestURLFetcher::AddExtraRequestHeader(const std::string& header_line) { 100 fake_extra_request_headers_.AddHeaderFromString(header_line); 101} 102 103void TestURLFetcher::GetExtraRequestHeaders( 104 HttpRequestHeaders* headers) const { 105 *headers = fake_extra_request_headers_; 106} 107 108void TestURLFetcher::SetRequestContext( 109 URLRequestContextGetter* request_context_getter) { 110} 111 112void TestURLFetcher::SetFirstPartyForCookies( 113 const GURL& first_party_for_cookies) { 114} 115 116void TestURLFetcher::SetURLRequestUserData( 117 const void* key, 118 const CreateDataCallback& create_data_callback) { 119} 120 121void TestURLFetcher::SetStopOnRedirect(bool stop_on_redirect) { 122} 123 124void TestURLFetcher::SetAutomaticallyRetryOn5xx(bool retry) { 125} 126 127void TestURLFetcher::SetMaxRetriesOn5xx(int max_retries) { 128 fake_max_retries_ = max_retries; 129} 130 131int TestURLFetcher::GetMaxRetriesOn5xx() const { 132 return fake_max_retries_; 133} 134 135base::TimeDelta TestURLFetcher::GetBackoffDelay() const { 136 return fake_backoff_delay_; 137} 138 139void TestURLFetcher::SetAutomaticallyRetryOnNetworkChanges(int max_retries) { 140} 141 142void TestURLFetcher::SaveResponseToFileAtPath( 143 const base::FilePath& file_path, 144 scoped_refptr<base::TaskRunner> file_task_runner) { 145} 146 147void TestURLFetcher::SaveResponseToTemporaryFile( 148 scoped_refptr<base::TaskRunner> file_task_runner) { 149} 150 151void TestURLFetcher::SaveResponseWithWriter( 152 scoped_ptr<URLFetcherResponseWriter> response_writer) { 153} 154 155HttpResponseHeaders* TestURLFetcher::GetResponseHeaders() const { 156 return fake_response_headers_.get(); 157} 158 159HostPortPair TestURLFetcher::GetSocketAddress() const { 160 NOTIMPLEMENTED(); 161 return HostPortPair(); 162} 163 164bool TestURLFetcher::WasFetchedViaProxy() const { 165 return fake_was_fetched_via_proxy_; 166} 167 168void 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_); 172} 173 174const GURL& TestURLFetcher::GetOriginalURL() const { 175 return original_url_; 176} 177 178const GURL& TestURLFetcher::GetURL() const { 179 return fake_url_; 180} 181 182const URLRequestStatus& TestURLFetcher::GetStatus() const { 183 return fake_status_; 184} 185 186int TestURLFetcher::GetResponseCode() const { 187 return fake_response_code_; 188} 189 190const ResponseCookies& TestURLFetcher::GetCookies() const { 191 return fake_cookies_; 192} 193 194void TestURLFetcher::ReceivedContentWasMalformed() { 195} 196 197bool TestURLFetcher::GetResponseAsString( 198 std::string* out_response_string) const { 199 if (fake_response_destination_ != STRING) 200 return false; 201 202 *out_response_string = fake_response_string_; 203 return true; 204} 205 206bool TestURLFetcher::GetResponseAsFilePath( 207 bool take_ownership, base::FilePath* out_response_path) const { 208 if (fake_response_destination_ != TEMP_FILE) 209 return false; 210 211 *out_response_path = fake_response_file_path_; 212 return true; 213} 214 215void TestURLFetcher::set_status(const URLRequestStatus& status) { 216 fake_status_ = status; 217} 218 219void TestURLFetcher::set_was_fetched_via_proxy(bool flag) { 220 fake_was_fetched_via_proxy_ = flag; 221} 222 223void TestURLFetcher::set_response_headers( 224 scoped_refptr<HttpResponseHeaders> headers) { 225 fake_response_headers_ = headers; 226} 227 228void TestURLFetcher::set_backoff_delay(base::TimeDelta backoff_delay) { 229 fake_backoff_delay_ = backoff_delay; 230} 231 232void TestURLFetcher::SetDelegateForTests(DelegateForTests* delegate_for_tests) { 233 delegate_for_tests_ = delegate_for_tests; 234} 235 236void TestURLFetcher::SetResponseString(const std::string& response) { 237 fake_response_destination_ = STRING; 238 fake_response_string_ = response; 239} 240 241void TestURLFetcher::SetResponseFilePath(const base::FilePath& path) { 242 fake_response_destination_ = TEMP_FILE; 243 fake_response_file_path_ = path; 244} 245 246TestURLFetcherFactory::TestURLFetcherFactory() 247 : ScopedURLFetcherFactory(this), 248 delegate_for_tests_(NULL), 249 remove_fetcher_on_delete_(false) { 250} 251 252TestURLFetcherFactory::~TestURLFetcherFactory() {} 253 254URLFetcher* TestURLFetcherFactory::CreateURLFetcher( 255 int id, 256 const GURL& url, 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; 264 return fetcher; 265} 266 267TestURLFetcher* TestURLFetcherFactory::GetFetcherByID(int id) const { 268 Fetchers::const_iterator i = fetchers_.find(id); 269 return i == fetchers_.end() ? NULL : i->second; 270} 271 272void TestURLFetcherFactory::RemoveFetcherFromMap(int id) { 273 Fetchers::iterator i = fetchers_.find(id); 274 DCHECK(i != fetchers_.end()); 275 fetchers_.erase(i); 276} 277 278void TestURLFetcherFactory::SetDelegateForTests( 279 TestURLFetcherDelegateForTests* delegate_for_tests) { 280 delegate_for_tests_ = delegate_for_tests; 281} 282 283FakeURLFetcher::FakeURLFetcher(const GURL& url, 284 URLFetcherDelegate* d, 285 const std::string& response_data, 286 bool success) 287 : TestURLFetcher(0, url, d), 288 weak_factory_(this) { 289 set_status(URLRequestStatus( 290 success ? URLRequestStatus::SUCCESS : URLRequestStatus::FAILED, 291 0)); 292 set_response_code(success ? 200 : 500); 293 SetResponseString(response_data); 294} 295 296FakeURLFetcher::~FakeURLFetcher() {} 297 298void FakeURLFetcher::Start() { 299 base::MessageLoop::current()->PostTask( 300 FROM_HERE, 301 base::Bind(&FakeURLFetcher::RunDelegate, weak_factory_.GetWeakPtr())); 302} 303 304void FakeURLFetcher::RunDelegate() { 305 delegate()->OnURLFetchComplete(this); 306} 307 308const GURL& FakeURLFetcher::GetURL() const { 309 return TestURLFetcher::GetOriginalURL(); 310} 311 312FakeURLFetcherFactory::FakeURLFetcherFactory( 313 URLFetcherFactory* default_factory) 314 : ScopedURLFetcherFactory(this), 315 creator_(base::Bind(&DefaultFakeURLFetcherCreator)), 316 default_factory_(default_factory) { 317} 318 319FakeURLFetcherFactory::FakeURLFetcherFactory( 320 URLFetcherFactory* default_factory, 321 const FakeURLFetcherCreator& creator) 322 : ScopedURLFetcherFactory(this), 323 creator_(creator), 324 default_factory_(default_factory) { 325} 326 327scoped_ptr<FakeURLFetcher> FakeURLFetcherFactory::DefaultFakeURLFetcherCreator( 328 const GURL& url, 329 URLFetcherDelegate* delegate, 330 const std::string& response, 331 bool success) { 332 return scoped_ptr<FakeURLFetcher>(new FakeURLFetcher(url, delegate, 333 response, success)); 334} 335 336FakeURLFetcherFactory::~FakeURLFetcherFactory() {} 337 338URLFetcher* FakeURLFetcherFactory::CreateURLFetcher( 339 int id, 340 const GURL& url, 341 URLFetcher::RequestType request_type, 342 URLFetcherDelegate* d) { 343 FakeResponseMap::const_iterator it = fake_responses_.find(url); 344 if (it == fake_responses_.end()) { 345 if (default_factory_ == NULL) { 346 // If we don't have a baked response for that URL we return NULL. 347 DLOG(ERROR) << "No baked response for URL: " << url.spec(); 348 return NULL; 349 } else { 350 return default_factory_->CreateURLFetcher(id, url, request_type, d); 351 } 352 } 353 354 scoped_ptr<FakeURLFetcher> fake_fetcher = 355 creator_.Run(url, d, it->second.first, it->second.second); 356 // TODO: Make URLFetcherFactory::CreateURLFetcher return a scoped_ptr 357 return fake_fetcher.release(); 358} 359 360void FakeURLFetcherFactory::SetFakeResponse( 361 const GURL& url, 362 const std::string& response_data, 363 bool success) { 364 // Overwrite existing URL if it already exists. 365 fake_responses_[url] = std::make_pair(response_data, success); 366} 367 368void FakeURLFetcherFactory::ClearFakeResponses() { 369 fake_responses_.clear(); 370} 371 372URLFetcherImplFactory::URLFetcherImplFactory() {} 373 374URLFetcherImplFactory::~URLFetcherImplFactory() {} 375 376URLFetcher* URLFetcherImplFactory::CreateURLFetcher( 377 int id, 378 const GURL& url, 379 URLFetcher::RequestType request_type, 380 URLFetcherDelegate* d) { 381 return new URLFetcherImpl(url, request_type, d); 382} 383 384} // namespace net 385