Translate device-local account IDs to user IDs

chrome/browser/chromeos/settings/device_settings_provider_unittest.cc

 // 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_provider.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/test/scoped_path_override.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/settings/cros_settings_names.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 "chrome/common/chrome_paths.h"
 #include "chrome/test/base/scoped_testing_local_state.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 16 matching lines @@
         user_data_dir_override_(chrome::DIR_USER_DATA) {}
 
   virtual void SetUp() OVERRIDE {
     DeviceSettingsTestBase::SetUp();
 
     EXPECT_CALL(*this, SettingChanged(_)).Times(AnyNumber());
     provider_.reset(
         new DeviceSettingsProvider(
             base::Bind(&DeviceSettingsProviderTest::SettingChanged,
                        base::Unretained(this)),
-            &device_settings_service_));
+            DeviceSettingsService::Get()));
     Mock::VerifyAndClearExpectations(this);
   }
 
   virtual void TearDown() OVERRIDE {
     DeviceSettingsTestBase::TearDown();
   }
 
   ScopedStubCrosEnabler stub_cros_enabler_;
 
   ScopedTestingLocalState local_state_;
@@ skipping 71 matching lines @@
   // Verify the change has not been applied.
   const base::Value* saved_value = provider_->Get(kStatsReportingPref);
   ASSERT_TRUE(saved_value);
   bool bool_value;
   EXPECT_TRUE(saved_value->GetAsBoolean(&bool_value));
   EXPECT_FALSE(bool_value);
 }
 
 TEST_F(DeviceSettingsProviderTest, SetPrefSucceed) {
   owner_key_util_->SetPrivateKey(device_policy_.signing_key());
-  device_settings_service_.SetUsername(device_policy_.policy_data().username());
+  DeviceSettingsService::Get()->SetUsername(
+      device_policy_.policy_data().username());
   FlushDeviceSettings();
 
   base::FundamentalValue value(true);
   EXPECT_CALL(*this, SettingChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*this, SettingChanged(kStatsReportingPref)).Times(1);
   provider_->Set(kStatsReportingPref, value);
   Mock::VerifyAndClearExpectations(this);
 
   // Process the store.
   device_settings_test_helper_.set_policy_blob(std::string());
   FlushDeviceSettings();
 
   // Verify that the device policy has been adjusted.
-  ASSERT_TRUE(device_settings_service_.device_settings());
-  EXPECT_TRUE(device_settings_service_.device_settings()->
+  ASSERT_TRUE(DeviceSettingsService::Get()->device_settings());
+  EXPECT_TRUE(DeviceSettingsService::Get()->device_settings()->
                   metrics_enabled().metrics_enabled());
 
   // Verify the change has been applied.
   const base::Value* saved_value = provider_->Get(kStatsReportingPref);
   ASSERT_TRUE(saved_value);
   bool bool_value;
   EXPECT_TRUE(saved_value->GetAsBoolean(&bool_value));
   EXPECT_TRUE(bool_value);
 }
 
 TEST_F(DeviceSettingsProviderTest, SetPrefTwice) {
   owner_key_util_->SetPrivateKey(device_policy_.signing_key());
-  device_settings_service_.SetUsername(device_policy_.policy_data().username());
+  DeviceSettingsService::Get()->SetUsername(
+      device_policy_.policy_data().username());
   FlushDeviceSettings();
 
   EXPECT_CALL(*this, SettingChanged(_)).Times(AnyNumber());
 
   base::StringValue value1("beta");
   provider_->Set(kReleaseChannel, value1);
   base::StringValue value2("dev");
   provider_->Set(kReleaseChannel, value2);
 
   // Let the changes propagate through the system.
   device_settings_test_helper_.set_policy_blob(std::string());
   FlushDeviceSettings();
 
   // Verify the second change has been applied.
   const base::Value* saved_value = provider_->Get(kReleaseChannel);
   EXPECT_TRUE(value2.Equals(saved_value));
 
   Mock::VerifyAndClearExpectations(this);
 }
 
 TEST_F(DeviceSettingsProviderTest, PolicyRetrievalFailedBadSignature) {
   owner_key_util_->SetPublicKeyFromPrivateKey(device_policy_.signing_key());
   device_policy_.policy().set_policy_data_signature("bad signature");
   device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
   ReloadDeviceSettings();
 
   // Verify that the cached settings blob is not "trusted".
   EXPECT_EQ(DeviceSettingsService::STORE_VALIDATION_ERROR,
-            device_settings_service_.status());
+            DeviceSettingsService::Get()->status());
   EXPECT_EQ(CrosSettingsProvider::PERMANENTLY_UNTRUSTED,
             provider_->PrepareTrustedValues(base::Closure()));
 }
 
 TEST_F(DeviceSettingsProviderTest, PolicyRetrievalNoPolicy) {
   owner_key_util_->SetPublicKeyFromPrivateKey(device_policy_.signing_key());
   device_settings_test_helper_.set_policy_blob(std::string());
   ReloadDeviceSettings();
 
   // Verify that the cached settings blob is not "trusted".
   EXPECT_EQ(DeviceSettingsService::STORE_NO_POLICY,
-            device_settings_service_.status());
+            DeviceSettingsService::Get()->status());
   EXPECT_EQ(CrosSettingsProvider::PERMANENTLY_UNTRUSTED,
             provider_->PrepareTrustedValues(base::Closure()));
 }
 
 TEST_F(DeviceSettingsProviderTest, PolicyFailedPermanentlyNotification) {
   device_settings_test_helper_.set_policy_blob(std::string());
 
   EXPECT_CALL(*this, GetTrustedCallback());
   EXPECT_EQ(CrosSettingsProvider::TEMPORARILY_UNTRUSTED,
             provider_->PrepareTrustedValues(
@@ skipping 49 matching lines @@
   device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
   ReloadDeviceSettings();
   Mock::VerifyAndClearExpectations(this);
 
   // On load, the deprecated spec should have been converted to the new format.
   base::ListValue expected_accounts;
   scoped_ptr<base::DictionaryValue> entry_dict(new base::DictionaryValue());
   entry_dict->SetString(kAccountsPrefDeviceLocalAccountsKeyId,
                         policy::PolicyBuilder::kFakeUsername);
   entry_dict->SetInteger(kAccountsPrefDeviceLocalAccountsKeyType,
-                         DEVICE_LOCAL_ACCOUNT_TYPE_PUBLIC_SESSION);
+                         policy::DeviceLocalAccount::TYPE_PUBLIC_SESSION);
   expected_accounts.Append(entry_dict.release());
   const base::Value* actual_accounts =
       provider_->Get(kAccountsPrefDeviceLocalAccounts);
   EXPECT_TRUE(base::Value::Equals(&expected_accounts, actual_accounts));
 }
 
 } // namespace chromeos