[sync] Allow FakeURLFetcher to return an arbitrary URLRequestStatus

chrome/browser/profile_resetter/profile_resetter_unittest.cc

 // Copyright (c) 2013 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 "chrome/browser/profile_resetter/profile_resetter.h"
 
 #include "base/json/json_string_value_serializer.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread.h"
 #include "extensions/common/manifest_constants.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
+#include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 
 namespace {
 
 const char kDistributionConfig[] = "{"
     " \"homepage\" : \"http://www.foo.com\","
     " \"homepage_is_newtabpage\" : false,"
     " \"browser\" : {"
     "   \"show_home_button\" : true"
@@ skipping 124 matching lines @@
 
   scoped_ptr<BrandcodeConfigFetcher> WaitForRequest(const GURL& url);
 
   net::FakeURLFetcherFactory& factory() { return factory_; }
 
  private:
   scoped_ptr<net::FakeURLFetcher> CreateFakeURLFetcher(
       const GURL& url,
       net::URLFetcherDelegate* fetcher_delegate,
       const std::string& response_data,
-      net::HttpStatusCode response_code);
+      net::HttpStatusCode response_code,
+      net::URLRequestStatus::Status status);
 
   MOCK_METHOD0(Callback, void(void));
 
   base::MessageLoop loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
   URLFetcherRequestListener request_listener_;
   net::FakeURLFetcherFactory factory_;
 };
 
@@ skipping 19 matching lines @@
   EXPECT_FALSE(fetcher->IsActive());
   // Look for the brand code in the request.
   EXPECT_NE(std::string::npos, request_listener_.upload_data.find("ABCD"));
   return fetcher.Pass();
 }
 
 scoped_ptr<net::FakeURLFetcher> ConfigParserTest::CreateFakeURLFetcher(
     const GURL& url,
     net::URLFetcherDelegate* fetcher_delegate,
     const std::string& response_data,
-    net::HttpStatusCode response_code) {
+    net::HttpStatusCode response_code,
+    net::URLRequestStatus::Status status) {
   request_listener_.real_delegate = fetcher_delegate;
   scoped_ptr<net::FakeURLFetcher> fetcher(
-      new net::FakeURLFetcher(url,
-                              &request_listener_,
-                              response_data,
-                              response_code));
+      new net::FakeURLFetcher(
+          url, &request_listener_, response_data, response_code, status));
   scoped_refptr<net::HttpResponseHeaders> download_headers =
       new net::HttpResponseHeaders("");
   download_headers->AddHeader("Content-Type: text/xml");
   fetcher->set_response_headers(download_headers);
   return fetcher.Pass();
 }
 
 
 // helper functions -----------------------------------------------------------
 
@@ skipping 412 matching lines @@
 TEST_F(ProfileResetterTest, ResetFewFlags) {
   // mock_object_ is a StrictMock, so we verify that it is called only once.
   ResetAndWait(ProfileResetter::DEFAULT_SEARCH_ENGINE |
                ProfileResetter::HOMEPAGE |
                ProfileResetter::CONTENT_SETTINGS);
 }
 
 // Tries to load unavailable config file.
 TEST_F(ConfigParserTest, NoConnectivity) {
   const GURL url("http://test");
-  factory().SetFakeResponse(url, "", net::HTTP_INTERNAL_SERVER_ERROR);
+  factory().SetFakeResponse(url, "", net::HTTP_INTERNAL_SERVER_ERROR,
+                            net::URLRequestStatus::FAILED);
 
   scoped_ptr<BrandcodeConfigFetcher> fetcher = WaitForRequest(GURL(url));
   EXPECT_FALSE(fetcher->GetSettings());
 }
 
 // Tries to load available config file.
 TEST_F(ConfigParserTest, ParseConfig) {
   const GURL url("http://test");
   std::string xml_config(kXmlConfig);
   ReplaceString(&xml_config, "placeholder_for_data", kDistributionConfig);
   ReplaceString(&xml_config,
                 "placeholder_for_id",
                 "abbaabbaabbaabbaabbaabbaabbaabba");
-  factory().SetFakeResponse(url, xml_config, net::HTTP_OK);
+  factory().SetFakeResponse(url, xml_config, net::HTTP_OK,
+                            net::URLRequestStatus::SUCCESS);
 
   scoped_ptr<BrandcodeConfigFetcher> fetcher = WaitForRequest(GURL(url));
   scoped_ptr<BrandcodedDefaultSettings> settings = fetcher->GetSettings();
   ASSERT_TRUE(settings);
 
   std::vector<std::string> extension_ids;
   EXPECT_TRUE(settings->GetExtensions(&extension_ids));
   EXPECT_EQ(1u, extension_ids.size());
   EXPECT_EQ("abbaabbaabbaabbaabbaabbaabbaabba", extension_ids[0]);
 
@@ skipping 162 matching lines @@
     ASSERT_TRUE(dict->GetString("key", &value));
     if (value == "Extensions") {
       string16 extensions;
       EXPECT_TRUE(dict->GetString("value", &extensions));
       EXPECT_EQ(WideToUTF16(L"Tiësto"), extensions);
     }
   }
 }
 
 }  // namespace