[sync] Allow FakeURLFetcher to return an arbitrary URLRequestStatus

net/url_request/test_url_fetcher_factory.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/url_request/test_url_fetcher_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/host_port_pair.h"
+#include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_fetcher_impl.h"
 #include "net/url_request/url_fetcher_response_writer.h"
 #include "net/url_request/url_request_status.h"
 
 namespace net {
 
 ScopedURLFetcherFactory::ScopedURLFetcherFactory(
     URLFetcherFactory* factory) {
@@ skipping 252 matching lines @@
 }
 
 void TestURLFetcherFactory::SetDelegateForTests(
     TestURLFetcherDelegateForTests* delegate_for_tests) {
   delegate_for_tests_ = delegate_for_tests;
 }
 
 FakeURLFetcher::FakeURLFetcher(const GURL& url,
                                URLFetcherDelegate* d,
                                const std::string& response_data,
-                               HttpStatusCode response_code)
+                               HttpStatusCode response_code,
+                               URLRequestStatus::Status status)
     : TestURLFetcher(0, url, d),
       weak_factory_(this) {
-  set_status(URLRequestStatus(
-      // Status is FAILED for HTTP/5xx server errors, and SUCCESS otherwise.
-      response_code >= HTTP_INTERNAL_SERVER_ERROR ? URLRequestStatus::FAILED :
-                                                    URLRequestStatus::SUCCESS,
-      0));
+  net::Error error;
+  switch(status) {
+    case URLRequestStatus::SUCCESS:
+    case URLRequestStatus::IO_PENDING:
+      error = net::OK;

[mmenke, 2013/11/06 17:07:21]

nit:  net:: not needed for any of these, since we're in the net namespace.

[mmenke, 2013/11/06 17:07:21]

Should theoretically use "error = ERR_IO_PENDING" in the IO_PENDING case.

[Raghu Simha, 2013/11/06 17:31:42]

Done.

[Raghu Simha, 2013/11/06 17:31:42]

Done.

+      break;
+    case URLRequestStatus::CANCELED:
+      error = net::ERR_ABORTED;
+      break;
+    case URLRequestStatus::FAILED:
+      error = net::ERR_FAILED;
+      break;
+    default:
+      NOTREACHED();
+      break;

[mmenke, 2013/11/06 17:07:21]

If you remove the default case, there will be a compiler error if a new status
is added, instead, which I think is slightly preferable.

Alternatively, you could make it a function in a private namespace, and use both
a NOTREACHED() and get the compiler error (return in each case, NOTREACHED()
outside the switch).

[Raghu Simha, 2013/11/06 17:31:42]

Default case removed. Done.

+  }
+  set_status(URLRequestStatus(status, error));
   set_response_code(response_code);
   SetResponseString(response_data);
 }
 
 FakeURLFetcher::~FakeURLFetcher() {}
 
 void FakeURLFetcher::Start() {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FakeURLFetcher::RunDelegate, weak_factory_.GetWeakPtr()));
@@ skipping 19 matching lines @@
     const FakeURLFetcherCreator& creator)
     : ScopedURLFetcherFactory(this),
       creator_(creator),
       default_factory_(default_factory) {
 }
 
 scoped_ptr<FakeURLFetcher> FakeURLFetcherFactory::DefaultFakeURLFetcherCreator(
       const GURL& url,
       URLFetcherDelegate* delegate,
       const std::string& response_data,
-      HttpStatusCode response_code) {
-  return scoped_ptr<FakeURLFetcher>(new FakeURLFetcher(url,
-                                                       delegate,
-                                                       response_data,
-                                                       response_code));
+      HttpStatusCode response_code,
+      URLRequestStatus::Status status) {
+  return scoped_ptr<FakeURLFetcher>(
+      new FakeURLFetcher(url, delegate, response_data, response_code, status));
 }
 
 FakeURLFetcherFactory::~FakeURLFetcherFactory() {}
 
 URLFetcher* FakeURLFetcherFactory::CreateURLFetcher(
     int id,
     const GURL& url,
     URLFetcher::RequestType request_type,
     URLFetcherDelegate* d) {
   FakeResponseMap::const_iterator it = fake_responses_.find(url);
   if (it == fake_responses_.end()) {
     if (default_factory_ == NULL) {
       // If we don't have a baked response for that URL we return NULL.
       DLOG(ERROR) << "No baked response for URL: " << url.spec();
       return NULL;
     } else {
       return default_factory_->CreateURLFetcher(id, url, request_type, d);
     }
   }
 
   scoped_ptr<FakeURLFetcher> fake_fetcher =
-      creator_.Run(url, d, it->second.first, it->second.second);
+      creator_.Run(url, d, it->second.response_data,
+                   it->second.response_code, it->second.status);
   // TODO: Make URLFetcherFactory::CreateURLFetcher return a scoped_ptr
   return fake_fetcher.release();
 }
 
 void FakeURLFetcherFactory::SetFakeResponse(
     const GURL& url,
     const std::string& response_data,
-    HttpStatusCode response_code) {
+    HttpStatusCode response_code,
+    URLRequestStatus::Status status) {
   // Overwrite existing URL if it already exists.
-  fake_responses_[url] = std::make_pair(response_data, response_code);
+  FakeURLResponse response;
+  response.response_data = response_data;
+  response.response_code = response_code;
+  response.status = status;
+  fake_responses_[url] = response;
 }
 
 void FakeURLFetcherFactory::ClearFakeResponses() {
   fake_responses_.clear();
 }
 
 URLFetcherImplFactory::URLFetcherImplFactory() {}
 
 URLFetcherImplFactory::~URLFetcherImplFactory() {}
 
 URLFetcher* URLFetcherImplFactory::CreateURLFetcher(
     int id,
     const GURL& url,
     URLFetcher::RequestType request_type,
     URLFetcherDelegate* d) {
   return new URLFetcherImpl(url, request_type, d);
 }
 
 }  // namespace net