chrome/browser/chromeos/ownership/owner_settings_service_chromeos_unittest.cc - chromium/src - Git at Google

 // 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 <queue>
 #include <utility>

 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/test/scoped_path_override.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos_factory.h"
 #include "chrome/browser/chromeos/settings/device_settings_provider.h"
 #include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/scoped_testing_local_state.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace em = enterprise_management;

 namespace chromeos {

 namespace {

 void OnPrefChanged(const std::string& /* setting */) {
 }

 class PrefsChecker : public ownership::OwnerSettingsService::Observer {
  public:
   PrefsChecker(OwnerSettingsServiceChromeOS* service,
                DeviceSettingsProvider* provider)
       : service_(service), provider_(provider) {
     CHECK(service_);
     CHECK(provider_);
     service_->AddObserver(this);
   }

   ~PrefsChecker() override { service_->RemoveObserver(this); }

   // OwnerSettingsService::Observer implementation:
   void OnSignedPolicyStored(bool success) override {
     if (service_->HasPendingChanges())
       return;

     while (!set_requests_.empty()) {
       SetRequest request = set_requests_.front();
       set_requests_.pop();
       const base::Value* value = provider_->Get(request.first);
       ASSERT_TRUE(request.second->Equals(value));
     }
     loop_.Quit();
   }

   bool Set(const std::string& setting, const base::Value& value) {
     if (!service_->Set(setting, value))
       return false;
     set_requests_.push(
         SetRequest(setting, linked_ptr<base::Value>(value.DeepCopy())));
     return true;
   }

   void Wait() { loop_.Run(); }

  private:
   OwnerSettingsServiceChromeOS* service_;
   DeviceSettingsProvider* provider_;
   base::RunLoop loop_;

   typedef std::pair<std::string, linked_ptr<base::Value>> SetRequest;
   std::queue<SetRequest> set_requests_;

   DISALLOW_COPY_AND_ASSIGN(PrefsChecker);
 };

 bool FindInListValue(const std::string& needle, const base::Value* haystack) {
   const base::ListValue* list;
   if (!haystack->GetAsList(&list))
     return false;
   return list->end() != list->Find(base::StringValue(needle));
 }

 }  // namespace

 class OwnerSettingsServiceChromeOSTest : public DeviceSettingsTestBase {
  public:
   OwnerSettingsServiceChromeOSTest()
       : service_(nullptr),
         local_state_(TestingBrowserProcess::GetGlobal()),
         user_data_dir_override_(chrome::DIR_USER_DATA),
         management_settings_set_(false) {}

   void SetUp() override {
     DeviceSettingsTestBase::SetUp();
     provider_.reset(new DeviceSettingsProvider(base::Bind(&OnPrefChanged),
                                                &device_settings_service_));
     owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
     InitOwner(AccountId::FromUserEmail(device_policy_.policy_data().username()),
               true);
     FlushDeviceSettings();

     service_ = OwnerSettingsServiceChromeOSFactory::GetForBrowserContext(
         profile_.get());
     ASSERT_TRUE(service_);
     ASSERT_TRUE(service_->IsOwner());

     device_policy_.policy_data().set_management_mode(
         em::PolicyData::LOCAL_OWNER);
     device_policy_.Build();
     device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
     ReloadDeviceSettings();
   }

   void TearDown() override { DeviceSettingsTestBase::TearDown(); }

   void TestSingleSet(OwnerSettingsServiceChromeOS* service,
                      const std::string& setting,
                      const base::Value& in_value) {
     PrefsChecker checker(service, provider_.get());
     checker.Set(setting, in_value);
     FlushDeviceSettings();
     checker.Wait();
   }

   void OnManagementSettingsSet(bool success) {
     management_settings_set_ = success;
   }

  protected:
   OwnerSettingsServiceChromeOS* service_;
   ScopedTestingLocalState local_state_;
   scoped_ptr<DeviceSettingsProvider> provider_;
   base::ScopedPathOverride user_data_dir_override_;
   bool management_settings_set_;

  private:
   DISALLOW_COPY_AND_ASSIGN(OwnerSettingsServiceChromeOSTest);
 };

 TEST_F(OwnerSettingsServiceChromeOSTest, SingleSetTest) {
   TestSingleSet(service_, kReleaseChannel, base::StringValue("dev-channel"));
   TestSingleSet(service_, kReleaseChannel, base::StringValue("beta-channel"));
   TestSingleSet(service_, kReleaseChannel, base::StringValue("stable-channel"));
 }

 TEST_F(OwnerSettingsServiceChromeOSTest, MultipleSetTest) {
   base::FundamentalValue allow_guest(false);
   base::StringValue release_channel("stable-channel");
   base::FundamentalValue show_user_names(true);

   PrefsChecker checker(service_, provider_.get());

   checker.Set(kAccountsPrefAllowGuest, allow_guest);
   checker.Set(kReleaseChannel, release_channel);
   checker.Set(kAccountsPrefShowUserNamesOnSignIn, show_user_names);

   FlushDeviceSettings();
   checker.Wait();
 }

 TEST_F(OwnerSettingsServiceChromeOSTest, FailedSetRequest) {
   device_settings_test_helper_.set_store_result(false);
   std::string current_channel;
   ASSERT_TRUE(provider_->Get(kReleaseChannel)->GetAsString(&current_channel));
   ASSERT_NE(current_channel, "stable-channel");

   // Check that DeviceSettingsProvider's cache is updated.
   PrefsChecker checker(service_, provider_.get());
   checker.Set(kReleaseChannel, base::StringValue("stable-channel"));
   FlushDeviceSettings();
   checker.Wait();

   // Check that DeviceSettingsService's policy isn't updated.
   ASSERT_EQ(current_channel, device_settings_service_.device_settings()
                                  ->release_channel()
                                  .release_channel());
 }

 TEST_F(OwnerSettingsServiceChromeOSTest, SetManagementSettingsModeTransition) {
   ReloadDeviceSettings();
   EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
             device_settings_service_.status());

   // The initial management mode should be LOCAL_OWNER.
   EXPECT_TRUE(device_settings_service_.policy_data()->has_management_mode());
   EXPECT_EQ(em::PolicyData::LOCAL_OWNER,
             device_settings_service_.policy_data()->management_mode());

   OwnerSettingsServiceChromeOS::ManagementSettings management_settings;
   management_settings.management_mode =
       policy::MANAGEMENT_MODE_CONSUMER_MANAGED;
   management_settings.request_token = "fake_request_token";
   management_settings.device_id = "fake_device_id";
   OwnerSettingsServiceChromeOS::OnManagementSettingsSetCallback
       on_management_settings_set_callback =
           base::Bind(&OwnerSettingsServiceChromeOSTest::OnManagementSettingsSet,
                      base::Unretained(this));

   // LOCAL_OWNER -> CONSUMER_MANAGED: Okay.
   service_->SetManagementSettings(management_settings,
                                   on_management_settings_set_callback);
   FlushDeviceSettings();

   EXPECT_TRUE(management_settings_set_);
   EXPECT_EQ(em::PolicyData::CONSUMER_MANAGED,
             device_settings_service_.policy_data()->management_mode());

   // CONSUMER_MANAGED -> ENTERPRISE_MANAGED: Invalid.
   management_settings.management_mode =
       policy::MANAGEMENT_MODE_ENTERPRISE_MANAGED;
   service_->SetManagementSettings(management_settings,
                                   on_management_settings_set_callback);
   FlushDeviceSettings();

   EXPECT_FALSE(management_settings_set_);
   EXPECT_EQ(em::PolicyData::CONSUMER_MANAGED,
             device_settings_service_.policy_data()->management_mode());

   // CONSUMER_MANAGED -> LOCAL_OWNER: Okay.
   management_settings.management_mode = policy::MANAGEMENT_MODE_LOCAL_OWNER;
   service_->SetManagementSettings(management_settings,
                                   on_management_settings_set_callback);
   FlushDeviceSettings();

   EXPECT_TRUE(management_settings_set_);
   EXPECT_EQ(em::PolicyData::LOCAL_OWNER,
             device_settings_service_.policy_data()->management_mode());

   // LOCAL_OWNER -> ENTERPRISE_MANAGED: Invalid.
   management_settings.management_mode =
       policy::MANAGEMENT_MODE_ENTERPRISE_MANAGED;
   service_->SetManagementSettings(management_settings,
                                   on_management_settings_set_callback);
   FlushDeviceSettings();

   EXPECT_FALSE(management_settings_set_);
   EXPECT_EQ(em::PolicyData::LOCAL_OWNER,
             device_settings_service_.policy_data()->management_mode());

   // Inject a policy data with management mode set to ENTERPRISE_MANAGED.
   device_policy_.policy_data().set_management_mode(
       em::PolicyData::ENTERPRISE_MANAGED);
   device_policy_.Build();
   device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
   ReloadDeviceSettings();
   EXPECT_EQ(em::PolicyData::ENTERPRISE_MANAGED,
             device_settings_service_.policy_data()->management_mode());

   // ENTERPRISE_MANAGED -> LOCAL_OWNER: Invalid.
   management_settings.management_mode = policy::MANAGEMENT_MODE_LOCAL_OWNER;
   service_->SetManagementSettings(management_settings,
                                   on_management_settings_set_callback);
   FlushDeviceSettings();

   EXPECT_FALSE(management_settings_set_);
   EXPECT_EQ(em::PolicyData::ENTERPRISE_MANAGED,
             device_settings_service_.policy_data()->management_mode());

   // ENTERPRISE_MANAGED -> CONSUMER_MANAGED: Invalid.
   management_settings.management_mode =
       policy::MANAGEMENT_MODE_CONSUMER_MANAGED;
   service_->SetManagementSettings(management_settings,
                                   on_management_settings_set_callback);
   FlushDeviceSettings();

   EXPECT_FALSE(management_settings_set_);
   EXPECT_EQ(em::PolicyData::ENTERPRISE_MANAGED,
             device_settings_service_.policy_data()->management_mode());
 }

 TEST_F(OwnerSettingsServiceChromeOSTest, SetManagementSettingsSuccess) {
   ReloadDeviceSettings();
   EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
             device_settings_service_.status());

   OwnerSettingsServiceChromeOS::ManagementSettings management_settings;
   management_settings.management_mode =
       policy::MANAGEMENT_MODE_CONSUMER_MANAGED;
   management_settings.request_token = "fake_request_token";
   management_settings.device_id = "fake_device_id";
   service_->SetManagementSettings(
       management_settings,
       base::Bind(&OwnerSettingsServiceChromeOSTest::OnManagementSettingsSet,
                  base::Unretained(this)));
   FlushDeviceSettings();

   EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
             device_settings_service_.status());
   ASSERT_TRUE(device_settings_service_.device_settings());

   // Check that the loaded policy_data contains the expected values.
   const em::PolicyData* policy_data = device_settings_service_.policy_data();
   EXPECT_EQ(policy::dm_protocol::kChromeDevicePolicyType,
             policy_data->policy_type());
   EXPECT_EQ(device_settings_service_.GetUsername(), policy_data->username());
   EXPECT_EQ(em::PolicyData::CONSUMER_MANAGED, policy_data->management_mode());
   EXPECT_EQ("fake_request_token", policy_data->request_token());
   EXPECT_EQ("fake_device_id", policy_data->device_id());
 }

 TEST_F(OwnerSettingsServiceChromeOSTest, ForceWhitelist) {
   EXPECT_FALSE(FindInListValue(device_policy_.policy_data().username(),
                                provider_->Get(kAccountsPrefUsers)));
   // Force a settings write.
   TestSingleSet(service_, kReleaseChannel, base::StringValue("dev-channel"));
   EXPECT_TRUE(FindInListValue(device_policy_.policy_data().username(),
                               provider_->Get(kAccountsPrefUsers)));
 }

 class OwnerSettingsServiceChromeOSNoOwnerTest
     : public OwnerSettingsServiceChromeOSTest {
  public:
   OwnerSettingsServiceChromeOSNoOwnerTest() {}
   ~OwnerSettingsServiceChromeOSNoOwnerTest() override {}

   void SetUp() override {
     DeviceSettingsTestBase::SetUp();
     provider_.reset(new DeviceSettingsProvider(base::Bind(&OnPrefChanged),
                                                &device_settings_service_));
     FlushDeviceSettings();
     service_ = OwnerSettingsServiceChromeOSFactory::GetForBrowserContext(
         profile_.get());
     ASSERT_TRUE(service_);
     ASSERT_FALSE(service_->IsOwner());
   }

   void TearDown() override { DeviceSettingsTestBase::TearDown(); }

  private:
   DISALLOW_COPY_AND_ASSIGN(OwnerSettingsServiceChromeOSNoOwnerTest);
 };

 TEST_F(OwnerSettingsServiceChromeOSNoOwnerTest, SingleSetTest) {
   ASSERT_FALSE(service_->SetBoolean(kAccountsPrefAllowGuest, false));
 }

 TEST_F(OwnerSettingsServiceChromeOSNoOwnerTest, TakeOwnershipForceWhitelist) {
   EXPECT_FALSE(FindInListValue(device_policy_.policy_data().username(),
                                provider_->Get(kAccountsPrefUsers)));
   owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
   InitOwner(AccountId::FromUserEmail(device_policy_.policy_data().username()),
             true);
   ReloadDeviceSettings();
   ASSERT_TRUE(service_->IsOwner());

   EXPECT_TRUE(FindInListValue(device_policy_.policy_data().username(),
                               provider_->Get(kAccountsPrefUsers)));
 }

 }  // namespace chromeos
	// 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 <queue>
	#include <utility>

	#include "base/macros.h"
	#include "base/memory/linked_ptr.h"
	#include "base/memory/scoped_ptr.h"
	#include "base/run_loop.h"
	#include "base/test/scoped_path_override.h"
	#include "base/values.h"
	#include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos.h"
	#include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos_factory.h"
	#include "chrome/browser/chromeos/settings/device_settings_provider.h"
	#include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
	#include "chrome/common/chrome_paths.h"
	#include "chrome/test/base/scoped_testing_local_state.h"
	#include "chrome/test/base/testing_browser_process.h"
	#include "chrome/test/base/testing_profile.h"
	#include "chromeos/settings/cros_settings_names.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace em = enterprise_management;

	namespace chromeos {

	namespace {

	void OnPrefChanged(const std::string& /* setting */) {
	}

	class PrefsChecker : public ownership::OwnerSettingsService::Observer {
	public:
	PrefsChecker(OwnerSettingsServiceChromeOS* service,
	DeviceSettingsProvider* provider)
	: service_(service), provider_(provider) {
	CHECK(service_);
	CHECK(provider_);
	service_->AddObserver(this);
	}

	~PrefsChecker() override { service_->RemoveObserver(this); }

	// OwnerSettingsService::Observer implementation:
	void OnSignedPolicyStored(bool success) override {
	if (service_->HasPendingChanges())
	return;

	while (!set_requests_.empty()) {
	SetRequest request = set_requests_.front();
	set_requests_.pop();
	const base::Value* value = provider_->Get(request.first);
	ASSERT_TRUE(request.second->Equals(value));
	}
	loop_.Quit();
	}

	bool Set(const std::string& setting, const base::Value& value) {
	if (!service_->Set(setting, value))
	return false;
	set_requests_.push(
	SetRequest(setting, linked_ptr<base::Value>(value.DeepCopy())));
	return true;
	}

	void Wait() { loop_.Run(); }

	private:
	OwnerSettingsServiceChromeOS* service_;
	DeviceSettingsProvider* provider_;
	base::RunLoop loop_;

	typedef std::pair<std::string, linked_ptr<base::Value>> SetRequest;
	std::queue<SetRequest> set_requests_;

	DISALLOW_COPY_AND_ASSIGN(PrefsChecker);
	};

	bool FindInListValue(const std::string& needle, const base::Value* haystack) {
	const base::ListValue* list;
	if (!haystack->GetAsList(&list))
	return false;
	return list->end() != list->Find(base::StringValue(needle));
	}

	} // namespace

	class OwnerSettingsServiceChromeOSTest : public DeviceSettingsTestBase {
	public:
	OwnerSettingsServiceChromeOSTest()
	: service_(nullptr),
	local_state_(TestingBrowserProcess::GetGlobal()),
	user_data_dir_override_(chrome::DIR_USER_DATA),
	management_settings_set_(false) {}

	void SetUp() override {
	DeviceSettingsTestBase::SetUp();
	provider_.reset(new DeviceSettingsProvider(base::Bind(&OnPrefChanged),
	&device_settings_service_));
	owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
	InitOwner(AccountId::FromUserEmail(device_policy_.policy_data().username()),
	true);
	FlushDeviceSettings();

	service_ = OwnerSettingsServiceChromeOSFactory::GetForBrowserContext(
	profile_.get());
	ASSERT_TRUE(service_);
	ASSERT_TRUE(service_->IsOwner());

	device_policy_.policy_data().set_management_mode(
	em::PolicyData::LOCAL_OWNER);
	device_policy_.Build();
	device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
	ReloadDeviceSettings();
	}

	void TearDown() override { DeviceSettingsTestBase::TearDown(); }

	void TestSingleSet(OwnerSettingsServiceChromeOS* service,
	const std::string& setting,
	const base::Value& in_value) {
	PrefsChecker checker(service, provider_.get());
	checker.Set(setting, in_value);
	FlushDeviceSettings();
	checker.Wait();
	}

	void OnManagementSettingsSet(bool success) {
	management_settings_set_ = success;
	}

	protected:
	OwnerSettingsServiceChromeOS* service_;
	ScopedTestingLocalState local_state_;
	scoped_ptr<DeviceSettingsProvider> provider_;
	base::ScopedPathOverride user_data_dir_override_;
	bool management_settings_set_;

	private:
	DISALLOW_COPY_AND_ASSIGN(OwnerSettingsServiceChromeOSTest);
	};

	TEST_F(OwnerSettingsServiceChromeOSTest, SingleSetTest) {
	TestSingleSet(service_, kReleaseChannel, base::StringValue("dev-channel"));
	TestSingleSet(service_, kReleaseChannel, base::StringValue("beta-channel"));
	TestSingleSet(service_, kReleaseChannel, base::StringValue("stable-channel"));
	}

	TEST_F(OwnerSettingsServiceChromeOSTest, MultipleSetTest) {
	base::FundamentalValue allow_guest(false);
	base::StringValue release_channel("stable-channel");
	base::FundamentalValue show_user_names(true);

	PrefsChecker checker(service_, provider_.get());

	checker.Set(kAccountsPrefAllowGuest, allow_guest);
	checker.Set(kReleaseChannel, release_channel);
	checker.Set(kAccountsPrefShowUserNamesOnSignIn, show_user_names);

	FlushDeviceSettings();
	checker.Wait();
	}

	TEST_F(OwnerSettingsServiceChromeOSTest, FailedSetRequest) {
	device_settings_test_helper_.set_store_result(false);
	std::string current_channel;
	ASSERT_TRUE(provider_->Get(kReleaseChannel)->GetAsString(&current_channel));
	ASSERT_NE(current_channel, "stable-channel");

	// Check that DeviceSettingsProvider's cache is updated.
	PrefsChecker checker(service_, provider_.get());
	checker.Set(kReleaseChannel, base::StringValue("stable-channel"));
	FlushDeviceSettings();
	checker.Wait();

	// Check that DeviceSettingsService's policy isn't updated.
	ASSERT_EQ(current_channel, device_settings_service_.device_settings()
	->release_channel()
	.release_channel());
	}

	TEST_F(OwnerSettingsServiceChromeOSTest, SetManagementSettingsModeTransition) {
	ReloadDeviceSettings();
	EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
	device_settings_service_.status());

	// The initial management mode should be LOCAL_OWNER.
	EXPECT_TRUE(device_settings_service_.policy_data()->has_management_mode());
	EXPECT_EQ(em::PolicyData::LOCAL_OWNER,
	device_settings_service_.policy_data()->management_mode());

	OwnerSettingsServiceChromeOS::ManagementSettings management_settings;
	management_settings.management_mode =
	policy::MANAGEMENT_MODE_CONSUMER_MANAGED;
	management_settings.request_token = "fake_request_token";
	management_settings.device_id = "fake_device_id";
	OwnerSettingsServiceChromeOS::OnManagementSettingsSetCallback
	on_management_settings_set_callback =
	base::Bind(&OwnerSettingsServiceChromeOSTest::OnManagementSettingsSet,
	base::Unretained(this));

	// LOCAL_OWNER -> CONSUMER_MANAGED: Okay.
	service_->SetManagementSettings(management_settings,
	on_management_settings_set_callback);
	FlushDeviceSettings();

	EXPECT_TRUE(management_settings_set_);
	EXPECT_EQ(em::PolicyData::CONSUMER_MANAGED,
	device_settings_service_.policy_data()->management_mode());

	// CONSUMER_MANAGED -> ENTERPRISE_MANAGED: Invalid.
	management_settings.management_mode =
	policy::MANAGEMENT_MODE_ENTERPRISE_MANAGED;
	service_->SetManagementSettings(management_settings,
	on_management_settings_set_callback);
	FlushDeviceSettings();

	EXPECT_FALSE(management_settings_set_);
	EXPECT_EQ(em::PolicyData::CONSUMER_MANAGED,
	device_settings_service_.policy_data()->management_mode());

	// CONSUMER_MANAGED -> LOCAL_OWNER: Okay.
	management_settings.management_mode = policy::MANAGEMENT_MODE_LOCAL_OWNER;
	service_->SetManagementSettings(management_settings,
	on_management_settings_set_callback);
	FlushDeviceSettings();

	EXPECT_TRUE(management_settings_set_);
	EXPECT_EQ(em::PolicyData::LOCAL_OWNER,
	device_settings_service_.policy_data()->management_mode());

	// LOCAL_OWNER -> ENTERPRISE_MANAGED: Invalid.
	management_settings.management_mode =
	policy::MANAGEMENT_MODE_ENTERPRISE_MANAGED;
	service_->SetManagementSettings(management_settings,
	on_management_settings_set_callback);
	FlushDeviceSettings();

	EXPECT_FALSE(management_settings_set_);
	EXPECT_EQ(em::PolicyData::LOCAL_OWNER,
	device_settings_service_.policy_data()->management_mode());

	// Inject a policy data with management mode set to ENTERPRISE_MANAGED.
	device_policy_.policy_data().set_management_mode(
	em::PolicyData::ENTERPRISE_MANAGED);
	device_policy_.Build();
	device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
	ReloadDeviceSettings();
	EXPECT_EQ(em::PolicyData::ENTERPRISE_MANAGED,
	device_settings_service_.policy_data()->management_mode());

	// ENTERPRISE_MANAGED -> LOCAL_OWNER: Invalid.
	management_settings.management_mode = policy::MANAGEMENT_MODE_LOCAL_OWNER;
	service_->SetManagementSettings(management_settings,
	on_management_settings_set_callback);
	FlushDeviceSettings();

	EXPECT_FALSE(management_settings_set_);
	EXPECT_EQ(em::PolicyData::ENTERPRISE_MANAGED,
	device_settings_service_.policy_data()->management_mode());

	// ENTERPRISE_MANAGED -> CONSUMER_MANAGED: Invalid.
	management_settings.management_mode =
	policy::MANAGEMENT_MODE_CONSUMER_MANAGED;
	service_->SetManagementSettings(management_settings,
	on_management_settings_set_callback);
	FlushDeviceSettings();

	EXPECT_FALSE(management_settings_set_);
	EXPECT_EQ(em::PolicyData::ENTERPRISE_MANAGED,
	device_settings_service_.policy_data()->management_mode());
	}

	TEST_F(OwnerSettingsServiceChromeOSTest, SetManagementSettingsSuccess) {
	ReloadDeviceSettings();
	EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
	device_settings_service_.status());

	OwnerSettingsServiceChromeOS::ManagementSettings management_settings;
	management_settings.management_mode =
	policy::MANAGEMENT_MODE_CONSUMER_MANAGED;
	management_settings.request_token = "fake_request_token";
	management_settings.device_id = "fake_device_id";
	service_->SetManagementSettings(
	management_settings,
	base::Bind(&OwnerSettingsServiceChromeOSTest::OnManagementSettingsSet,
	base::Unretained(this)));
	FlushDeviceSettings();

	EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS,
	device_settings_service_.status());
	ASSERT_TRUE(device_settings_service_.device_settings());

	// Check that the loaded policy_data contains the expected values.
	const em::PolicyData* policy_data = device_settings_service_.policy_data();
	EXPECT_EQ(policy::dm_protocol::kChromeDevicePolicyType,
	policy_data->policy_type());
	EXPECT_EQ(device_settings_service_.GetUsername(), policy_data->username());
	EXPECT_EQ(em::PolicyData::CONSUMER_MANAGED, policy_data->management_mode());
	EXPECT_EQ("fake_request_token", policy_data->request_token());
	EXPECT_EQ("fake_device_id", policy_data->device_id());
	}

	TEST_F(OwnerSettingsServiceChromeOSTest, ForceWhitelist) {
	EXPECT_FALSE(FindInListValue(device_policy_.policy_data().username(),
	provider_->Get(kAccountsPrefUsers)));
	// Force a settings write.
	TestSingleSet(service_, kReleaseChannel, base::StringValue("dev-channel"));
	EXPECT_TRUE(FindInListValue(device_policy_.policy_data().username(),
	provider_->Get(kAccountsPrefUsers)));
	}

	class OwnerSettingsServiceChromeOSNoOwnerTest
	: public OwnerSettingsServiceChromeOSTest {
	public:
	OwnerSettingsServiceChromeOSNoOwnerTest() {}
	~OwnerSettingsServiceChromeOSNoOwnerTest() override {}

	void SetUp() override {
	DeviceSettingsTestBase::SetUp();
	provider_.reset(new DeviceSettingsProvider(base::Bind(&OnPrefChanged),
	&device_settings_service_));
	FlushDeviceSettings();
	service_ = OwnerSettingsServiceChromeOSFactory::GetForBrowserContext(
	profile_.get());
	ASSERT_TRUE(service_);
	ASSERT_FALSE(service_->IsOwner());
	}

	void TearDown() override { DeviceSettingsTestBase::TearDown(); }

	private:
	DISALLOW_COPY_AND_ASSIGN(OwnerSettingsServiceChromeOSNoOwnerTest);
	};

	TEST_F(OwnerSettingsServiceChromeOSNoOwnerTest, SingleSetTest) {
	ASSERT_FALSE(service_->SetBoolean(kAccountsPrefAllowGuest, false));
	}

	TEST_F(OwnerSettingsServiceChromeOSNoOwnerTest, TakeOwnershipForceWhitelist) {
	EXPECT_FALSE(FindInListValue(device_policy_.policy_data().username(),
	provider_->Get(kAccountsPrefUsers)));
	owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
	InitOwner(AccountId::FromUserEmail(device_policy_.policy_data().username()),
	true);
	ReloadDeviceSettings();
	ASSERT_TRUE(service_->IsOwner());

	EXPECT_TRUE(FindInListValue(device_policy_.policy_data().username(),
	provider_->Get(kAccountsPrefUsers)));
	}

	} // namespace chromeos