Convert URLFetcher::Delegates to use an interface in content/public/common. Also remove the old U...

chrome/common/net/gaia/gaia_auth_fetcher_unittest.cc

 // Copyright (c) 2011 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.
 //
 // A complete set of unit tests for GaiaAuthFetcher.
 // Originally ported from GoogleAuthenticator tests.
 
 #include "chrome/common/net/gaia/gaia_auth_fetcher_unittest.h"
 
 #include <string>
 
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "chrome/common/net/gaia/gaia_auth_consumer.h"
 #include "chrome/common/net/gaia/gaia_auth_fetcher.h"
 #include "chrome/common/net/gaia/gaia_urls.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "chrome/common/net/http_return.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/common/net/url_fetcher.h"
+#include "content/public/common/url_fetcher_delegate.h"
 #include "content/test/test_url_fetcher_factory.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 
 MockFetcher::MockFetcher(bool success,
                          const GURL& url,
                          const std::string& results,
                          URLFetcher::RequestType request_type,
-                         URLFetcher::Delegate* d)
+                         content::URLFetcherDelegate* d)
     : URLFetcher(url, request_type, d),
-      success_(success),
       url_(url),
-      results_(results) {}
+      results_(results) {
+  net::URLRequestStatus::Status code;
+  
+  if (success) {
+    response_code_ = RC_REQUEST_OK;
+    code = net::URLRequestStatus::SUCCESS;
+  } else {
+    response_code_ = RC_FORBIDDEN;
+    code = net::URLRequestStatus::FAILED;
+  }
+
+  status_ = net::URLRequestStatus(code, 0);
+}
+
+MockFetcher::MockFetcher(const GURL& url,
+                         const net::URLRequestStatus& status,
+                         int response_code,
+                         const net::ResponseCookies& cookies,
+                         const std::string& results,
+                         URLFetcher::RequestType request_type,
+                         content::URLFetcherDelegate* d)
+  : URLFetcher(url, request_type, d),
+    url_(url),
+    status_(status),
+    response_code_(response_code),
+    cookies_(cookies),
+    results_(results) {
+}
 
 MockFetcher::~MockFetcher() {}
 
 void MockFetcher::Start() {
-  net::URLRequestStatus::Status code;
-  int http_code;
-  if (success_) {
-    http_code = RC_REQUEST_OK;
-    code = net::URLRequestStatus::SUCCESS;
-  } else {
-    http_code = RC_FORBIDDEN;
-    code = net::URLRequestStatus::FAILED;
-  }
+  delegate()->OnURLFetchComplete(this);
+}
 
-  net::URLRequestStatus status(code, 0);
-  delegate()->OnURLFetchComplete(NULL,
-                                 url_,
-                                 status,
-                                 http_code,
-                                 net::ResponseCookies(),
-                                 results_);
+const GURL& MockFetcher::url() const {
+  return url_;
+}
+
+const net::URLRequestStatus& MockFetcher::status() const {
+  return status_;
+}
+
+int MockFetcher::response_code() const {
+  return response_code_;
+}
+
+const net::ResponseCookies& MockFetcher::cookies() const {
+  return cookies_;
+}
+
+bool MockFetcher::GetResponseAsString(std::string* out_response_string) const {
+  *out_response_string = results_;
+  return true;
 }
 
 
 class GaiaAuthFetcherTest : public testing::Test {
  public:
   GaiaAuthFetcherTest()
       : client_login_source_(GaiaUrls::GetInstance()->client_login_url()),
         issue_auth_token_source_(
             GaiaUrls::GetInstance()->issue_auth_token_url()),
         token_auth_source_(GaiaUrls::GetInstance()->token_auth_url()),
@@ skipping 95 matching lines @@
   GoogleServiceAuthError expected_error =
       GoogleServiceAuthError::FromConnectionError(error_no);
 
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnClientLoginFailure(expected_error))
       .Times(1);
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
 
-  auth.OnURLFetchComplete(NULL,
-                          client_login_source_,
-                          status,
-                          0,
-                          cookies_,
-                          std::string());
+  MockFetcher mock_fetcher(
+      client_login_source_, status, 0, net::ResponseCookies(), std::string(),
+      URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
 }
 
 TEST_F(GaiaAuthFetcherTest, TokenNetFailure) {
   int error_no = net::ERR_CONNECTION_RESET;
   net::URLRequestStatus status(net::URLRequestStatus::FAILED, error_no);
 
   GoogleServiceAuthError expected_error =
       GoogleServiceAuthError::FromConnectionError(error_no);
 
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnIssueAuthTokenFailure(_, expected_error))
       .Times(1);
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
 
-  auth.OnURLFetchComplete(NULL,
-                          issue_auth_token_source_,
-                          status,
-                          0,
-                          cookies_,
-                          std::string());
+  MockFetcher mock_fetcher(
+      issue_auth_token_source_, status, 0, cookies_, std::string(),
+      URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
 }
 
 
 TEST_F(GaiaAuthFetcherTest, LoginDenied) {
   std::string data("Error=BadAuthentication");
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
 
   GoogleServiceAuthError expected_error(
       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
 
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnClientLoginFailure(expected_error))
       .Times(1);
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
-  auth.OnURLFetchComplete(NULL,
-                          client_login_source_,
-                          status,
-                          RC_FORBIDDEN,
-                          cookies_,
-                          data);
+
+  MockFetcher mock_fetcher(
+      client_login_source_, status, RC_FORBIDDEN, cookies_, data,
+      URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
 }
 
 TEST_F(GaiaAuthFetcherTest, ParseRequest) {
   RunParsingTest("SID=sid\nLSID=lsid\nAuth=auth\n", "sid", "lsid", "auth");
   RunParsingTest("LSID=lsid\nSID=sid\nAuth=auth\n", "sid", "lsid", "auth");
   RunParsingTest("SID=sid\nLSID=lsid\nAuth=auth", "sid", "lsid", "auth");
   RunParsingTest("SID=sid\nAuth=auth\n", "sid", "", "auth");
   RunParsingTest("LSID=lsid\nAuth=auth\n", "", "lsid", "auth");
   RunParsingTest("\nAuth=auth\n", "", "", "auth");
   RunParsingTest("SID=sid", "sid", "", "");
@@ skipping 24 matching lines @@
   result.token = "auth";
   result.data = data;
 
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnClientLoginSuccess(result))
       .Times(1);
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  auth.OnURLFetchComplete(NULL,
-                          client_login_source_,
-                          status,
-                          RC_REQUEST_OK,
-                          cookies_,
-                          data);
+  MockFetcher mock_fetcher(
+      client_login_source_, status, RC_REQUEST_OK, cookies_, data,
+      URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
 }
 
 TEST_F(GaiaAuthFetcherTest, WorkingIssueAuthToken) {
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnIssueAuthTokenSuccess(_, "token"))
       .Times(1);
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  auth.OnURLFetchComplete(NULL,
-                          issue_auth_token_source_,
-                          status,
-                          RC_REQUEST_OK,
-                          cookies_,
-                          "token");
+  MockFetcher mock_fetcher(
+      issue_auth_token_source_, status, RC_REQUEST_OK, cookies_, "token",
+      URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
 }
 
 TEST_F(GaiaAuthFetcherTest, CheckTwoFactorResponse) {
   std::string response =
       base::StringPrintf("Error=BadAuthentication\n%s\n",
                          GaiaAuthFetcher::kSecondFactor);
   EXPECT_TRUE(GaiaAuthFetcher::IsSecondFactorSuccess(response));
 }
 
 TEST_F(GaiaAuthFetcherTest, CheckNormalErrorCode) {
   std::string response = "Error=BadAuthentication\n";
   EXPECT_FALSE(GaiaAuthFetcher::IsSecondFactorSuccess(response));
 }
 
 TEST_F(GaiaAuthFetcherTest, TwoFactorLogin) {
   std::string response = base::StringPrintf("Error=BadAuthentication\n%s\n",
       GaiaAuthFetcher::kSecondFactor);
 
   GoogleServiceAuthError error =
       GoogleServiceAuthError(GoogleServiceAuthError::TWO_FACTOR);
 
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnClientLoginFailure(error))
       .Times(1);
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  auth.OnURLFetchComplete(NULL,
-                          client_login_source_,
-                          status,
-                          RC_FORBIDDEN,
-                          cookies_,
-                          response);
+  MockFetcher mock_fetcher(
+      client_login_source_, status, RC_FORBIDDEN, cookies_, response,
+      URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
 }
 
 TEST_F(GaiaAuthFetcherTest, CaptchaParse) {
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
   std::string data = "Url=http://www.google.com/login/captcha\n"
                      "Error=CaptchaRequired\n"
                      "CaptchaToken=CCTOKEN\n"
                      "CaptchaUrl=Captcha?ctoken=CCTOKEN\n";
   GoogleServiceAuthError error =
       GaiaAuthFetcher::GenerateAuthError(data, status);
@@ skipping 130 matching lines @@
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
   auth.StartClientLogin("username",
                         "password",
                         "service",
                         std::string(),
                         std::string(),
                         GaiaAuthFetcher::HostedAccountsAllowed);
 
   EXPECT_TRUE(auth.HasPendingFetch());
-  auth.OnURLFetchComplete(
-      NULL,
+  MockFetcher mock_fetcher(
       client_login_source_,
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0),
-      RC_REQUEST_OK,
-      cookies_,
-      "SID=sid\nLSID=lsid\nAuth=auth\n");
+      RC_REQUEST_OK, cookies_, "SID=sid\nLSID=lsid\nAuth=auth\n",
+      URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
   EXPECT_FALSE(auth.HasPendingFetch());
 }
 
 TEST_F(GaiaAuthFetcherTest, FullTokenSuccess) {
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnIssueAuthTokenSuccess("service", "token"))
       .Times(1);
 
   TestingProfile profile;
 
   TestURLFetcherFactory factory;
   GaiaAuthFetcher auth(&consumer, std::string(),
                        profile_.GetRequestContext());
   auth.StartIssueAuthToken("sid", "lsid", "service");
 
   EXPECT_TRUE(auth.HasPendingFetch());
-  auth.OnURLFetchComplete(
-      NULL,
+  MockFetcher mock_fetcher(
       issue_auth_token_source_,
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0),
-      RC_REQUEST_OK,
-      cookies_,
-      "token");
+      RC_REQUEST_OK, cookies_, "token",
+      URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
   EXPECT_FALSE(auth.HasPendingFetch());
 }
 
 TEST_F(GaiaAuthFetcherTest, FullTokenFailure) {
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnIssueAuthTokenFailure("service", _))
       .Times(1);
 
   TestingProfile profile;
   TestURLFetcherFactory factory;
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
   auth.StartIssueAuthToken("sid", "lsid", "service");
 
   EXPECT_TRUE(auth.HasPendingFetch());
-  auth.OnURLFetchComplete(
-      NULL,
+  MockFetcher mock_fetcher(
       issue_auth_token_source_,
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0),
-      RC_FORBIDDEN,
-      cookies_,
-      "");
+      RC_FORBIDDEN, cookies_, "", URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
   EXPECT_FALSE(auth.HasPendingFetch());
 }
 
 TEST_F(GaiaAuthFetcherTest, TokenAuthSuccess) {
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnTokenAuthSuccess("<html></html>"))
       .Times(1);
 
   TestingProfile profile;
   TestURLFetcherFactory factory;
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
   auth.StartTokenAuth("myubertoken");
 
   EXPECT_TRUE(auth.HasPendingFetch());
-  auth.OnURLFetchComplete(
-      NULL,
+  MockFetcher mock_fetcher(
       token_auth_source_,
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0),
-      RC_REQUEST_OK,
-      cookies_,
-      "<html></html>");
+      RC_REQUEST_OK, cookies_, "<html></html>", URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
   EXPECT_FALSE(auth.HasPendingFetch());
 }
 
 TEST_F(GaiaAuthFetcherTest, TokenAuthUnauthorizedFailure) {
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnTokenAuthFailure(_))
       .Times(1);
 
   TestingProfile profile;
   TestURLFetcherFactory factory;
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
   auth.StartTokenAuth("badubertoken");
 
   EXPECT_TRUE(auth.HasPendingFetch());
-  auth.OnURLFetchComplete(
-      NULL,
+  MockFetcher mock_fetcher(
       token_auth_source_,
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0),
-      RC_UNAUTHORIZED,
-      cookies_,
-      "");
+      RC_UNAUTHORIZED, cookies_, "", URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
   EXPECT_FALSE(auth.HasPendingFetch());
 }
 
 TEST_F(GaiaAuthFetcherTest, TokenAuthNetFailure) {
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnTokenAuthFailure(_))
       .Times(1);
 
   TestingProfile profile;
   TestURLFetcherFactory factory;
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
   auth.StartTokenAuth("badubertoken");
 
   EXPECT_TRUE(auth.HasPendingFetch());
-  auth.OnURLFetchComplete(
-      NULL,
+  MockFetcher mock_fetcher(
       token_auth_source_,
       net::URLRequestStatus(net::URLRequestStatus::FAILED, 0),
-      RC_REQUEST_OK,
-      cookies_,
-      "");
+      RC_REQUEST_OK, cookies_, "", URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
   EXPECT_FALSE(auth.HasPendingFetch());
 }
 
 TEST_F(GaiaAuthFetcherTest, MergeSessionSuccess) {
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnMergeSessionSuccess("<html></html>"))
       .Times(1);
 
   TestingProfile profile;
   TestURLFetcherFactory factory;
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
   auth.StartMergeSession("myubertoken");
 
   EXPECT_TRUE(auth.HasPendingFetch());
-  auth.OnURLFetchComplete(
-      NULL,
+  MockFetcher mock_fetcher(
       merge_session_source_,
       net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0),
-      RC_REQUEST_OK,
-      cookies_,
-      "<html></html>");
+      RC_REQUEST_OK, cookies_, "<html></html>", URLFetcher::GET, &auth);
+  auth.OnURLFetchComplete(&mock_fetcher);
   EXPECT_FALSE(auth.HasPendingFetch());
 }
 
 TEST_F(GaiaAuthFetcherTest, MergeSessionSuccessRedirect) {
   MockGaiaConsumer consumer;
   EXPECT_CALL(consumer, OnMergeSessionSuccess("<html></html>"))
       .Times(1);
 
   TestingProfile profile;
   TestURLFetcherFactory factory;
 
   GaiaAuthFetcher auth(&consumer, std::string(),
       profile_.GetRequestContext());
   auth.StartMergeSession("myubertoken");
 
   // Make sure the fetcher created has the expected flags.  Set its url()
   // properties to reflect a redirect.
   TestURLFetcher* test_fetcher = factory.GetFetcherByID(0);
   EXPECT_TRUE(test_fetcher != NULL);
   EXPECT_TRUE(test_fetcher->load_flags() == net::LOAD_NORMAL);
   EXPECT_TRUE(auth.HasPendingFetch());
 
   GURL final_url("http://www.google.com/CheckCookie");
   test_fetcher->set_url(final_url);
+  test_fetcher->set_status(
+      net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0));
+  test_fetcher->set_response_code(RC_REQUEST_OK);
+  test_fetcher->set_cookies(cookies_);
+  test_fetcher->SetResponseString("<html></html>");
 
-  auth.OnURLFetchComplete(
-      test_fetcher,
-      test_fetcher->url(),
-      net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0),
-      RC_REQUEST_OK,
-      cookies_,
-      "<html></html>");
+  auth.OnURLFetchComplete(test_fetcher);
   EXPECT_FALSE(auth.HasPendingFetch());
 }