Settings Rewrite: Fix Opening Sync User login

chrome/browser/ui/webui/settings/people_handler_unittest.cc

 // Copyright 2015 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/settings/people_handler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 381 matching lines @@
 TEST_F(PeopleHandlerTest,
        DisplayConfigureWithBackendDisabledAndSyncStartupCompleted) {
   EXPECT_CALL(*mock_pss_, CanSyncStart()).WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   error_ = GoogleServiceAuthError::AuthErrorNone();
   // Sync backend is stopped initially, and will start up.
   EXPECT_CALL(*mock_pss_, IsBackendInitialized()).WillRepeatedly(Return(false));
   SetDefaultExpectationsForConfigPage();
 
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   // We expect a call to settings.SyncPrivateApi.showSyncSetupPage.
   EXPECT_EQ(1U, web_ui_.call_data().size());
 
   const content::TestWebUI::CallData& data0 = *web_ui_.call_data()[0];
   EXPECT_EQ("settings.SyncPrivateApi.showSyncSetupPage", data0.function_name());
   std::string page;
   ASSERT_TRUE(data0.arg1()->GetAsString(&page));
   EXPECT_EQ(page, "spinner");
 
@@ skipping 28 matching lines @@
 TEST_F(PeopleHandlerTest,
        DisplayConfigureWithBackendDisabledAndCancelAfterSigninSuccess) {
   EXPECT_CALL(*mock_pss_, CanSyncStart()).WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   error_ = GoogleServiceAuthError::AuthErrorNone();
   EXPECT_CALL(*mock_pss_, IsBackendInitialized())
       .WillOnce(Return(false))
       .WillRepeatedly(Return(true));
   SetDefaultExpectationsForConfigPage();
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   // 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_, RequestStop(ProfileSyncService::CLEAR_DATA));
   EXPECT_CALL(*mock_pss_, SetSetupInProgress(false));
 
   handler_->CloseSyncSetup();
   EXPECT_EQ(NULL,
             LoginUIServiceFactory::GetForProfile(
                 profile_)->current_login_ui());
 }
 
 TEST_F(PeopleHandlerTest,
        DisplayConfigureWithBackendDisabledAndSigninFailed) {
   EXPECT_CALL(*mock_pss_, CanSyncStart()).WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   error_ = GoogleServiceAuthError::AuthErrorNone();
   EXPECT_CALL(*mock_pss_, IsBackendInitialized()).WillRepeatedly(Return(false));
 
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
   const content::TestWebUI::CallData& data = *web_ui_.call_data()[0];
   EXPECT_EQ("settings.SyncPrivateApi.showSyncSetupPage", data.function_name());
   std::string page;
   ASSERT_TRUE(data.arg1()->GetAsString(&page));
   EXPECT_EQ(page, "spinner");
   Mock::VerifyAndClearExpectations(mock_pss_);
   error_ = GoogleServiceAuthError(
       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
   EXPECT_CALL(*mock_pss_, GetAuthError()).WillRepeatedly(ReturnRef(error_));
   NotifySyncListeners();
@@ skipping 11 matching lines @@
   PeopleHandlerNonCrosTest() {}
 };
 
 TEST_F(PeopleHandlerNonCrosTest, HandleGaiaAuthFailure) {
   EXPECT_CALL(*mock_pss_, CanSyncStart()).WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasUnrecoverableError())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   // Open the web UI.
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   ASSERT_FALSE(handler_->is_configuring_sync());
 }
 
 // TODO(kochi): We need equivalent tests for ChromeOS.
 TEST_F(PeopleHandlerNonCrosTest, UnrecoverableErrorInitializingSync) {
   EXPECT_CALL(*mock_pss_, CanSyncStart()).WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   // Open the web UI.
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   ASSERT_FALSE(handler_->is_configuring_sync());
 }
 
 TEST_F(PeopleHandlerNonCrosTest, GaiaErrorInitializingSync) {
   EXPECT_CALL(*mock_pss_, CanSyncStart()).WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, HasSyncSetupCompleted())
       .WillRepeatedly(Return(false));
   // Open the web UI.
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   ASSERT_FALSE(handler_->is_configuring_sync());
 }
 
 #endif  // #if !defined(OS_CHROMEOS)
 
 TEST_F(PeopleHandlerTest, TestSyncEverything) {
   std::string args = GetConfiguration(
       NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(), ENCRYPT_PASSWORDS);
   base::ListValue list_args;
@@ skipping 208 matching lines @@
 }
 
 TEST_F(PeopleHandlerTest, ShowSyncSetup) {
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   // This should display the sync setup dialog (not login).
   SetDefaultExpectationsForConfigPage();
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   ExpectConfig();
 }
 
 // We do not display signin on chromeos in the case of auth error.
 TEST_F(PeopleHandlerTest, ShowSigninOnAuthError) {
   // Initialize the system to a signed in state, but with an auth error.
   error_ = GoogleServiceAuthError(
       GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
 
@@ skipping 14 matching lines @@
   // sync backend (which will fail due to the auth error). This should only
   // happen if the user manually navigates to chrome://settings/syncSetup -
   // clicking on the button in the UI will sign the user out rather than
   // displaying a spinner. Should be no visible UI on ChromeOS in this case.
   EXPECT_EQ(NULL, LoginUIServiceFactory::GetForProfile(
       profile_)->current_login_ui());
 #else
 
   // On ChromeOS, this should display the spinner while we try to startup the
   // sync backend, and on desktop this displays the login dialog.
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   // Sync setup is closed when re-auth is in progress.
   EXPECT_EQ(NULL,
             LoginUIServiceFactory::GetForProfile(
                 profile_)->current_login_ui());
 
   ASSERT_FALSE(handler_->is_configuring_sync());
 #endif
 }
 
 TEST_F(PeopleHandlerTest, ShowSetupSyncEverything) {
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   SetDefaultExpectationsForConfigPage();
   // This should display the sync setup dialog (not login).
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   ExpectConfig();
   const content::TestWebUI::CallData& data = *web_ui_.call_data()[0];
   const base::DictionaryValue* dictionary = nullptr;
   ASSERT_TRUE(data.arg2()->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "syncAllDataTypes", true);
   CheckBool(dictionary, "appsRegistered", true);
   CheckBool(dictionary, "autofillRegistered", true);
   CheckBool(dictionary, "bookmarksRegistered", true);
   CheckBool(dictionary, "extensionsRegistered", true);
@@ skipping 13 matching lines @@
 TEST_F(PeopleHandlerTest, ShowSetupManuallySyncAll) {
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   sync_driver::SyncPrefs sync_prefs(profile_->GetPrefs());
   sync_prefs.SetKeepEverythingSynced(false);
   SetDefaultExpectationsForConfigPage();
   // This should display the sync setup dialog (not login).
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   ExpectConfig();
   const content::TestWebUI::CallData& data = *web_ui_.call_data()[0];
   const base::DictionaryValue* dictionary = nullptr;
   ASSERT_TRUE(data.arg2()->GetAsDictionary(&dictionary));
   CheckConfigDataTypeArguments(dictionary, CHOOSE_WHAT_TO_SYNC, GetAllTypes());
 }
 
 TEST_F(PeopleHandlerTest, ShowSetupSyncForAllTypesIndividually) {
   syncer::ModelTypeSet user_selectable_types = GetAllTypes();
   syncer::ModelTypeSet::Iterator it;
   for (it = user_selectable_types.First(); it.Good(); it.Inc()) {
     EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
         .WillRepeatedly(Return(false));
     EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
         .WillRepeatedly(Return(false));
     SetupInitializedProfileSyncService();
     sync_driver::SyncPrefs sync_prefs(profile_->GetPrefs());
     sync_prefs.SetKeepEverythingSynced(false);
     SetDefaultExpectationsForConfigPage();
     syncer::ModelTypeSet types;
     types.Put(it.Get());
     EXPECT_CALL(*mock_pss_, GetPreferredDataTypes()).
         WillRepeatedly(Return(types));
 
     // This should display the sync setup dialog (not login).
-    handler_->OpenSyncSetup(nullptr);
+    handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
     ExpectConfig();
     // Close the config overlay.
     LoginUIServiceFactory::GetForProfile(profile_)->LoginUIClosed(
         handler_.get());
     const content::TestWebUI::CallData& data = *web_ui_.call_data()[0];
     const base::DictionaryValue* dictionary = nullptr;
     ASSERT_TRUE(data.arg2()->GetAsDictionary(&dictionary));
     CheckConfigDataTypeArguments(dictionary, CHOOSE_WHAT_TO_SYNC, types);
     Mock::VerifyAndClearExpectations(mock_pss_);
     // Clean up so we can loop back to display the dialog again.
     web_ui_.ClearTrackedCalls();
   }
 }
 
 TEST_F(PeopleHandlerTest, ShowSetupGaiaPassphraseRequired) {
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   SetDefaultExpectationsForConfigPage();
 
   // This should display the sync setup dialog (not login).
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   ExpectConfig();
   const content::TestWebUI::CallData& data = *web_ui_.call_data()[0];
   const base::DictionaryValue* dictionary = nullptr;
   ASSERT_TRUE(data.arg2()->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "showPassphrase", true);
   CheckBool(dictionary, "usePassphrase", false);
   CheckBool(dictionary, "passphraseFailed", false);
 }
 
 TEST_F(PeopleHandlerTest, ShowSetupCustomPassphraseRequired) {
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, GetPassphraseType())
       .WillRepeatedly(Return(syncer::CUSTOM_PASSPHRASE));
   SetupInitializedProfileSyncService();
   SetDefaultExpectationsForConfigPage();
 
   // This should display the sync setup dialog (not login).
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   ExpectConfig();
   const content::TestWebUI::CallData& data = *web_ui_.call_data()[0];
   const base::DictionaryValue* dictionary = nullptr;
   ASSERT_TRUE(data.arg2()->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "showPassphrase", true);
   CheckBool(dictionary, "usePassphrase", true);
   CheckBool(dictionary, "passphraseFailed", false);
 }
 
 TEST_F(PeopleHandlerTest, ShowSetupEncryptAll) {
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   SetDefaultExpectationsForConfigPage();
   EXPECT_CALL(*mock_pss_, IsEncryptEverythingEnabled())
       .WillRepeatedly(Return(true));
 
   // This should display the sync setup dialog (not login).
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   ExpectConfig();
   const content::TestWebUI::CallData& data = *web_ui_.call_data()[0];
   const base::DictionaryValue* dictionary = nullptr;
   ASSERT_TRUE(data.arg2()->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "encryptAllData", true);
 }
 
 TEST_F(PeopleHandlerTest, ShowSetupEncryptAllDisallowed) {
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   SetDefaultExpectationsForConfigPage();
   EXPECT_CALL(*mock_pss_, IsEncryptEverythingAllowed())
       .WillRepeatedly(Return(false));
 
   // This should display the sync setup dialog (not login).
-  handler_->OpenSyncSetup(nullptr);
+  handler_->OpenSyncSetup(false /* creating_supervised_user */);
 
   ExpectConfig();
   const content::TestWebUI::CallData& data = *web_ui_.call_data()[0];
   const base::DictionaryValue* dictionary = nullptr;
   ASSERT_TRUE(data.arg2()->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "encryptAllData", false);
   CheckBool(dictionary, "encryptAllDataAllowed", false);
 }
 
 TEST_F(PeopleHandlerTest, TurnOnEncryptAllDisallowed) {
@@ skipping 11 matching lines @@
   EXPECT_CALL(*mock_pss_, EnableEncryptEverything()).Times(0);
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(true, _));
   handler_->HandleConfigure(&list_args);
 
   // Ensure that we navigated to the "done" state since we don't need a
   // passphrase.
   ExpectDone();
 }
 
 }  // namespace settings