signin: move SigninManagerBase::Signout to SigninManager.

chrome/browser/ui/webui/sync_setup_handler_unittest.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 "chrome/browser/ui/webui/sync_setup_handler.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/signin/fake_auth_status_provider.h"
 #include "chrome/browser/signin/fake_signin_manager.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service_mock.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service.h"
 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
 #include "chrome/browser/ui/webui/sync_promo/sync_promo_ui.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chrome/test/base/scoped_testing_local_state.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/generated_resources.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::ReturnRef;
@@ skipping 275 matching lines @@
   using SyncSetupHandler::have_signin_tracker;
 
  private:
   virtual void DisplayGaiaLoginInNewTabOrWindow() OVERRIDE {}
 
   // Weak pointer to parent profile.
   Profile* profile_;
   DISALLOW_COPY_AND_ASSIGN(TestingSyncSetupHandler);
 };
 
-class SigninManagerBaseMock : public FakeSigninManagerBase {
- public:
-  explicit SigninManagerBaseMock(Profile* profile)
-      : FakeSigninManagerBase(profile) {}
-  MOCK_CONST_METHOD1(IsAllowedUsername, bool(const std::string& username));
-};
-
-static ProfileKeyedService* BuildSigninManagerBaseMock(
-    content::BrowserContext* profile) {
-  return new SigninManagerBaseMock(static_cast<Profile*>(profile));
-}
-
 // The boolean parameter indicates whether the test is run with ClientOAuth
 // or not.  The test parameter is a bool: whether or not to test with/
 // /ClientLogin enabled or not.
 class SyncSetupHandlerTest : public testing::TestWithParam<bool> {
  public:
   SyncSetupHandlerTest() : error_(GoogleServiceAuthError::NONE) {}
   virtual void SetUp() OVERRIDE {
     bool use_client_login_flow = GetParam();
     if (use_client_login_flow) {
       if (!CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 13 matching lines @@
             profile_.get(),
             ProfileSyncServiceMock::BuildMockProfileSyncService));
     mock_pss_->Initialize();
 
     ON_CALL(*mock_pss_, GetPassphraseType()).WillByDefault(
         Return(syncer::IMPLICIT_PASSPHRASE));
     ON_CALL(*mock_pss_, GetPassphraseTime()).WillByDefault(
         Return(base::Time()));
     ON_CALL(*mock_pss_, GetExplicitPassphraseTime()).WillByDefault(
         Return(base::Time()));
+#if defined(OS_CHROMEOS)
     mock_signin_ = static_cast<SigninManagerBase*>(
         SigninManagerFactory::GetInstance()->SetTestingFactoryAndUse(
-            profile_.get(), BuildSigninManagerBaseMock));
+            profile_.get(), FakeSigninManagerBase::Build));
+#else
+    mock_signin_ = static_cast<SigninManagerBase*>(
+        SigninManagerFactory::GetInstance()->SetTestingFactoryAndUse(
+            profile_.get(), FakeSigninManager::Build));
+#endif
     handler_.reset(new TestingSyncSetupHandler(&web_ui_, profile_.get()));
   }
 
   // Setup the expectations for calls made when displaying the config page.
   void SetDefaultExpectationsForConfigPage() {
     EXPECT_CALL(*mock_pss_, GetRegisteredDataTypes()).
         WillRepeatedly(Return(GetAllTypes()));
     EXPECT_CALL(*mock_pss_, GetPreferredDataTypes()).
         WillRepeatedly(Return(GetAllTypes()));
     EXPECT_CALL(*mock_pss_, EncryptEverythingEnabled()).
         WillRepeatedly(Return(false));
   }
 
   void SetupInitializedProfileSyncService() {
     // An initialized ProfileSyncService will have already completed sync setup
     // and will have an initialized sync backend.
-    mock_signin_->SetAuthenticatedUsername(kTestUser);
+    if (!mock_signin_->IsInitialized()) {
+      profile_->GetPrefs()->SetString(
+          prefs::kGoogleServicesUsername, kTestUser);
+      mock_signin_->Initialize(profile_.get());
+    }
     EXPECT_CALL(*mock_pss_, IsSyncEnabledAndLoggedIn())
         .WillRepeatedly(Return(true));
     EXPECT_CALL(*mock_pss_, IsSyncTokenAvailable())
         .WillRepeatedly(Return(true));
     EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
         .WillRepeatedly(Return(true));
     EXPECT_CALL(*mock_pss_, GetAuthError()).WillRepeatedly(ReturnRef(error_));
     EXPECT_CALL(*mock_pss_, sync_initialized()).WillRepeatedly(Return(true));
   }
 
@@ skipping 92 matching lines @@
               LoginUIServiceFactory::GetForProfile(
                   profile_.get())->current_login_ui());
   }
 }
 
 // Verifies that the handler correctly handles a cancellation when
 // it is displaying the spinner to the user.
 TEST_P(SyncSetupHandlerTest, DisplayConfigureWithBackendDisabledAndCancel) {
   EXPECT_CALL(*mock_pss_, IsSyncEnabledAndLoggedIn())
       .WillRepeatedly(Return(true));
-  mock_signin_->SetAuthenticatedUsername(kTestUser);
+  profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, kTestUser);
+  mock_signin_->Initialize(profile_.get());
   EXPECT_CALL(*mock_pss_, IsSyncTokenAvailable())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   error_ = GoogleServiceAuthError::AuthErrorNone();
   EXPECT_CALL(*mock_pss_, GetAuthError()).WillRepeatedly(ReturnRef(error_));
   EXPECT_CALL(*mock_pss_, sync_initialized()).WillRepeatedly(Return(false));
 
   // We're simulating a user setting up sync, which would cause the backend to
   // kick off initialization, but not download user data types. The sync
@@ skipping 21 matching lines @@
             LoginUIServiceFactory::GetForProfile(
                 profile_.get())->current_login_ui());
 }
 
 // Verifies that the handler correctly transitions from showing the spinner
 // to showing a configuration page when signin completes successfully.
 TEST_P(SyncSetupHandlerTest,
        DisplayConfigureWithBackendDisabledAndSigninSuccess) {
   EXPECT_CALL(*mock_pss_, IsSyncEnabledAndLoggedIn())
       .WillRepeatedly(Return(true));
-  mock_signin_->SetAuthenticatedUsername(kTestUser);
+  profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, kTestUser);
+  mock_signin_->Initialize(profile_.get());
   EXPECT_CALL(*mock_pss_, IsSyncTokenAvailable())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   error_ = GoogleServiceAuthError::AuthErrorNone();
   EXPECT_CALL(*mock_pss_, GetAuthError()).WillRepeatedly(ReturnRef(error_));
   // Sync backend is stopped initially, and will start up.
   EXPECT_CALL(*mock_pss_, sync_initialized())
       .WillRepeatedly(Return(false));
   SetDefaultExpectationsForConfigPage();
@@ skipping 36 matching lines @@
 
 // Verifies the case where the user cancels after the sync backend has
 // initialized (meaning it already transitioned from the spinner to a proper
 // configuration page, tested by
 // DisplayConfigureWithBackendDisabledAndSigninSuccess), but before the user
 // before the user has continued on.
 TEST_P(SyncSetupHandlerTest,
        DisplayConfigureWithBackendDisabledAndCancelAfterSigninSuccess) {
   EXPECT_CALL(*mock_pss_, IsSyncEnabledAndLoggedIn())
       .WillRepeatedly(Return(true));
-  mock_signin_->SetAuthenticatedUsername(kTestUser);
+  profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, kTestUser);
+  mock_signin_->Initialize(profile_.get());
   EXPECT_CALL(*mock_pss_, IsSyncTokenAvailable())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   error_ = GoogleServiceAuthError::AuthErrorNone();
   EXPECT_CALL(*mock_pss_, GetAuthError()).WillRepeatedly(ReturnRef(error_));
   EXPECT_CALL(*mock_pss_, sync_initialized())
       .WillOnce(Return(false))
       .WillRepeatedly(Return(true));
   SetDefaultExpectationsForConfigPage();
   handler_->OpenSyncSetup();
   handler_->SigninSuccess();
 
   // It's important to tell sync the user cancelled the setup flow before we
   // tell it we're through with the setup progress.
   testing::InSequence seq;
   EXPECT_CALL(*mock_pss_, DisableForUser());
   EXPECT_CALL(*mock_pss_, SetSetupInProgress(false));
 
   handler_->CloseSyncSetup();
   EXPECT_EQ(NULL,
             LoginUIServiceFactory::GetForProfile(
                 profile_.get())->current_login_ui());
 }
 
 TEST_P(SyncSetupHandlerTest,
        DisplayConfigureWithBackendDisabledAndSigninFalied) {
   EXPECT_CALL(*mock_pss_, IsSyncEnabledAndLoggedIn())
       .WillRepeatedly(Return(true));
-  mock_signin_->SetAuthenticatedUsername(kTestUser);
+  profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, kTestUser);
+  mock_signin_->Initialize(profile_.get());
   EXPECT_CALL(*mock_pss_, IsSyncTokenAvailable())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   error_ = GoogleServiceAuthError::AuthErrorNone();
   EXPECT_CALL(*mock_pss_, GetAuthError()).WillRepeatedly(ReturnRef(error_));
   EXPECT_CALL(*mock_pss_, sync_initialized()).WillRepeatedly(Return(false));
 
   handler_->OpenSyncSetup();
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   EXPECT_EQ("SyncSetupOverlay.showSyncSetupPage", data.function_name);
   std::string page;
   ASSERT_TRUE(data.arg1->GetAsString(&page));
   EXPECT_EQ(page, "spinner");
   GoogleServiceAuthError error(
       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
   handler_->SigninFailed(error);
   // On failure, the dialog will be closed.
   EXPECT_EQ(NULL,
             LoginUIServiceFactory::GetForProfile(
                 profile_.get())->current_login_ui());
 }
 
 #if !defined(OS_CHROMEOS)
 
-namespace {
-class SigninManagerMock : public FakeSigninManager {
- public:
-  explicit SigninManagerMock(Profile* profile) : FakeSigninManager(profile) {
-  }
-
-  virtual void StartSignIn(const std::string& username,
-                           const std::string& password,
-                           const std::string& login_token,
-                           const std::string& login_captcha) OVERRIDE {
-    SetAuthenticatedUsername(username);
-  }
-
-  MOCK_CONST_METHOD1(IsAllowedUsername, bool(const std::string& username));
-};
-}
-
-static ProfileKeyedService* BuildSigninManagerMock(
-    content::BrowserContext* profile) {
-  return new SigninManagerMock(static_cast<Profile*>(profile));
-}
-
 class SyncSetupHandlerNonCrosTest : public SyncSetupHandlerTest {
  public:
   SyncSetupHandlerNonCrosTest() {}
   virtual void SetUp() OVERRIDE {
     SyncSetupHandlerTest::SetUp();
-    mock_signin_ = static_cast<SigninManagerMock*>(
+    mock_signin_ = static_cast<SigninManagerBase*>(
         SigninManagerFactory::GetInstance()->SetTestingFactoryAndUse(
-            profile_.get(), BuildSigninManagerMock));
+            profile_.get(), FakeSigninManager::Build));
   }
 };
 
 TEST_P(SyncSetupHandlerNonCrosTest, HandleGaiaAuthFailure) {
   EXPECT_CALL(*mock_pss_, IsSyncEnabledAndLoggedIn())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsSyncTokenAvailable())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasUnrecoverableError())
       .WillRepeatedly(Return(false));
@@ skipping 93 matching lines @@
     // complete yet).
     handler_->TryLogin(kTestUser, kTestPassword, std::string(), std::string());
     handler_->GaiaCredentialsValid();
     ASSERT_EQ(2U, web_ui_.call_data().size());
     EXPECT_EQ("SyncSetupOverlay.showSuccessAndSettingUp",
               web_ui_.call_data()[1].function_name);
     // Now fake a sync error.
     GoogleServiceAuthError none(GoogleServiceAuthError::NONE);
     EXPECT_CALL(*mock_pss_, HasUnrecoverableError())
         .WillRepeatedly(Return(true));
-    mock_signin_->SignOut();
+    // On non-Cros platforms, we use SigninManager.
+    static_cast<SigninManager*>(mock_signin_)->SignOut();
     handler_->SigninFailed(none);
     ASSERT_EQ(3U, web_ui_.call_data().size());
     // Validate the second JS call (the first call was already tested by
     // the DisplayBasicLogin test).
     const TestWebUI::CallData& data = web_ui_.call_data()[2];
     EXPECT_EQ("SyncSetupOverlay.showSyncSetupPage", data.function_name);
     std::string page;
     ASSERT_TRUE(data.arg1->GetAsString(&page));
     EXPECT_EQ(page, "login");
     // Now make sure that the appropriate params are being passed.
@@ skipping 29 matching lines @@
     handler_->TryLogin(kTestUser, kTestPassword, std::string(), std::string());
     handler_->GaiaCredentialsValid();
     ASSERT_EQ(2U, web_ui_.call_data().size());
     EXPECT_EQ("SyncSetupOverlay.showSuccessAndSettingUp",
               web_ui_.call_data()[1].function_name);
     // Now fake a sync gaia error.
     GoogleServiceAuthError unavailable(
         GoogleServiceAuthError::SERVICE_UNAVAILABLE);
     EXPECT_CALL(*mock_pss_, HasUnrecoverableError())
         .WillRepeatedly(Return(false));
-    mock_signin_->SignOut();
+    // On non-Cros platforms, we use SigninManager.
+    static_cast<SigninManager*>(mock_signin_)->SignOut();
     handler_->SigninFailed(unavailable);
     ASSERT_EQ(3U, web_ui_.call_data().size());
     // Validate the second JS call (the first call was already tested by
     // the DisplayBasicLogin test).
     const TestWebUI::CallData& data = web_ui_.call_data()[2];
     EXPECT_EQ("SyncSetupOverlay.showSyncSetupPage", data.function_name);
     std::string page;
     ASSERT_TRUE(data.arg1->GetAsString(&page));
     EXPECT_EQ(page, "login");
     // Now make sure that the appropriate params are being passed.
     DictionaryValue* dictionary;
     ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
     CheckShowSyncSetupArgs(dictionary,
                            std::string(),
                            false,
                            GoogleServiceAuthError::SERVICE_UNAVAILABLE,
                            kTestUser,
                            true,
                            std::string());
   } else {
     ASSERT_FALSE(handler_->is_configuring_sync());
     ASSERT_TRUE(handler_->have_signin_tracker());
   }
 }
 
 // Tests that trying to log in with an invalid username results in an error
 // displayed to the user.
 TEST_P(SyncSetupHandlerNonCrosTest, SubmitAuthWithInvalidUsername) {
-  SigninManagerMock* mock_signin =
-      static_cast<SigninManagerMock*>(mock_signin_);
-  EXPECT_CALL(*mock_signin, IsAllowedUsername(_)).
-      WillRepeatedly(Return(false));
+  ScopedTestingLocalState local_state(
+      TestingBrowserProcess::GetGlobal());
+  local_state.Get()->SetString(
+      prefs::kGoogleServicesUsernamePattern, ".*@valid.com");
 
   // Generate a blob of json that matches what would be submitted by the login
   // javascript code.
   DictionaryValue args;
   args.SetString("user", "user@not_allowed.com");
   args.SetString("pass", "password");
   args.SetString("captcha", std::string());
   args.SetString("otp", std::string());
   args.SetString("accessCode", std::string());
   std::string json;
@@ skipping 431 matching lines @@
   ExpectConfig();
   const TestWebUI::CallData& data = web_ui_.call_data()[0];
   DictionaryValue* dictionary;
   ASSERT_TRUE(data.arg2->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "encryptAllData", true);
 }
 
 INSTANTIATE_TEST_CASE_P(SyncSetupHandlerTestWithParam,
                         SyncSetupHandlerTest,
                         Values(true, false));