[sync] Allow FakeURLFetcher to return arbitrary HTTP response codes

components/precache/core/precache_fetcher_unittest.cc

 // Copyright 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 "components/precache/core/precache_fetcher.h"
 
 #include <list>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "components/precache/core/precache_switches.h"
 #include "components/precache/core/proto/precache.pb.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_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace precache {
 
 namespace {
 
 class TestURLFetcherCallback {
  public:
   scoped_ptr<net::FakeURLFetcher> CreateURLFetcher(
       const GURL& url, net::URLFetcherDelegate* delegate,
-      const std::string& response_data, bool success) {
+      const std::string& response_data, net::HttpStatusCode response_code) {
     scoped_ptr<net::FakeURLFetcher> fetcher(
-        new net::FakeURLFetcher(url, delegate, response_data, success));
+        new net::FakeURLFetcher(url, delegate, response_data, response_code));
 
-    if (success) {
+    if (response_code == net::HTTP_OK) {
       scoped_refptr<net::HttpResponseHeaders> download_headers =
           new net::HttpResponseHeaders("");
       download_headers->AddHeader("Content-Type: text/html");
       fetcher->set_response_headers(download_headers);
     }
 
     requested_urls_.insert(url);
     return fetcher.Pass();
   }
 
@@ skipping 69 matching lines @@
   config.add_whitelisted_starting_url("http://bad-manifest.com");
   config.add_whitelisted_starting_url("http://good-manifest.com");
   config.add_whitelisted_starting_url("http://not-in-top-4.com");
   config.set_maximum_rank_starting_url(4);
 
   PrecacheManifest good_manifest;
   good_manifest.add_resource()->set_url(kResourceFetchFailureURL);
   good_manifest.add_resource();  // Resource with no URL, should not be fetched.
   good_manifest.add_resource()->set_url(kGoodResourceURL);
 
-  factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(), true);
-  factory_.SetFakeResponse(GURL(kManifestFetchFailureURL), "", false);
-  factory_.SetFakeResponse(GURL(kBadManifestURL), "bad protobuf", true);
+  factory_.SetFakeResponse(GURL(kConfigURL),
+                           config.SerializeAsString(),
+                           net::HTTP_OK);
+  factory_.SetFakeResponse(GURL(kManifestFetchFailureURL),
+                           "",
+                           net::HTTP_INTERNAL_SERVER_ERROR);
+  factory_.SetFakeResponse(GURL(kBadManifestURL), "bad protobuf", net::HTTP_OK);
   factory_.SetFakeResponse(GURL(kGoodManifestURL),
-                           good_manifest.SerializeAsString(), true);
-  factory_.SetFakeResponse(GURL(kResourceFetchFailureURL), "", false);
-  factory_.SetFakeResponse(GURL(kGoodResourceURL), "good", true);
+                           good_manifest.SerializeAsString(), net::HTTP_OK);
+  factory_.SetFakeResponse(GURL(kResourceFetchFailureURL),
+                           "",
+                           net::HTTP_INTERNAL_SERVER_ERROR);
+  factory_.SetFakeResponse(GURL(kGoodResourceURL), "good", net::HTTP_OK);
 
   PrecacheFetcher precache_fetcher(starting_urls, request_context_.get(),
                                    &precache_delegate_);
   precache_fetcher.Start();
 
   base::MessageLoop::current()->RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(GURL(kManifestFetchFailureURL));
   expected_requested_urls.insert(GURL(kBadManifestURL));
   expected_requested_urls.insert(GURL(kGoodManifestURL));
   expected_requested_urls.insert(GURL(kResourceFetchFailureURL));
   expected_requested_urls.insert(GURL(kGoodResourceURL));
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, ConfigFetchFailure) {
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kPrecacheConfigSettingsURL, kConfigURL);
 
   std::list<GURL> starting_urls(1, GURL("http://starting-url.com"));
 
-  factory_.SetFakeResponse(GURL(kConfigURL), "", false);
+  factory_.SetFakeResponse(GURL(kConfigURL),
+                           "",
+                           net::HTTP_INTERNAL_SERVER_ERROR);
 
   PrecacheFetcher precache_fetcher(starting_urls, request_context_.get(),
                                    &precache_delegate_);
   precache_fetcher.Start();
 
   base::MessageLoop::current()->RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, BadConfig) {
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kPrecacheConfigSettingsURL, kConfigURL);
 
   std::list<GURL> starting_urls(1, GURL("http://starting-url.com"));
 
-  factory_.SetFakeResponse(GURL(kConfigURL), "bad protobuf", true);
+  factory_.SetFakeResponse(GURL(kConfigURL), "bad protobuf", net::HTTP_OK);
 
   PrecacheFetcher precache_fetcher(starting_urls, request_context_.get(),
                                    &precache_delegate_);
   precache_fetcher.Start();
 
   base::MessageLoop::current()->RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, Cancel) {
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kPrecacheConfigSettingsURL, kConfigURL);
 
   std::list<GURL> starting_urls(1, GURL("http://starting-url.com"));
 
   PrecacheConfigurationSettings config;
   config.add_whitelisted_starting_url("http://starting-url.com");
   config.set_maximum_rank_starting_url(1);
 
-  factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(), true);
+  factory_.SetFakeResponse(GURL(kConfigURL),
+                           config.SerializeAsString(),
+                           net::HTTP_OK);
 
   scoped_ptr<PrecacheFetcher> precache_fetcher(new PrecacheFetcher(
       starting_urls, request_context_.get(), &precache_delegate_));
   precache_fetcher->Start();
 
   // Destroy the PrecacheFetcher to cancel precaching. This should not cause
   // OnDone to be called on the precache delegate.
   precache_fetcher.reset();
 
   base::MessageLoop::current()->RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_FALSE(precache_delegate_.was_on_done_called());
 }
 
 #if defined(PRECACHE_CONFIG_SETTINGS_URL)
 
 // If the default precache configuration settings URL is defined, then test that
 // it works with the PrecacheFetcher.
 TEST_F(PrecacheFetcherTest, PrecacheUsingDefaultConfigSettingsURL) {
   std::list<GURL> starting_urls(1, GURL("http://starting-url.com"));
 
   factory_.SetFakeResponse(GURL(PRECACHE_CONFIG_SETTINGS_URL),
                            PrecacheConfigurationSettings().SerializeAsString(),
-                           true);
+                           net::HTTP_OK);
 
   PrecacheFetcher precache_fetcher(starting_urls, request_context_.get(),
                                    &precache_delegate_);
   precache_fetcher.Start();
 
   base::MessageLoop::current()->RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(PRECACHE_CONFIG_SETTINGS_URL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
@@ skipping 13 matching lines @@
 
   std::list<GURL> starting_urls(1, GURL("http://starting-url.com"));
 
   PrecacheConfigurationSettings config;
   config.add_whitelisted_starting_url("http://starting-url.com");
   config.set_maximum_rank_starting_url(1);
 
   GURL manifest_url(PRECACHE_MANIFEST_URL_PREFIX
                     "http%253A%252F%252Fstarting-url.com%252F");
 
-  factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(), true);
-  factory_.SetFakeResponse(manifest_url, PrecacheManifest().SerializeAsString(),
-                           true);
+  factory_.SetFakeResponse(GURL(kConfigURL),
+                           config.SerializeAsString(),
+                           net::HTTP_OK);
+  factory_.SetFakeResponse(manifest_url,
+                           PrecacheManifest().SerializeAsString(),
+                           net::HTTP_OK);
 
   PrecacheFetcher precache_fetcher(starting_urls, request_context_.get(),
                                    &precache_delegate_);
   precache_fetcher.Start();
 
   base::MessageLoop::current()->RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(manifest_url);
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 #endif  // PRECACHE_MANIFEST_URL_PREFIX
 
 }  // namespace
 
 }  // namespace precache