| // 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/chromeos/settings/device_settings_service.h" |
| |
| #include "base/basictypes.h" |
| #include "base/bind.h" |
| #include "base/bind_helpers.h" |
| #include "base/compiler_specific.h" |
| #include "chrome/browser/chromeos/settings/device_settings_test_helper.h" |
| #include "chrome/browser/policy/proto/chromeos/chrome_device_policy.pb.h" |
| #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace em = enterprise_management; |
| |
| using ::testing::Mock; |
| |
| namespace chromeos { |
| |
| namespace { |
| |
| class MockDeviceSettingsObserver : public DeviceSettingsService::Observer { |
| public: |
| virtual ~MockDeviceSettingsObserver() {} |
| |
| MOCK_METHOD0(OwnershipStatusChanged, void()); |
| MOCK_METHOD0(DeviceSettingsUpdated, void()); |
| }; |
| |
| } // namespace |
| |
| class DeviceSettingsServiceTest : public DeviceSettingsTestBase { |
| public: |
| void SetOperationCompleted() { |
| operation_completed_ = true; |
| } |
| |
| void SetOwnershipStatus( |
| DeviceSettingsService::OwnershipStatus ownership_status) { |
| ownership_status_ = ownership_status; |
| } |
| |
| void OnIsOwner(bool is_owner) { |
| is_owner_ = is_owner; |
| is_owner_set_ = true; |
| } |
| |
| protected: |
| DeviceSettingsServiceTest() |
| : operation_completed_(false), |
| is_owner_(true), |
| is_owner_set_(false), |
| ownership_status_(DeviceSettingsService::OWNERSHIP_UNKNOWN) {} |
| |
| virtual void SetUp() OVERRIDE { |
| device_policy_.payload().mutable_device_policy_refresh_rate()-> |
| set_device_policy_refresh_rate(120); |
| DeviceSettingsTestBase::SetUp(); |
| } |
| |
| void CheckPolicy() { |
| ASSERT_TRUE(device_settings_service_.policy_data()); |
| EXPECT_EQ(device_policy_.policy_data().SerializeAsString(), |
| device_settings_service_.policy_data()->SerializeAsString()); |
| ASSERT_TRUE(device_settings_service_.device_settings()); |
| EXPECT_EQ(device_policy_.payload().SerializeAsString(), |
| device_settings_service_.device_settings()->SerializeAsString()); |
| } |
| |
| bool operation_completed_; |
| bool is_owner_; |
| bool is_owner_set_; |
| DeviceSettingsService::OwnershipStatus ownership_status_; |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(DeviceSettingsServiceTest); |
| }; |
| |
| TEST_F(DeviceSettingsServiceTest, LoadNoKey) { |
| owner_key_util_->Clear(); |
| ReloadDeviceSettings(); |
| |
| EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE, |
| device_settings_service_.status()); |
| EXPECT_FALSE(device_settings_service_.policy_data()); |
| EXPECT_FALSE(device_settings_service_.device_settings()); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, LoadNoPolicy) { |
| device_settings_test_helper_.set_policy_blob(std::string()); |
| ReloadDeviceSettings(); |
| |
| EXPECT_EQ(DeviceSettingsService::STORE_NO_POLICY, |
| device_settings_service_.status()); |
| EXPECT_FALSE(device_settings_service_.policy_data()); |
| EXPECT_FALSE(device_settings_service_.device_settings()); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, LoadValidationError) { |
| device_policy_.policy().set_policy_data_signature("bad"); |
| device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob()); |
| owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey()); |
| ReloadDeviceSettings(); |
| |
| EXPECT_EQ(DeviceSettingsService::STORE_VALIDATION_ERROR, |
| device_settings_service_.status()); |
| EXPECT_FALSE(device_settings_service_.policy_data()); |
| EXPECT_FALSE(device_settings_service_.device_settings()); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, LoadValidationErrorFutureTimestamp) { |
| base::Time timestamp(base::Time::NowFromSystemTime() + |
| base::TimeDelta::FromDays(5000)); |
| device_policy_.policy_data().set_timestamp( |
| (timestamp - base::Time::UnixEpoch()).InMilliseconds()); |
| device_policy_.Build(); |
| device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob()); |
| owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey()); |
| ReloadDeviceSettings(); |
| |
| EXPECT_EQ(DeviceSettingsService::STORE_TEMP_VALIDATION_ERROR, |
| device_settings_service_.status()); |
| EXPECT_FALSE(device_settings_service_.policy_data()); |
| EXPECT_FALSE(device_settings_service_.device_settings()); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, LoadSuccess) { |
| ReloadDeviceSettings(); |
| |
| EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS, |
| device_settings_service_.status()); |
| CheckPolicy(); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, SignAndStoreNoKey) { |
| ReloadDeviceSettings(); |
| EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS, |
| device_settings_service_.status()); |
| |
| scoped_ptr<em::ChromeDeviceSettingsProto> new_device_settings( |
| new em::ChromeDeviceSettingsProto(device_policy_.payload())); |
| new_device_settings->mutable_device_policy_refresh_rate()-> |
| set_device_policy_refresh_rate(300); |
| device_settings_service_.SignAndStore( |
| new_device_settings.Pass(), |
| base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted, |
| base::Unretained(this))); |
| FlushDeviceSettings(); |
| EXPECT_TRUE(operation_completed_); |
| EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE, |
| device_settings_service_.status()); |
| CheckPolicy(); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, SignAndStoreFailure) { |
| ReloadDeviceSettings(); |
| EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS, |
| device_settings_service_.status()); |
| |
| owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey()); |
| device_settings_service_.SetUsername(device_policy_.policy_data().username()); |
| FlushDeviceSettings(); |
| |
| scoped_ptr<em::ChromeDeviceSettingsProto> new_device_settings( |
| new em::ChromeDeviceSettingsProto(device_policy_.payload())); |
| new_device_settings->mutable_device_policy_refresh_rate()-> |
| set_device_policy_refresh_rate(300); |
| device_settings_test_helper_.set_store_result(false); |
| device_settings_service_.SignAndStore( |
| new_device_settings.Pass(), |
| base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted, |
| base::Unretained(this))); |
| FlushDeviceSettings(); |
| EXPECT_TRUE(operation_completed_); |
| EXPECT_EQ(DeviceSettingsService::STORE_OPERATION_FAILED, |
| device_settings_service_.status()); |
| CheckPolicy(); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, SignAndStoreSuccess) { |
| ReloadDeviceSettings(); |
| EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS, |
| device_settings_service_.status()); |
| |
| owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey()); |
| device_settings_service_.SetUsername(device_policy_.policy_data().username()); |
| FlushDeviceSettings(); |
| |
| device_policy_.payload().mutable_device_policy_refresh_rate()-> |
| set_device_policy_refresh_rate(300); |
| device_policy_.Build(); |
| device_settings_service_.SignAndStore( |
| scoped_ptr<em::ChromeDeviceSettingsProto>( |
| new em::ChromeDeviceSettingsProto(device_policy_.payload())), |
| base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted, |
| base::Unretained(this))); |
| FlushDeviceSettings(); |
| EXPECT_TRUE(operation_completed_); |
| EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS, |
| device_settings_service_.status()); |
| ASSERT_TRUE(device_settings_service_.device_settings()); |
| EXPECT_EQ(device_policy_.payload().SerializeAsString(), |
| device_settings_service_.device_settings()->SerializeAsString()); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, StoreFailure) { |
| owner_key_util_->Clear(); |
| device_settings_test_helper_.set_policy_blob(std::string()); |
| ReloadDeviceSettings(); |
| EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE, |
| device_settings_service_.status()); |
| |
| device_settings_test_helper_.set_store_result(false); |
| device_settings_service_.Store( |
| device_policy_.GetCopy(), |
| base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted, |
| base::Unretained(this))); |
| FlushDeviceSettings(); |
| EXPECT_TRUE(operation_completed_); |
| EXPECT_EQ(DeviceSettingsService::STORE_OPERATION_FAILED, |
| device_settings_service_.status()); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, StoreSuccess) { |
| owner_key_util_->Clear(); |
| device_settings_test_helper_.set_policy_blob(std::string()); |
| ReloadDeviceSettings(); |
| EXPECT_EQ(DeviceSettingsService::STORE_KEY_UNAVAILABLE, |
| device_settings_service_.status()); |
| |
| owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey()); |
| device_settings_service_.Store( |
| device_policy_.GetCopy(), |
| base::Bind(&DeviceSettingsServiceTest::SetOperationCompleted, |
| base::Unretained(this))); |
| FlushDeviceSettings(); |
| EXPECT_TRUE(operation_completed_); |
| EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS, |
| device_settings_service_.status()); |
| CheckPolicy(); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, StoreRotation) { |
| ReloadDeviceSettings(); |
| EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS, |
| device_settings_service_.status()); |
| |
| device_policy_.payload().mutable_device_policy_refresh_rate()-> |
| set_device_policy_refresh_rate(300); |
| device_policy_.SetDefaultNewSigningKey(); |
| device_policy_.Build(); |
| device_settings_service_.Store(device_policy_.GetCopy(), base::Closure()); |
| FlushDeviceSettings(); |
| owner_key_util_->SetPublicKeyFromPrivateKey( |
| *device_policy_.GetNewSigningKey()); |
| device_settings_service_.OwnerKeySet(true); |
| FlushDeviceSettings(); |
| EXPECT_EQ(DeviceSettingsService::STORE_SUCCESS, |
| device_settings_service_.status()); |
| CheckPolicy(); |
| |
| // Check the new key has been loaded. |
| std::vector<uint8> key; |
| ASSERT_TRUE(device_policy_.GetNewSigningKey()->ExportPublicKey(&key)); |
| EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, OwnershipStatus) { |
| owner_key_util_->Clear(); |
| |
| EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey()); |
| EXPECT_FALSE(device_settings_service_.GetOwnerKey().get()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN, |
| device_settings_service_.GetOwnershipStatus()); |
| |
| device_settings_service_.GetOwnershipStatusAsync( |
| base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus, |
| base::Unretained(this))); |
| FlushDeviceSettings(); |
| EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey().get()); |
| EXPECT_FALSE(device_settings_service_.GetOwnerKey()->public_key()); |
| EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_NONE, |
| device_settings_service_.GetOwnershipStatus()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_NONE, ownership_status_); |
| |
| owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey()); |
| ReloadDeviceSettings(); |
| device_settings_service_.GetOwnershipStatusAsync( |
| base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus, |
| base::Unretained(this))); |
| FlushDeviceSettings(); |
| EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey().get()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key()); |
| std::vector<uint8> key; |
| ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key)); |
| EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key); |
| EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, |
| device_settings_service_.GetOwnershipStatus()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, ownership_status_); |
| |
| owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey()); |
| device_settings_service_.SetUsername(device_policy_.policy_data().username()); |
| device_settings_service_.GetOwnershipStatusAsync( |
| base::Bind(&DeviceSettingsServiceTest::SetOwnershipStatus, |
| base::Unretained(this))); |
| FlushDeviceSettings(); |
| EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey().get()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key()); |
| ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key)); |
| EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key); |
| EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, |
| device_settings_service_.GetOwnershipStatus()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, ownership_status_); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, OnCertificatesLoadedForNonOwner) { |
| owner_key_util_->Clear(); |
| |
| EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey()); |
| EXPECT_FALSE(device_settings_service_.GetOwnerKey().get()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN, |
| device_settings_service_.GetOwnershipStatus()); |
| |
| device_settings_service_.IsCurrentUserOwnerAsync( |
| base::Bind(&DeviceSettingsServiceTest::OnIsOwner, |
| base::Unretained(this))); |
| |
| owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey()); |
| ReloadDeviceSettings(); |
| |
| EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey().get()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key()); |
| std::vector<uint8> key; |
| ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key)); |
| EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key); |
| EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, |
| device_settings_service_.GetOwnershipStatus()); |
| EXPECT_FALSE(is_owner_set_); |
| |
| // Simulate CertLoader reporting a new set of certificates. The passed |
| // certificates are ignored. |
| device_settings_service_.OnCertificatesLoaded(net::CertificateList(), true); |
| FlushDeviceSettings(); |
| |
| EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey().get()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key()); |
| ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key)); |
| EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key); |
| EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, |
| device_settings_service_.GetOwnershipStatus()); |
| EXPECT_TRUE(is_owner_set_); |
| EXPECT_FALSE(is_owner_); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, OnCertificatesLoadedForOwner) { |
| owner_key_util_->Clear(); |
| |
| EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey()); |
| EXPECT_FALSE(device_settings_service_.GetOwnerKey().get()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN, |
| device_settings_service_.GetOwnershipStatus()); |
| |
| device_settings_service_.IsCurrentUserOwnerAsync( |
| base::Bind(&DeviceSettingsServiceTest::OnIsOwner, |
| base::Unretained(this))); |
| |
| owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey()); |
| ReloadDeviceSettings(); |
| |
| EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey().get()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key()); |
| std::vector<uint8> key; |
| ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key)); |
| EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key); |
| EXPECT_FALSE(device_settings_service_.GetOwnerKey()->private_key()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, |
| device_settings_service_.GetOwnershipStatus()); |
| EXPECT_FALSE(is_owner_set_); |
| |
| owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey()); |
| device_settings_service_.SetUsername(device_policy_.policy_data().username()); |
| // Simulate CertLoader reporting a new set of certificates. The passed |
| // certificates are ignored. |
| device_settings_service_.OnCertificatesLoaded(net::CertificateList(), true); |
| FlushDeviceSettings(); |
| |
| EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey().get()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key()); |
| ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key)); |
| EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key); |
| EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, |
| device_settings_service_.GetOwnershipStatus()); |
| EXPECT_TRUE(is_owner_set_); |
| EXPECT_TRUE(is_owner_); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, IsCurrentUserOwnerAsyncWithLoadedCerts) { |
| owner_key_util_->Clear(); |
| |
| EXPECT_FALSE(device_settings_service_.HasPrivateOwnerKey()); |
| EXPECT_FALSE(device_settings_service_.GetOwnerKey().get()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_UNKNOWN, |
| device_settings_service_.GetOwnershipStatus()); |
| |
| owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey()); |
| owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey()); |
| device_settings_service_.SetUsername(device_policy_.policy_data().username()); |
| ReloadDeviceSettings(); |
| |
| // Simulate CertLoader reporting a new set of certificates. The passed |
| // certificates are ignored. |
| device_settings_service_.OnCertificatesLoaded(net::CertificateList(), true); |
| FlushDeviceSettings(); |
| |
| EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey().get()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key()); |
| std::vector<uint8> key; |
| ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key)); |
| EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key); |
| EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, |
| device_settings_service_.GetOwnershipStatus()); |
| EXPECT_FALSE(is_owner_set_); |
| |
| device_settings_service_.IsCurrentUserOwnerAsync( |
| base::Bind(&DeviceSettingsServiceTest::OnIsOwner, |
| base::Unretained(this))); |
| // The callback should be called immediately. |
| base::MessageLoop::current()->RunUntilIdle(); |
| |
| EXPECT_TRUE(device_settings_service_.HasPrivateOwnerKey()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey().get()); |
| ASSERT_TRUE(device_settings_service_.GetOwnerKey()->public_key()); |
| ASSERT_TRUE(device_policy_.GetSigningKey()->ExportPublicKey(&key)); |
| EXPECT_EQ(*device_settings_service_.GetOwnerKey()->public_key(), key); |
| EXPECT_TRUE(device_settings_service_.GetOwnerKey()->private_key()); |
| EXPECT_EQ(DeviceSettingsService::OWNERSHIP_TAKEN, |
| device_settings_service_.GetOwnershipStatus()); |
| EXPECT_TRUE(is_owner_set_); |
| EXPECT_TRUE(is_owner_); |
| } |
| |
| TEST_F(DeviceSettingsServiceTest, Observer) { |
| owner_key_util_->Clear(); |
| MockDeviceSettingsObserver observer_; |
| device_settings_service_.AddObserver(&observer_); |
| |
| EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(1); |
| EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1); |
| ReloadDeviceSettings(); |
| Mock::VerifyAndClearExpectations(&observer_); |
| |
| EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(1); |
| EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1); |
| owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey()); |
| ReloadDeviceSettings(); |
| Mock::VerifyAndClearExpectations(&observer_); |
| |
| EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(0); |
| EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1); |
| device_settings_service_.Store(device_policy_.GetCopy(), base::Closure()); |
| FlushDeviceSettings(); |
| Mock::VerifyAndClearExpectations(&observer_); |
| |
| EXPECT_CALL(observer_, OwnershipStatusChanged()).Times(0); |
| EXPECT_CALL(observer_, DeviceSettingsUpdated()).Times(1); |
| device_settings_service_.PropertyChangeComplete(true); |
| FlushDeviceSettings(); |
| Mock::VerifyAndClearExpectations(&observer_); |
| |
| device_settings_service_.RemoveObserver(&observer_); |
| } |
| |
| } // namespace chromeos |
