Rename "managed (mode|user)" to "supervised user" (part 7)

chrome/browser/chromeos/login/supervised/supervised_user_test_base.cc

 // Copyright 2014 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/chromeos/login/managed/managed_user_test_base.h"
+#include "chrome/browser/chromeos/login/supervised/supervised_user_test_base.h"
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/login_manager_test.h"
-#include "chrome/browser/chromeos/login/managed/supervised_user_authentication.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
+#include "chrome/browser/chromeos/login/supervised/supervised_user_authentication.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/ui/webui_login_view.h"
 #include "chrome/browser/chromeos/login/users/supervised_user_manager.h"
 #include "chrome/browser/chromeos/net/network_portal_detector_test_impl.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
 #include "chrome/browser/profiles/profile_impl.h"
 #include "chrome/browser/supervised_user/supervised_user_constants.h"
 #include "chrome/browser/supervised_user/supervised_user_registration_utility.h"
 #include "chrome/browser/supervised_user/supervised_user_registration_utility_stub.h"
@@ skipping 20 matching lines @@
 namespace chromeos {
 
 namespace {
 
 const char kCurrentPage[] = "$('managed-user-creation').currentPage_";
 
 const char kStubEthernetGuid[] = "eth0";
 
 }
 
-ManagedUsersSyncTestAdapter::ManagedUsersSyncTestAdapter(Profile* profile)
+SupervisedUsersSyncTestAdapter::SupervisedUsersSyncTestAdapter(Profile* profile)
     : processor_(), next_sync_data_id_(0) {
   service_ = SupervisedUserSyncServiceFactory::GetForProfile(profile);
   processor_ = new syncer::FakeSyncChangeProcessor();
   service_->MergeDataAndStartSyncing(
       syncer::SUPERVISED_USERS,
       syncer::SyncDataList(),
       scoped_ptr<syncer::SyncChangeProcessor>(processor_),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock));
 }
 
 scoped_ptr< ::sync_pb::ManagedUserSpecifics>
-ManagedUsersSyncTestAdapter::GetFirstChange() {
+SupervisedUsersSyncTestAdapter::GetFirstChange() {
   scoped_ptr< ::sync_pb::ManagedUserSpecifics> result(
       new ::sync_pb::ManagedUserSpecifics);
   CHECK(HasChanges())
       << "GetFirstChange() should only be callled if HasChanges() is true";
   const syncer::SyncData& data = processor_->changes().front().sync_data();
   EXPECT_EQ(syncer::SUPERVISED_USERS, data.GetDataType());
   result->CopyFrom(data.GetSpecifics().managed_user());
   return result.Pass();
 }
 
-void ManagedUsersSyncTestAdapter::AddChange(
+void SupervisedUsersSyncTestAdapter::AddChange(
     const ::sync_pb::ManagedUserSpecifics& proto,
     bool update) {
   sync_pb::EntitySpecifics specifics;
 
   specifics.mutable_managed_user()->CopyFrom(proto);
 
   syncer::SyncData change_data = syncer::SyncData::CreateRemoteData(
       ++next_sync_data_id_,
       specifics,
       base::Time(),
       syncer::AttachmentIdList(),
       syncer::AttachmentServiceProxyForTest::Create());
   syncer::SyncChange change(FROM_HERE,
                             update ? syncer::SyncChange::ACTION_UPDATE
                                    : syncer::SyncChange::ACTION_ADD,
                             change_data);
 
   syncer::SyncChangeList change_list;
   change_list.push_back(change);
 
   service_->ProcessSyncChanges(FROM_HERE, change_list);
 }
 
-ManagedUsersSharedSettingsSyncTestAdapter::
-    ManagedUsersSharedSettingsSyncTestAdapter(Profile* profile)
+SupervisedUsersSharedSettingsSyncTestAdapter::
+    SupervisedUsersSharedSettingsSyncTestAdapter(Profile* profile)
     : processor_(), next_sync_data_id_(0) {
   service_ =
       SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(profile);
   processor_ = new syncer::FakeSyncChangeProcessor();
   service_->MergeDataAndStartSyncing(
       syncer::SUPERVISED_USER_SHARED_SETTINGS,
       syncer::SyncDataList(),
       scoped_ptr<syncer::SyncChangeProcessor>(processor_),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock));
 }
 
 scoped_ptr< ::sync_pb::ManagedUserSharedSettingSpecifics>
-ManagedUsersSharedSettingsSyncTestAdapter::GetFirstChange() {
+SupervisedUsersSharedSettingsSyncTestAdapter::GetFirstChange() {
   scoped_ptr< ::sync_pb::ManagedUserSharedSettingSpecifics> result(
       new ::sync_pb::ManagedUserSharedSettingSpecifics);
   CHECK(HasChanges())
       << "GetFirstChange() should only be callled if HasChanges() is true";
   const syncer::SyncData& data = processor_->changes().front().sync_data();
   EXPECT_EQ(syncer::SUPERVISED_USER_SHARED_SETTINGS, data.GetDataType());
   result->CopyFrom(data.GetSpecifics().managed_user_shared_setting());
   return result.Pass();
 }
 
-void ManagedUsersSharedSettingsSyncTestAdapter::AddChange(
+void SupervisedUsersSharedSettingsSyncTestAdapter::AddChange(
     const ::sync_pb::ManagedUserSharedSettingSpecifics& proto,
     bool update) {
   sync_pb::EntitySpecifics specifics;
 
   specifics.mutable_managed_user_shared_setting()->CopyFrom(proto);
 
   syncer::SyncData change_data = syncer::SyncData::CreateRemoteData(
       ++next_sync_data_id_,
       specifics,
       base::Time(),
       syncer::AttachmentIdList(),
       syncer::AttachmentServiceProxyForTest::Create());
   syncer::SyncChange change(FROM_HERE,
                             update ? syncer::SyncChange::ACTION_UPDATE
                                    : syncer::SyncChange::ACTION_ADD,
                             change_data);
 
   syncer::SyncChangeList change_list;
   change_list.push_back(change);
 
   service_->ProcessSyncChanges(FROM_HERE, change_list);
 }
 
-void ManagedUsersSharedSettingsSyncTestAdapter::AddChange(
+void SupervisedUsersSharedSettingsSyncTestAdapter::AddChange(
     const std::string& mu_id,
     const std::string& key,
     const base::Value& value,
     bool acknowledged,
     bool update) {
   syncer::SyncData data =
       SupervisedUserSharedSettingsService::CreateSyncDataForSetting(
           mu_id, key, value, acknowledged);
   AddChange(data.GetSpecifics().managed_user_shared_setting(), update);
 }
 
-ManagedUserTestBase::ManagedUserTestBase()
+SupervisedUserTestBase::SupervisedUserTestBase()
     : LoginManagerTest(true),
       mock_async_method_caller_(NULL),
       mock_homedir_methods_(NULL),
       network_portal_detector_(NULL),
       registration_utility_stub_(NULL) {
 }
 
-ManagedUserTestBase::~ManagedUserTestBase() {
+SupervisedUserTestBase::~SupervisedUserTestBase() {
 }
 
-void ManagedUserTestBase::SetUpInProcessBrowserTestFixture() {
+void SupervisedUserTestBase::SetUpInProcessBrowserTestFixture() {
   LoginManagerTest::SetUpInProcessBrowserTestFixture();
   mock_async_method_caller_ = new cryptohome::MockAsyncMethodCaller;
   mock_async_method_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   cryptohome::AsyncMethodCaller::InitializeForTesting(
       mock_async_method_caller_);
 
   mock_homedir_methods_ = new cryptohome::MockHomedirMethods;
   mock_homedir_methods_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   cryptohome::HomedirMethods::InitializeForTesting(mock_homedir_methods_);
 
   registration_utility_stub_ = new SupervisedUserRegistrationUtilityStub();
   scoped_utility_.reset(new ScopedTestingSupervisedUserRegistrationUtility(
       registration_utility_stub_));
 
   // Setup network portal detector to return online state for both
   // ethernet and wifi networks. Ethernet is an active network by
   // default.
   network_portal_detector_ = new NetworkPortalDetectorTestImpl();
   NetworkPortalDetector::InitializeForTesting(network_portal_detector_);
   NetworkPortalDetector::CaptivePortalState online_state;
   online_state.status = NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE;
   online_state.response_code = 204;
   network_portal_detector_->SetDefaultNetworkForTesting(kStubEthernetGuid);
   network_portal_detector_->SetDetectionResultsForTesting(kStubEthernetGuid,
                                                           online_state);
 }
 
-void ManagedUserTestBase::CleanUpOnMainThread() {
+void SupervisedUserTestBase::CleanUpOnMainThread() {
   LoginManagerTest::CleanUpOnMainThread();
 }
 
-void ManagedUserTestBase::TearDown() {
+void SupervisedUserTestBase::TearDown() {
   cryptohome::AsyncMethodCaller::Shutdown();
   cryptohome::HomedirMethods::Shutdown();
   mock_homedir_methods_ = NULL;
   mock_async_method_caller_ = NULL;
   LoginManagerTest::TearDown();
 }
 
-void ManagedUserTestBase::TearDownInProcessBrowserTestFixture() {
+void SupervisedUserTestBase::TearDownInProcessBrowserTestFixture() {
   NetworkPortalDetector::Shutdown();
 }
 
-void ManagedUserTestBase::JSEval(const std::string& script) {
+void SupervisedUserTestBase::JSEval(const std::string& script) {
   EXPECT_TRUE(content::ExecuteScript(web_contents(), script)) << script;
 }
 
-void ManagedUserTestBase::JSExpectAsync(const std::string& function) {
+void SupervisedUserTestBase::JSExpectAsync(const std::string& function) {
   bool result;
   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
       web_contents(),
       StringPrintf(
           "(%s)(function() { window.domAutomationController.send(true); });",
           function.c_str()),
       &result)) << function;
   EXPECT_TRUE(result);
 }
 
-void ManagedUserTestBase::JSSetTextField(const std::string& element_selector,
+void SupervisedUserTestBase::JSSetTextField(const std::string& element_selector,
                                          const std::string& value) {
   std::string function =
       StringPrintf("document.querySelector('%s').value = '%s'",
                    element_selector.c_str(),
                    value.c_str());
   JSEval(function);
 }
 
-void ManagedUserTestBase::PrepareUsers() {
+void SupervisedUserTestBase::PrepareUsers() {
   RegisterUser(kTestManager);
   RegisterUser(kTestOtherUser);
   chromeos::StartupUtils::MarkOobeCompleted();
 }
 
-void ManagedUserTestBase::StartFlowLoginAsManager() {
+void SupervisedUserTestBase::StartFlowLoginAsManager() {
   // Navigate to supervised user creation screen.
   JSEval("chrome.send('showLocallyManagedUserCreationScreen')");
 
   // Read intro and proceed.
   JSExpect(StringPrintf("%s == 'intro'", kCurrentPage));
 
   JSEval("$('managed-user-creation-start-button').click()");
 
   // Check that both users appear as managers, and test-manager@gmail.com is
   // the first one.
@@ skipping 42 matching lines @@
 
   // OAuth token is valid.
   UserManager::Get()->SaveUserOAuthStatus(kTestManager,
                                           User::OAUTH2_TOKEN_STATUS_VALID);
   base::RunLoop().RunUntilIdle();
 
   // Check the page have changed.
   JSExpect(StringPrintf("%s == 'username'", kCurrentPage));
 }
 
-void ManagedUserTestBase::FillNewUserData(const std::string& display_name) {
+void SupervisedUserTestBase::FillNewUserData(const std::string& display_name) {
   JSExpect("$('managed-user-creation-next-button').disabled");
   JSSetTextField("#managed-user-creation-name", display_name);
   JSEval("$('managed-user-creation').checkUserName_()");
 
   base::RunLoop().RunUntilIdle();
 
   JSSetTextField("#managed-user-creation-password",
                  kTestSupervisedUserPassword);
   JSSetTextField("#managed-user-creation-password-confirm",
                  kTestSupervisedUserPassword);
 
   JSEval("$('managed-user-creation').updateNextButtonForUser_()");
   JSExpect("!$('managed-user-creation-next-button').disabled");
 }
 
-void ManagedUserTestBase::StartUserCreation(
+void SupervisedUserTestBase::StartUserCreation(
     const std::string& button_id,
     const std::string& expected_display_name) {
   EXPECT_CALL(*mock_homedir_methods_, MountEx(_, _, _, _)).Times(1);
   EXPECT_CALL(*mock_homedir_methods_, AddKeyEx(_, _, _, _, _)).Times(1);
 
   JSEval(std::string("$('").append(button_id).append("').click()"));
 
   ::testing::Mock::VerifyAndClearExpectations(mock_homedir_methods_);
 
   EXPECT_TRUE(registration_utility_stub_->register_was_called());
   EXPECT_EQ(registration_utility_stub_->display_name(),
             base::UTF8ToUTF16(expected_display_name));
 
   registration_utility_stub_->RunSuccessCallback("token");
 
   // Token writing moves control to BlockingPool and back.
   base::RunLoop().RunUntilIdle();
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
 
   JSExpect(StringPrintf("%s == 'created'", kCurrentPage));
   JSEval("$('managed-user-creation-gotit-button').click()");
 }
 
-void ManagedUserTestBase::SigninAsSupervisedUser(
+void SupervisedUserTestBase::SigninAsSupervisedUser(
     bool check_homedir_calls,
     int user_index,
     const std::string& expected_display_name) {
   if (check_homedir_calls)
     EXPECT_CALL(*mock_homedir_methods_, MountEx(_, _, _, _)).Times(1);
 
   // Log in as supervised user, make sure that everything works.
   ASSERT_EQ(3UL, UserManager::Get()->GetUsers().size());
 
   // Created supervised user have to be first in a list.
   const User* user = UserManager::Get()->GetUsers().at(user_index);
   ASSERT_EQ(base::UTF8ToUTF16(expected_display_name), user->display_name());
   LoginUser(user->email());
   if (check_homedir_calls)
     ::testing::Mock::VerifyAndClearExpectations(mock_homedir_methods_);
   Profile* profile = ProfileHelper::Get()->GetProfileByUser(user);
   shared_settings_adapter_.reset(
-      new ManagedUsersSharedSettingsSyncTestAdapter(profile));
+      new SupervisedUsersSharedSettingsSyncTestAdapter(profile));
 
   // Check ChromeOS preference is initialized.
   EXPECT_TRUE(
       static_cast<ProfileImpl*>(profile)->chromeos_preferences_);
 }
 
-void ManagedUserTestBase::SigninAsManager(int user_index) {
+void SupervisedUserTestBase::SigninAsManager(int user_index) {
   // Log in as supervised user, make sure that everything works.
   ASSERT_EQ(3UL, UserManager::Get()->GetUsers().size());
 
   // Created supervised user have to be first in a list.
   const User* user = UserManager::Get()->GetUsers().at(user_index);
   LoginUser(user->email());
   Profile* profile = ProfileHelper::Get()->GetProfileByUser(user);
   shared_settings_adapter_.reset(
-      new ManagedUsersSharedSettingsSyncTestAdapter(profile));
-  managed_users_adapter_.reset(new ManagedUsersSyncTestAdapter(profile));
+      new SupervisedUsersSharedSettingsSyncTestAdapter(profile));
+  supervised_users_adapter_.reset(new SupervisedUsersSyncTestAdapter(profile));
 }
 
-void ManagedUserTestBase::RemoveSupervisedUser(
+void SupervisedUserTestBase::RemoveSupervisedUser(
     unsigned long original_user_count,
     int user_index,
     const std::string& expected_display_name) {
   // Remove supervised user.
   ASSERT_EQ(original_user_count, UserManager::Get()->GetUsers().size());
 
   // Created supervised user have to be first in a list.
   const User* user = UserManager::Get()->GetUsers().at(user_index);
   ASSERT_EQ(base::UTF8ToUTF16(expected_display_name), user->display_name());
 
@@ skipping 22 matching lines @@
   // Confirm deletion.
   JSEval(StringPrintf(
       "$('pod-row').pods[%d].querySelector('.remove-warning-button').click()",
       user_index));
 
   // Make sure there is no supervised user in list.
   ASSERT_EQ(original_user_count - 1, UserManager::Get()->GetUsers().size());
 }
 
 }  // namespace chromeos