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