src/net/url_request/test_url_fetcher_factory.cc

   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
  20 namespace net {
  21
  22 ScopedURLFetcherFactory::ScopedURLFetcherFactory(
  23     URLFetcherFactory* factory) {
  24   DCHECK(!URLFetcherImpl::factory());
  25   URLFetcherImpl::set_factory(factory);
  26 }
  27
  28 ScopedURLFetcherFactory::~ScopedURLFetcherFactory() {
  29   DCHECK(URLFetcherImpl::factory());
  30   URLFetcherImpl::set_factory(NULL);
  31 }
  32
  33 TestURLFetcher::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
  49 TestURLFetcher::~TestURLFetcher() {
  50   if (delegate_for_tests_)
  51     delegate_for_tests_->OnRequestEnd(id_);
  52   if (owner_)
  53     owner_->RemoveFetcherFromMap(id_);
  54 }
  55
  56 void TestURLFetcher::SetUploadData(const std::string& upload_content_type,
  57                                    const std::string& upload_content) {
  58   upload_data_ = upload_content;
  59 }
  60
  61 void 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
  70 void TestURLFetcher::SetChunkedUpload(const std::string& upload_content_type) {
  71 }
  72
  73 void 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
  82 void TestURLFetcher::SetLoadFlags(int load_flags) {
  83   fake_load_flags_= load_flags;
  84 }
  85
  86 int TestURLFetcher::GetLoadFlags() const {
  87   return fake_load_flags_;
  88 }
  89
  90 void TestURLFetcher::SetReferrer(const std::string& referrer) {
  91 }
  92
  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);
  97 }
  98
  99 void TestURLFetcher::AddExtraRequestHeader(const std::string& header_line) {
 100   fake_extra_request_headers_.AddHeaderFromString(header_line);
 101 }
 102
 103 void TestURLFetcher::GetExtraRequestHeaders(
 104     HttpRequestHeaders* headers) const {
 105   *headers = fake_extra_request_headers_;
 106 }
 107
 108 void TestURLFetcher::SetRequestContext(
 109     URLRequestContextGetter* request_context_getter) {
 110 }
 111
 112 void TestURLFetcher::SetFirstPartyForCookies(
 113     const GURL& first_party_for_cookies) {
 114 }
 115
 116 void TestURLFetcher::SetURLRequestUserData(
 117     const void* key,
 118     const CreateDataCallback& create_data_callback) {
 119 }
 120
 121 void TestURLFetcher::SetStopOnRedirect(bool stop_on_redirect) {
 122 }
 123
 124 void TestURLFetcher::SetAutomaticallyRetryOn5xx(bool retry) {
 125 }
 126
 127 void TestURLFetcher::SetMaxRetriesOn5xx(int max_retries) {
 128   fake_max_retries_ = max_retries;
 129 }
 130
 131 int TestURLFetcher::GetMaxRetriesOn5xx() const {
 132   return fake_max_retries_;
 133 }
 134
 135 base::TimeDelta TestURLFetcher::GetBackoffDelay() const {
 136   return fake_backoff_delay_;
 137 }
 138
 139 void TestURLFetcher::SetAutomaticallyRetryOnNetworkChanges(int max_retries) {
 140 }
 141
 142 void TestURLFetcher::SaveResponseToFileAtPath(
 143     const base::FilePath& file_path,
 144     scoped_refptr<base::TaskRunner> file_task_runner) {
 145 }
 146
 147 void TestURLFetcher::SaveResponseToTemporaryFile(
 148     scoped_refptr<base::TaskRunner> file_task_runner) {
 149 }
 150
 151 void TestURLFetcher::SaveResponseWithWriter(
 152     scoped_ptr<URLFetcherResponseWriter> response_writer) {
 153 }
 154
 155 HttpResponseHeaders* TestURLFetcher::GetResponseHeaders() const {
 156   return fake_response_headers_.get();
 157 }
 158
 159 HostPortPair TestURLFetcher::GetSocketAddress() const {
 160   NOTIMPLEMENTED();
 161   return HostPortPair();
 162 }
 163
 164 bool TestURLFetcher::WasFetchedViaProxy() const {
 165   return fake_was_fetched_via_proxy_;
 166 }
 167
 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_);
 172 }
 173
 174 const GURL& TestURLFetcher::GetOriginalURL() const {
 175   return original_url_;
 176 }
 177
 178 const GURL& TestURLFetcher::GetURL() const {
 179   return fake_url_;
 180 }
 181
 182 const URLRequestStatus& TestURLFetcher::GetStatus() const {
 183   return fake_status_;
 184 }
 185
 186 int TestURLFetcher::GetResponseCode() const {
 187   return fake_response_code_;
 188 }
 189
 190 const ResponseCookies& TestURLFetcher::GetCookies() const {
 191   return fake_cookies_;
 192 }
 193
 194 void TestURLFetcher::ReceivedContentWasMalformed() {
 195 }
 196
 197 bool 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
 206 bool 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
 215 void TestURLFetcher::set_status(const URLRequestStatus& status) {
 216   fake_status_ = status;
 217 }
 218
 219 void TestURLFetcher::set_was_fetched_via_proxy(bool flag) {
 220   fake_was_fetched_via_proxy_ = flag;
 221 }
 222
 223 void TestURLFetcher::set_response_headers(
 224     scoped_refptr<HttpResponseHeaders> headers) {
 225   fake_response_headers_ = headers;
 226 }
 227
 228 void TestURLFetcher::set_backoff_delay(base::TimeDelta backoff_delay) {
 229   fake_backoff_delay_ = backoff_delay;
 230 }
 231
 232 void TestURLFetcher::SetDelegateForTests(DelegateForTests* delegate_for_tests) {
 233   delegate_for_tests_ = delegate_for_tests;
 234 }
 235
 236 void TestURLFetcher::SetResponseString(const std::string& response) {
 237   fake_response_destination_ = STRING;
 238   fake_response_string_ = response;
 239 }
 240
 241 void TestURLFetcher::SetResponseFilePath(const base::FilePath& path) {
 242   fake_response_destination_ = TEMP_FILE;
 243   fake_response_file_path_ = path;
 244 }
 245
 246 TestURLFetcherFactory::TestURLFetcherFactory()
 247     : ScopedURLFetcherFactory(this),
 248       delegate_for_tests_(NULL),
 249       remove_fetcher_on_delete_(false) {
 250 }
 251
 252 TestURLFetcherFactory::~TestURLFetcherFactory() {}
 253
 254 URLFetcher* 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
 267 TestURLFetcher* TestURLFetcherFactory::GetFetcherByID(int id) const {
 268   Fetchers::const_iterator i = fetchers_.find(id);
 269   return i == fetchers_.end() ? NULL : i->second;
 270 }
 271
 272 void TestURLFetcherFactory::RemoveFetcherFromMap(int id) {
 273   Fetchers::iterator i = fetchers_.find(id);
 274   DCHECK(i != fetchers_.end());
 275   fetchers_.erase(i);
 276 }
 277
 278 void TestURLFetcherFactory::SetDelegateForTests(
 279     TestURLFetcherDelegateForTests* delegate_for_tests) {
 280   delegate_for_tests_ = delegate_for_tests;
 281 }
 282
 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,
 293       0));
 294   set_response_code(response_code);
 295   SetResponseString(response_data);
 296 }
 297
 298 FakeURLFetcher::~FakeURLFetcher() {}
 299
 300 void FakeURLFetcher::Start() {
 301   base::MessageLoop::current()->PostTask(
 302       FROM_HERE,
 303       base::Bind(&FakeURLFetcher::RunDelegate, weak_factory_.GetWeakPtr()));
 304 }
 305
 306 void FakeURLFetcher::RunDelegate() {
 307   delegate()->OnURLFetchComplete(this);
 308 }
 309
 310 const GURL& FakeURLFetcher::GetURL() const {
 311   return TestURLFetcher::GetOriginalURL();
 312 }
 313
 314 FakeURLFetcherFactory::FakeURLFetcherFactory(
 315     URLFetcherFactory* default_factory)
 316     : ScopedURLFetcherFactory(this),
 317       creator_(base::Bind(&DefaultFakeURLFetcherCreator)),
 318       default_factory_(default_factory) {
 319 }
 320
 321 FakeURLFetcherFactory::FakeURLFetcherFactory(
 322     URLFetcherFactory* default_factory,
 323     const FakeURLFetcherCreator& creator)
 324     : ScopedURLFetcherFactory(this),
 325       creator_(creator),
 326       default_factory_(default_factory) {
 327 }
 328
 329 scoped_ptr<FakeURLFetcher> FakeURLFetcherFactory::DefaultFakeURLFetcherCreator(
 330       const GURL& url,
 331       URLFetcherDelegate* delegate,
 332       const std::string& response_data,
 333       HttpStatusCode response_code) {
 334   return scoped_ptr<FakeURLFetcher>(new FakeURLFetcher(url,
 335                                                        delegate,
 336                                                        response_data,
 337                                                        response_code));
 338 }
 339
 340 FakeURLFetcherFactory::~FakeURLFetcherFactory() {}
 341
 342 URLFetcher* FakeURLFetcherFactory::CreateURLFetcher(
 343     int id,
 344     const GURL& url,
 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();
 352       return NULL;
 353     } else {
 354       return default_factory_->CreateURLFetcher(id, url, request_type, d);
 355     }
 356   }
 357
 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();
 362 }
 363
 364 void FakeURLFetcherFactory::SetFakeResponse(
 365     const GURL& url,
 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);
 370 }
 371
 372 void FakeURLFetcherFactory::ClearFakeResponses() {
 373   fake_responses_.clear();
 374 }
 375
 376 URLFetcherImplFactory::URLFetcherImplFactory() {}
 377
 378 URLFetcherImplFactory::~URLFetcherImplFactory() {}
 379
 380 URLFetcher* URLFetcherImplFactory::CreateURLFetcher(
 381     int id,
 382     const GURL& url,
 383     URLFetcher::RequestType request_type,
 384     URLFetcherDelegate* d) {
 385   return new URLFetcherImpl(url, request_type, d);
 386 }
 387
 388 }  // namespace net