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_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::SetUploadFilePath( 61 const std::string& upload_content_type, 62 const base::FilePath& file_path, 63 uint64 range_offset, 64 uint64 range_length, 65 scoped_refptr<base::TaskRunner> file_task_runner) { 66 upload_file_path_ = file_path; 67 } 68 69 void TestURLFetcher::SetChunkedUpload(const std::string& upload_content_type) { 70 } 71 72 void TestURLFetcher::AppendChunkToUpload(const std::string& data, 73 bool is_last_chunk) { 74 DCHECK(!did_receive_last_chunk_); 75 did_receive_last_chunk_ = is_last_chunk; 76 chunks_.push_back(data); 77 if (delegate_for_tests_) 78 delegate_for_tests_->OnChunkUpload(id_); 79 } 80 81 void TestURLFetcher::SetLoadFlags(int load_flags) { 82 fake_load_flags_= load_flags; 83 } 84 85 int TestURLFetcher::GetLoadFlags() const { 86 return fake_load_flags_; 87 } 88 89 void TestURLFetcher::SetReferrer(const std::string& referrer) { 90 } 91 92 void TestURLFetcher::SetExtraRequestHeaders( 93 const std::string& extra_request_headers) { 94 fake_extra_request_headers_.Clear(); 95 fake_extra_request_headers_.AddHeadersFromString(extra_request_headers); 96 } 97 98 void TestURLFetcher::AddExtraRequestHeader(const std::string& header_line) { 99 fake_extra_request_headers_.AddHeaderFromString(header_line); 100 } 101 102 void TestURLFetcher::GetExtraRequestHeaders( 103 HttpRequestHeaders* headers) const { 104 *headers = fake_extra_request_headers_; 105 } 106 107 void TestURLFetcher::SetRequestContext( 108 URLRequestContextGetter* request_context_getter) { 109 } 110 111 void TestURLFetcher::SetFirstPartyForCookies( 112 const GURL& first_party_for_cookies) { 113 } 114 115 void TestURLFetcher::SetURLRequestUserData( 116 const void* key, 117 const CreateDataCallback& create_data_callback) { 118 } 119 120 void TestURLFetcher::SetStopOnRedirect(bool stop_on_redirect) { 121 } 122 123 void TestURLFetcher::SetAutomaticallyRetryOn5xx(bool retry) { 124 } 125 126 void TestURLFetcher::SetMaxRetriesOn5xx(int max_retries) { 127 fake_max_retries_ = max_retries; 128 } 129 130 int TestURLFetcher::GetMaxRetriesOn5xx() const { 131 return fake_max_retries_; 132 } 133 134 base::TimeDelta TestURLFetcher::GetBackoffDelay() const { 135 return fake_backoff_delay_; 136 } 137 138 void TestURLFetcher::SetAutomaticallyRetryOnNetworkChanges(int max_retries) { 139 } 140 141 void TestURLFetcher::SaveResponseToFileAtPath( 142 const base::FilePath& file_path, 143 scoped_refptr<base::TaskRunner> file_task_runner) { 144 } 145 146 void TestURLFetcher::SaveResponseToTemporaryFile( 147 scoped_refptr<base::TaskRunner> file_task_runner) { 148 } 149 150 HttpResponseHeaders* TestURLFetcher::GetResponseHeaders() const { 151 return fake_response_headers_.get(); 152 } 153 154 HostPortPair TestURLFetcher::GetSocketAddress() const { 155 NOTIMPLEMENTED(); 156 return HostPortPair(); 157 } 158 159 bool TestURLFetcher::WasFetchedViaProxy() const { 160 return fake_was_fetched_via_proxy_; 161 } 162 163 void TestURLFetcher::Start() { 164 // Overriden to do nothing. It is assumed the caller will notify the delegate. 165 if (delegate_for_tests_) 166 delegate_for_tests_->OnRequestStart(id_); 167 } 168 169 const GURL& TestURLFetcher::GetOriginalURL() const { 170 return original_url_; 171 } 172 173 const GURL& TestURLFetcher::GetURL() const { 174 return fake_url_; 175 } 176 177 const URLRequestStatus& TestURLFetcher::GetStatus() const { 178 return fake_status_; 179 } 180 181 int TestURLFetcher::GetResponseCode() const { 182 return fake_response_code_; 183 } 184 185 const ResponseCookies& TestURLFetcher::GetCookies() const { 186 return fake_cookies_; 187 } 188 189 bool TestURLFetcher::FileErrorOccurred(int* out_error_code) const { 190 NOTIMPLEMENTED(); 191 return false; 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 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 296 FakeURLFetcher::~FakeURLFetcher() {} 297 298 void FakeURLFetcher::Start() { 299 base::MessageLoop::current()->PostTask( 300 FROM_HERE, 301 base::Bind(&FakeURLFetcher::RunDelegate, weak_factory_.GetWeakPtr())); 302 } 303 304 void FakeURLFetcher::RunDelegate() { 305 delegate()->OnURLFetchComplete(this); 306 } 307 308 const GURL& FakeURLFetcher::GetURL() const { 309 return TestURLFetcher::GetOriginalURL(); 310 } 311 312 FakeURLFetcherFactory::FakeURLFetcherFactory( 313 URLFetcherFactory* default_factory) 314 : ScopedURLFetcherFactory(this), 315 creator_(base::Bind(&DefaultFakeURLFetcherCreator)), 316 default_factory_(default_factory) { 317 } 318 319 FakeURLFetcherFactory::FakeURLFetcherFactory( 320 URLFetcherFactory* default_factory, 321 const FakeURLFetcherCreator& creator) 322 : ScopedURLFetcherFactory(this), 323 creator_(creator), 324 default_factory_(default_factory) { 325 } 326 327 scoped_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 336 FakeURLFetcherFactory::~FakeURLFetcherFactory() {} 337 338 URLFetcher* 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 360 void FakeURLFetcherFactory::SetFakeResponse(const std::string& url, 361 const std::string& response_data, 362 bool success) { 363 // Overwrite existing URL if it already exists. 364 fake_responses_[GURL(url)] = std::make_pair(response_data, success); 365 } 366 367 void FakeURLFetcherFactory::ClearFakeResponses() { 368 fake_responses_.clear(); 369 } 370 371 URLFetcherImplFactory::URLFetcherImplFactory() {} 372 373 URLFetcherImplFactory::~URLFetcherImplFactory() {} 374 375 URLFetcher* URLFetcherImplFactory::CreateURLFetcher( 376 int id, 377 const GURL& url, 378 URLFetcher::RequestType request_type, 379 URLFetcherDelegate* d) { 380 return new URLFetcherImpl(url, request_type, d); 381 } 382 383 } // namespace net 384
