Replace chromeos::UserManager::Get() with chromeos::GetUserManager().

chrome/browser/chromeos/policy/device_local_account_browsertest.cc

 // Copyright (c) 2013 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 <map>
 #include <string>
 
 #include "apps/app_window_registry.h"
 #include "apps/ui/native_app_window.h"
 #include "ash/shell.h"
@@ skipping 398 matching lines @@
         proto.mutable_device_local_accounts()->add_account();
     account->set_account_id(username);
     account->set_type(
         em::DeviceLocalAccountInfoProto::ACCOUNT_TYPE_PUBLIC_SESSION);
     RefreshDevicePolicy();
     test_server_.UpdatePolicy(dm_protocol::kChromeDevicePolicyType,
                               std::string(), proto.SerializeAsString());
   }
 
   void CheckPublicSessionPresent(const std::string& id) {
-    const chromeos::User* user = chromeos::UserManager::Get()->FindUser(id);
+    const chromeos::User* user = chromeos::GetUserManager()->FindUser(id);
     ASSERT_TRUE(user);
     EXPECT_EQ(id, user->email());
     EXPECT_EQ(user_manager::USER_TYPE_PUBLIC_ACCOUNT, user->GetType());
   }
 
   base::FilePath GetExtensionCacheDirectoryForAccountID(
       const std::string& account_id) {
     base::FilePath extension_cache_root_dir;
     if (!PathService::Get(chromeos::DIR_DEVICE_LOCAL_ACCOUNT_EXTENSIONS,
                           &extension_cache_root_dir)) {
@@ skipping 22 matching lines @@
   scoped_ptr<base::RunLoop> run_loop_;
 
   UserPolicyBuilder device_local_account_policy_;
   LocalPolicyTestServer test_server_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeviceLocalAccountTest);
 };
 
 static bool IsKnownUser(const std::string& account_id) {
-  return chromeos::UserManager::Get()->IsKnownUser(account_id);
+  return chromeos::GetUserManager()->IsKnownUser(account_id);
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, LoginScreen) {
   AddPublicSessionToDevicePolicy(kAccountId1);
   AddPublicSessionToDevicePolicy(kAccountId2);
 
   content::WindowedNotificationObserver(chrome::NOTIFICATION_USER_LIST_CHANGED,
                                         base::Bind(&IsKnownUser, user_id_1_))
       .Wait();
   content::WindowedNotificationObserver(chrome::NOTIFICATION_USER_LIST_CHANGED,
                                         base::Bind(&IsKnownUser, user_id_2_))
       .Wait();
 
   CheckPublicSessionPresent(user_id_1_);
   CheckPublicSessionPresent(user_id_2_);
 }
 
 static bool DisplayNameMatches(const std::string& account_id,
                                const std::string& display_name) {
-  const chromeos::User* user =
-      chromeos::UserManager::Get()->FindUser(account_id);
+  const chromeos::User* user = chromeos::GetUserManager()->FindUser(account_id);
   if (!user || user->display_name().empty())
     return false;
   EXPECT_EQ(base::UTF8ToUTF16(display_name), user->display_name());
   return true;
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, DisplayName) {
   UploadAndInstallDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
@@ skipping 51 matching lines @@
                             policy.SerializeAsString());
   g_browser_process->policy_service()->RefreshPolicies(base::Closure());
 
   // Make sure the second device-local account disappears.
   content::WindowedNotificationObserver(
       chrome::NOTIFICATION_USER_LIST_CHANGED,
       base::Bind(&IsNotKnownUser, user_id_2_)).Wait();
 }
 
 static bool IsSessionStarted() {
-  return chromeos::UserManager::Get()->IsSessionStarted();
+  return chromeos::GetUserManager()->IsSessionStarted();
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, StartSession) {
   // Specify startup pages.
   device_local_account_policy_.payload().mutable_restoreonstartup()->set_value(
       SessionStartupPref::kPrefValueURLs);
   em::StringListPolicyProto* startup_urls_proto =
       device_local_account_policy_.payload().mutable_restoreonstartupurls();
   for (size_t i = 0; i < arraysize(kStartupURLs); ++i)
     startup_urls_proto->mutable_value()->add_entries(kStartupURLs[i]);
@@ skipping 284 matching lines @@
   // Verify that the extension was removed from the account's extension cache.
   EXPECT_FALSE(PathExists(cached_extension));
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, ExternalData) {
   // chromeos::UserManager requests an external data fetch whenever
   // the key::kUserAvatarImage policy is set. Since this test wants to
   // verify that the underlying policy subsystem will start a fetch
   // without this request as well, the chromeos::UserManager must be
   // prevented from seeing the policy change.
-  reinterpret_cast<chromeos::UserManagerImpl*>(chromeos::UserManager::Get())->
-      StopPolicyObserverForTesting();
+  reinterpret_cast<chromeos::UserManagerImpl*>(chromeos::GetUserManager())
+      ->StopPolicyObserverForTesting();
 
   UploadDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
   // This observes the display name becoming available as this indicates
   // device-local account policy is fully loaded.
   content::WindowedNotificationObserver(
       chrome::NOTIFICATION_USER_LIST_CHANGED,
       base::Bind(&DisplayNameMatches, user_id_1_, kDisplayName)).Wait();
 
@@ skipping 130 matching lines @@
       policy);
   UploadAndInstallDeviceLocalAccountPolicy();
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   DeviceLocalAccountPolicyBroker* broker =
       connector->GetDeviceLocalAccountPolicyService()->GetBrokerForUser(
           user_id_1_);
   ASSERT_TRUE(broker);
 
   run_loop_.reset(new base::RunLoop);
-  chromeos::UserManager::Get()->AddObserver(this);
+  chromeos::GetUserManager()->AddObserver(this);
   broker->core()->store()->Load();
   run_loop_->Run();
-  chromeos::UserManager::Get()->RemoveObserver(this);
+  chromeos::GetUserManager()->RemoveObserver(this);
 
   scoped_ptr<gfx::ImageSkia> policy_image = chromeos::test::ImageLoader(
       test_dir.Append(chromeos::test::kUserAvatarImage1RelativePath)).Load();
   ASSERT_TRUE(policy_image);
 
-  const chromeos::User* user =
-      chromeos::UserManager::Get()->FindUser(user_id_1_);
+  const chromeos::User* user = chromeos::GetUserManager()->FindUser(user_id_1_);
   ASSERT_TRUE(user);
 
   base::FilePath user_data_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_USER_DATA, &user_data_dir));
   const base::FilePath saved_image_path =
       user_data_dir.Append(user_id_1_).AddExtension("jpg");
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(chromeos::User::kExternalImageIndex, user->image_index());
   EXPECT_TRUE(chromeos::test::AreImagesEqual(*policy_image, user->GetImage()));
@@ skipping 352 matching lines @@
   if (!IsSessionStarted()) {
     content::WindowedNotificationObserver(chrome::NOTIFICATION_SESSION_STARTED,
                                           base::Bind(IsSessionStarted)).Wait();
   }
 }
 
 INSTANTIATE_TEST_CASE_P(TermsOfServiceTestInstance,
                         TermsOfServiceTest, testing::Bool());
 
 }  // namespace policy