Remove unused email from install attributes and add support for AD.

chrome/browser/chromeos/system/device_disabling_manager_unittest.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/system/device_disabling_manager.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 38 matching lines @@
 class DeviceDisablingManagerTestBase : public testing::Test,
                                        public DeviceDisablingManager::Delegate {
  public:
   DeviceDisablingManagerTestBase();
 
   // testing::Test:
   void TearDown() override;
 
   virtual void CreateDeviceDisablingManager();
   virtual void DestroyDeviceDisablingManager();
-
-  void UpdateInstallAttributes(const std::string& enrollment_domain,
-                               const std::string& registration_user,
-                               policy::DeviceMode device_mode);
   void LogIn();
 
   // DeviceDisablingManager::Delegate:
   MOCK_METHOD0(RestartToLoginScreen, void());
   MOCK_METHOD0(ShowDeviceDisabledScreen, void());
 
   DeviceDisablingManager* GetDeviceDisablingManager() {
     return device_disabling_manager_.get();
   }
 
+  // Configure install attributes.
+  void SetUnowned();
+  void SetEnterpriseOwned();
+  void SetConsumerOwned();
+
  private:
+  chromeos::StubInstallAttributes* GetInstallAttributes();
+
   chromeos::ScopedStubInstallAttributes install_attributes_;
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   user_manager::FakeUserManager fake_user_manager_;
   std::unique_ptr<DeviceDisablingManager> device_disabling_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceDisablingManagerTestBase);
 };
 
 DeviceDisablingManagerTestBase::DeviceDisablingManagerTestBase()
-    : install_attributes_("", "", "", policy::DEVICE_MODE_NOT_SET) {
+    : install_attributes_(ScopedStubInstallAttributes::CreateUnset()) {
 }
 
 void DeviceDisablingManagerTestBase::TearDown() {
   DestroyDeviceDisablingManager();
 }
 
 void DeviceDisablingManagerTestBase::CreateDeviceDisablingManager() {
   device_disabling_manager_.reset(new DeviceDisablingManager(
       this,
       CrosSettings::Get(),
       &fake_user_manager_));
 }
 
 void DeviceDisablingManagerTestBase::DestroyDeviceDisablingManager() {
   device_disabling_manager_.reset();
 }
 
-void DeviceDisablingManagerTestBase::UpdateInstallAttributes(
-    const std::string& enrollment_domain,
-    const std::string& registration_user,
-    policy::DeviceMode device_mode) {
-  chromeos::StubInstallAttributes* install_attributes =
-      static_cast<chromeos::StubInstallAttributes*>(
-          TestingBrowserProcess::GetGlobal()
-              ->platform_part()
-              ->browser_policy_connector_chromeos()
-              ->GetInstallAttributes());
-  install_attributes->SetDomain(enrollment_domain);
-  install_attributes->SetRegistrationUser(registration_user);
-  install_attributes->SetMode(device_mode);
-}
-
 void DeviceDisablingManagerTestBase::LogIn() {
   fake_user_manager_.AddUser(AccountId::FromUserEmail(kTestUser));
 }
 
+void DeviceDisablingManagerTestBase::SetUnowned() {
+  GetInstallAttributes()->Clear();
+}
+
+void DeviceDisablingManagerTestBase::SetEnterpriseOwned() {
+  GetInstallAttributes()->SetEnterprise(kEnrollmentDomain, "fake-id");
+}
+
+void DeviceDisablingManagerTestBase::SetConsumerOwned() {
+  GetInstallAttributes()->SetConsumer();
+}
+
+chromeos::StubInstallAttributes*
+DeviceDisablingManagerTestBase::GetInstallAttributes() {
+  return static_cast<chromeos::StubInstallAttributes*>(
+      TestingBrowserProcess::GetGlobal()
+      ->platform_part()
+      ->browser_policy_connector_chromeos()
+      ->GetInstallAttributes());
+}
+
 // Base class for tests that verify device disabling behavior during OOBE, when
 // the device is not owned yet.
 class DeviceDisablingManagerOOBETest : public DeviceDisablingManagerTestBase {
  public:
   DeviceDisablingManagerOOBETest();
 
   // DeviceDisablingManagerTestBase:
   void SetUp() override;
   void TearDown() override;
 
@@ skipping 78 matching lines @@
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kDisableDeviceDisabling);
   SetDeviceDisabled(true);
   CheckWhetherDeviceDisabledDuringOOBE();
   EXPECT_FALSE(device_disabled());
 }
 
 // Verifies that the device is not considered disabled during OOBE when it is
 // already enrolled, even if the device is marked as disabled.
 TEST_F(DeviceDisablingManagerOOBETest, NotDisabledWhenEnterpriseOwned) {
-  UpdateInstallAttributes(kEnrollmentDomain,
-                          kTestUser,
-                          policy::DEVICE_MODE_ENTERPRISE);
+  SetEnterpriseOwned();
   SetDeviceDisabled(true);
   CheckWhetherDeviceDisabledDuringOOBE();
   EXPECT_FALSE(device_disabled());
 }
 
 // Verifies that the device is not considered disabled during OOBE when it is
 // already owned by a consumer, even if the device is marked as disabled.
 TEST_F(DeviceDisablingManagerOOBETest, NotDisabledWhenConsumerOwned) {
-  UpdateInstallAttributes(std::string() /* enrollment_domain */,
-                          std::string() /* registration_user */,
-                          policy::DEVICE_MODE_CONSUMER);
+  SetConsumerOwned();
   SetDeviceDisabled(true);
   CheckWhetherDeviceDisabledDuringOOBE();
   EXPECT_FALSE(device_disabled());
 }
 
 // Verifies that the device is considered disabled during OOBE when it is marked
 // as disabled, device disabling is not turned off by flag and the device is not
 // owned yet.
 TEST_F(DeviceDisablingManagerOOBETest, ShowWhenDisabledAndNotOwned) {
   SetDeviceDisabled(true);
@@ skipping 12 matching lines @@
   DeviceDisablingManagerTest();
 
   // DeviceDisablingManagerTestBase:
   void TearDown() override;
   void CreateDeviceDisablingManager() override;
   void DestroyDeviceDisablingManager() override;
 
   // DeviceDisablingManager::Observer:
   MOCK_METHOD1(OnDisabledMessageChanged, void(const std::string&));
 
-  void SetUnowned();
-  void SetEnterpriseOwned();
-  void SetConsumerOwned();
   void MakeCrosSettingsTrusted();
 
   void SetDeviceDisabled(bool disabled);
   void SetDisabledMessage(const std::string& disabled_message);
 
  private:
   void SimulatePolicyFetch();
 
   content::TestBrowserThreadBundle thread_bundle_;
   chromeos::DeviceSettingsTestHelper device_settings_test_helper_;
@@ skipping 14 matching lines @@
   DeviceDisablingManagerTestBase::CreateDeviceDisablingManager();
   GetDeviceDisablingManager()->AddObserver(this);
 }
 
 void DeviceDisablingManagerTest::DestroyDeviceDisablingManager() {
   if (GetDeviceDisablingManager())
     GetDeviceDisablingManager()->RemoveObserver(this);
   DeviceDisablingManagerTestBase::DestroyDeviceDisablingManager();
 }
 
-void DeviceDisablingManagerTest::SetUnowned() {
-  UpdateInstallAttributes(std::string() /* enrollment_domain */,
-                          std::string() /* registration_user */,
-                          policy::DEVICE_MODE_NOT_SET);
-}
-
-void DeviceDisablingManagerTest::SetEnterpriseOwned() {
-  UpdateInstallAttributes(kEnrollmentDomain,
-                          kTestUser,
-                          policy::DEVICE_MODE_ENTERPRISE);
-}
-
-void DeviceDisablingManagerTest::SetConsumerOwned() {
-  UpdateInstallAttributes(std::string() /* enrollment_domain */,
-                          std::string() /* registration_user */,
-                          policy::DEVICE_MODE_CONSUMER);
-}
-
 void DeviceDisablingManagerTest::MakeCrosSettingsTrusted() {
   scoped_refptr<ownership::MockOwnerKeyUtil> owner_key_util(
       new ownership::MockOwnerKeyUtil);
   owner_key_util->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
   chromeos::DeviceSettingsService::Get()->SetSessionManager(
       &device_settings_test_helper_,
       owner_key_util);
   SimulatePolicyFetch();
 }
 
@@ skipping 180 matching lines @@
       DeviceDisablingManager::HonorDeviceDisablingDuringNormalOperation());
 
   // Not enterprise owned, disabled by flag.
   SetUnowned();
   EXPECT_FALSE(
       DeviceDisablingManager::HonorDeviceDisablingDuringNormalOperation());
 }
 
 }  // namespace system
 }  // namespace chromeos