[sync] Allow FakeURLFetcher to return arbitrary HTTP response codes

chrome/browser/ui/webui/local_discovery/local_discovery_ui_browsertest.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/local_discovery/test_service_discovery_client.h"
 #include "chrome/browser/signin/profile_oauth2_token_service.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_base.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/webui/local_discovery/local_discovery_ui_handler.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.cc"
 #include "chrome/test/base/web_ui_browsertest.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"
 
 using testing::InvokeWithoutArgs;
 using testing::Return;
 using testing::AtLeast;
 using testing::DoDefault;
 using testing::DoAll;
 using testing::InSequence;
 using testing::StrictMock;
@@ skipping 252 matching lines @@
   }
 
   ~MockableFakeURLFetcherCreator() {
   }
 
   MOCK_METHOD1(OnCreateFakeURLFetcher, void(const std::string& url));
 
   scoped_ptr<net::FakeURLFetcher> CreateFakeURLFetcher(
       const GURL& url,
       net::URLFetcherDelegate* delegate,
-      const std::string& response,
-      bool success) {
+      const std::string& response_data,
+      net::HttpStatusCode response_code) {
     OnCreateFakeURLFetcher(url.spec());
     return scoped_ptr<net::FakeURLFetcher>(
-        new net::FakeURLFetcher(url, delegate, response, success));
+        new net::FakeURLFetcher(url, delegate, response_data, response_code));
   }
 
   net::FakeURLFetcherFactory::FakeURLFetcherCreator callback() {
     return base::Bind(&MockableFakeURLFetcherCreator::CreateFakeURLFetcher,
                       base::Unretained(this));
   }
 };
 
 class LocalDiscoveryUITest : public WebUIBrowserTest {
  public:
@@ skipping 19 matching lines @@
 
     SigninManagerBase* signin_manager =
         SigninManagerFactory::GetForProfile(browser()->profile());
 
     DCHECK(signin_manager);
     signin_manager->SetAuthenticatedUsername(kSampleUser);
 
     fake_fetcher_factory().SetFakeResponse(
         GURL(kURLInfo),
         kResponseInfo,
-        true);
+        net::HTTP_OK);
 
     fake_fetcher_factory().SetFakeResponse(
         GURL(kURLRegisterStart),
         kResponseRegisterStart,
-        true);
+        net::HTTP_OK);
 
     fake_fetcher_factory().SetFakeResponse(
         GURL(kURLRegisterClaimToken),
         kResponseRegisterClaimTokenNoConfirm,
-        true);
+        net::HTTP_OK);
 
     fake_fetcher_factory().SetFakeResponse(
         GURL(kURLCloudPrintConfirm),
         kResponseCloudPrintConfirm,
-        true);
+        net::HTTP_OK);
 
     fake_fetcher_factory().SetFakeResponse(
         GURL(kURLRegisterComplete),
         kResponseRegisterComplete,
-        true);
+        net::HTTP_OK);
 
     fake_fetcher_factory().SetFakeResponse(
         GURL(kURLGaiaToken),
         kResponseGaiaToken,
-        true);
+        net::HTTP_OK);
 
     EXPECT_CALL(fake_url_fetcher_creator(), OnCreateFakeURLFetcher(
         kURLGaiaToken))
         .Times(AnyNumber());
 
     ProfileOAuth2TokenService* token_service =
         ProfileOAuth2TokenServiceFactory::GetForProfile(browser()->profile());
 
     token_service->UpdateCredentials("user@host.com", "MyFakeToken");
 
@@ skipping 99 matching lines @@
 
   EXPECT_TRUE(WebUIBrowserTest::RunJavascriptTest("registerBegin"));
 
   condition_token_claimed.Wait();
 
   EXPECT_TRUE(WebUIBrowserTest::RunJavascriptTest("expectPageAdding1"));
 
   fake_fetcher_factory().SetFakeResponse(
       GURL(kURLRegisterClaimToken),
       kResponseRegisterClaimTokenConfirm,
-      true);
+      net::HTTP_OK);
 
   fake_fetcher_factory().SetFakeResponse(
       GURL(kURLInfo),
       kResponseInfoWithID,
-      true);
+      net::HTTP_OK);
 
   {
     InSequence s;
     EXPECT_CALL(fake_url_fetcher_creator(), OnCreateFakeURLFetcher(
         kURLRegisterClaimToken));
     EXPECT_CALL(fake_url_fetcher_creator(), OnCreateFakeURLFetcher(
         kURLCloudPrintConfirm));
     EXPECT_CALL(fake_url_fetcher_creator(), OnCreateFakeURLFetcher(
         kURLRegisterComplete));
     EXPECT_CALL(fake_url_fetcher_creator(), OnCreateFakeURLFetcher(kURLInfo))
         .WillOnce(InvokeWithoutArgs(&condition_token_claimed,
                                     &TestMessageLoopCondition::Signal));
   }
 
   condition_token_claimed.Wait();
 
   test_service_discovery_client()->SimulateReceive(
       kAnnouncePacketRegistered, sizeof(kAnnouncePacketRegistered));
 
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_TRUE(WebUIBrowserTest::RunJavascriptTest("expectRegisterDone"));
 }
 
 }  // namespace
 
 }  // namespace local_discovery