[cros] Move User class to user_manager component.

chrome/browser/chromeos/login/users/avatar/user_image_manager_browsertest.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 <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 13 matching lines @@
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/login_manager_test.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/users/avatar/user_image_manager.h"
 #include "chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.h"
 #include "chrome/browser/chromeos/login/users/avatar/user_image_manager_test_util.h"
 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
-#include "chrome/browser/chromeos/login/users/user.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/policy/cloud_external_data_manager_base_test_util.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_downloader.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chromeos/chromeos_paths.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_dbus_thread_manager.h"
 #include "chromeos/dbus/fake_session_manager_client.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "components/policy/core/common/cloud/cloud_policy_core.h"
 #include "components/policy/core/common/cloud/cloud_policy_store.h"
 #include "components/policy/core/common/cloud/policy_builder.h"
+#include "components/user_manager/user.h"
 #include "components/user_manager/user_image/default_user_images.h"
 #include "components/user_manager/user_image/user_image.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/test/test_utils.h"
 #include "crypto/rsa_private_key.h"
 #include "google_apis/gaia/gaia_oauth_client.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_status.h"
 #include "policy/proto/cloud_policy.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
 #include "url/gurl.h"
 
 namespace chromeos {
 
 namespace {
 
 const char kTestUser1[] = "test-user@example.com";
 const char kTestUser2[] = "test-user2@example.com";
 
-policy::CloudPolicyStore* GetStoreForUser(const User* user) {
+policy::CloudPolicyStore* GetStoreForUser(const user_manager::User* user) {
   Profile* profile = ProfileHelper::Get()->GetProfileByUser(user);
   if (!profile) {
     ADD_FAILURE();
     return NULL;
   }
   policy::UserCloudPolicyManagerChromeOS* policy_manager =
       policy::UserCloudPolicyManagerFactoryChromeOS::GetForProfile(profile);
   if (!policy_manager) {
     ADD_FAILURE();
     return NULL;
@@ skipping 106 matching lines @@
                         int resource_id) {
     base::FilePath image_path = GetUserImagePath(username, "png");
     scoped_refptr<base::RefCountedStaticMemory> image_data(
         ResourceBundle::GetSharedInstance().LoadDataResourceBytesForScale(
             resource_id, ui::SCALE_FACTOR_100P));
     int written = base::WriteFile(
         image_path,
         reinterpret_cast<const char*>(image_data->front()),
         image_data->size());
     EXPECT_EQ(static_cast<int>(image_data->size()), written);
-    SetOldUserImageInfo(username, User::kExternalImageIndex, image_path);
+    SetOldUserImageInfo(
+        username, user_manager::User::USER_IMAGE_EXTERNAL, image_path);
   }
 
   // Returns the image path for user |username| with specified |extension|.
   base::FilePath GetUserImagePath(const std::string& username,
                                   const std::string& extension) {
     return user_data_dir_.Append(username).AddExtension(extension);
   }
 
   // Completes the download of all non-image profile data for the user
   // |username|.  This method must only be called after a profile data
@@ skipping 47 matching lines @@
     pref_change_registrar.Add("UserDisplayName", run_loop.QuitClosure());
     net::TestURLFetcher* fetcher = url_fetcher_factory->GetFetcherByID(0);
     ASSERT_TRUE(fetcher);
     fetcher->SetResponseString(profile_image_data);
     fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
                                               net::OK));
     fetcher->set_response_code(200);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     run_loop.Run();
 
-    const User* user = UserManager::Get()->GetLoggedInUser();
+    const user_manager::User* user = UserManager::Get()->GetLoggedInUser();
     ASSERT_TRUE(user);
     UserImageManagerImpl* uim = reinterpret_cast<UserImageManagerImpl*>(
         UserManager::Get()->GetUserImageManager(user->email()));
     if (uim->job_.get()) {
       run_loop_.reset(new base::RunLoop);
       run_loop_->Run();
     }
   }
 
   base::FilePath test_data_dir_;
@@ skipping 55 matching lines @@
   // Setup a user with non-JPEG image.
   ScopedUserManagerEnabler(new MockUserManager);
   SaveUserImagePNG(kTestUser1,
                    user_manager::kDefaultImageResourceIDs
                        [user_manager::kFirstDefaultImageIndex]);
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, PRE_NonJPEGImageFromFile) {
   UserManager::Get()->GetUsers();  // Load users.
   // Old info preserved.
-  ExpectOldUserImageInfo(kTestUser1, User::kExternalImageIndex,
+  ExpectOldUserImageInfo(kTestUser1,
+                         user_manager::User::USER_IMAGE_EXTERNAL,
                          GetUserImagePath(kTestUser1, "png"));
-  const User* user = UserManager::Get()->FindUser(kTestUser1);
+  const user_manager::User* user = UserManager::Get()->FindUser(kTestUser1);
   EXPECT_TRUE(user->image_is_stub());
 
   base::RunLoop run_loop;
   PrefChangeRegistrar pref_change_registrar_;
   pref_change_registrar_.Init(local_state_);
   pref_change_registrar_.Add("UserImages", run_loop.QuitClosure());
   LogIn(kTestUser1);
 
   // Wait for migration.
   run_loop.Run();
 
   // Image info is migrated and the image is converted to JPG.
-  ExpectNewUserImageInfo(kTestUser1, User::kExternalImageIndex,
+  ExpectNewUserImageInfo(kTestUser1,
+                         user_manager::User::USER_IMAGE_EXTERNAL,
                          GetUserImagePath(kTestUser1, "jpg"));
   user = UserManager::Get()->GetLoggedInUser();
   ASSERT_TRUE(user);
   EXPECT_FALSE(user->image_is_safe_format());
   // Check image dimensions.
   const gfx::ImageSkia& saved_image =
       user_manager::GetDefaultImage(user_manager::kFirstDefaultImageIndex);
   EXPECT_EQ(saved_image.width(), user->GetImage().width());
   EXPECT_EQ(saved_image.height(), user->GetImage().height());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, NonJPEGImageFromFile) {
   UserManager::Get()->GetUsers();  // Load users.
-  const User* user = UserManager::Get()->FindUser(kTestUser1);
+  const user_manager::User* user = UserManager::Get()->FindUser(kTestUser1);
   ASSERT_TRUE(user);
   // Wait for image load.
-  if (user->image_index() == User::kInvalidImageIndex) {
+  if (user->image_index() == user_manager::User::USER_IMAGE_INVALID) {
     content::WindowedNotificationObserver(
         chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
         content::NotificationService::AllSources()).Wait();
   }
   // Now the migrated image is used.
   EXPECT_TRUE(user->image_is_safe_format());
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   const gfx::ImageSkia& saved_image =
       user_manager::GetDefaultImage(user_manager::kFirstDefaultImageIndex);
   EXPECT_EQ(saved_image.width(), user->GetImage().width());
   EXPECT_EQ(saved_image.height(), user->GetImage().height());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, PRE_SaveUserDefaultImageIndex) {
   RegisterUser(kTestUser1);
 }
 
 // Verifies that SaveUserDefaultImageIndex() correctly sets and persists the
 // chosen user image.
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, SaveUserDefaultImageIndex) {
-  const User* user = UserManager::Get()->FindUser(kTestUser1);
+  const user_manager::User* user = UserManager::Get()->FindUser(kTestUser1);
   ASSERT_TRUE(user);
 
   const gfx::ImageSkia& default_image =
       user_manager::GetDefaultImage(user_manager::kFirstDefaultImageIndex);
 
   UserImageManager* user_image_manager =
       UserManager::Get()->GetUserImageManager(kTestUser1);
   user_image_manager->SaveUserDefaultImageIndex(
       user_manager::kFirstDefaultImageIndex);
 
   EXPECT_TRUE(user->HasDefaultImage());
   EXPECT_EQ(user_manager::kFirstDefaultImageIndex, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(default_image, user->GetImage()));
   ExpectNewUserImageInfo(
       kTestUser1, user_manager::kFirstDefaultImageIndex, base::FilePath());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, PRE_SaveUserImage) {
   RegisterUser(kTestUser1);
 }
 
 // Verifies that SaveUserImage() correctly sets and persists the chosen user
 // image.
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, SaveUserImage) {
-  const User* user = UserManager::Get()->FindUser(kTestUser1);
+  const user_manager::User* user = UserManager::Get()->FindUser(kTestUser1);
   ASSERT_TRUE(user);
 
   SkBitmap custom_image_bitmap;
   custom_image_bitmap.allocN32Pixels(10, 10);
   custom_image_bitmap.setImmutable();
   const gfx::ImageSkia custom_image =
       gfx::ImageSkia::CreateFrom1xBitmap(custom_image_bitmap);
 
   run_loop_.reset(new base::RunLoop);
   UserImageManager* user_image_manager =
       UserManager::Get()->GetUserImageManager(kTestUser1);
   user_image_manager->SaveUserImage(
       user_manager::UserImage::CreateAndEncode(custom_image));
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
-  EXPECT_EQ(User::kExternalImageIndex, user->image_index());
+  EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(custom_image, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
-                         User::kExternalImageIndex,
+                         user_manager::User::USER_IMAGE_EXTERNAL,
                          GetUserImagePath(kTestUser1, "jpg"));
 
   const scoped_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(kTestUser1, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(custom_image.width(), saved_image->width());
   EXPECT_EQ(custom_image.height(), saved_image->height());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, PRE_SaveUserImageFromFile) {
   RegisterUser(kTestUser1);
 }
 
 // Verifies that SaveUserImageFromFile() correctly sets and persists the chosen
 // user image.
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, SaveUserImageFromFile) {
-  const User* user = UserManager::Get()->FindUser(kTestUser1);
+  const user_manager::User* user = UserManager::Get()->FindUser(kTestUser1);
   ASSERT_TRUE(user);
 
   const base::FilePath custom_image_path =
       test_data_dir_.Append(test::kUserAvatarImage1RelativePath);
   const scoped_ptr<gfx::ImageSkia> custom_image =
       test::ImageLoader(custom_image_path).Load();
   ASSERT_TRUE(custom_image);
 
   run_loop_.reset(new base::RunLoop);
   UserImageManager* user_image_manager =
       UserManager::Get()->GetUserImageManager(kTestUser1);
   user_image_manager->SaveUserImageFromFile(custom_image_path);
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
-  EXPECT_EQ(User::kExternalImageIndex, user->image_index());
+  EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(*custom_image, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
-                         User::kExternalImageIndex,
+                         user_manager::User::USER_IMAGE_EXTERNAL,
                          GetUserImagePath(kTestUser1, "jpg"));
 
   const scoped_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(kTestUser1, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(custom_image->width(), saved_image->width());
   EXPECT_EQ(custom_image->height(), saved_image->height());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest,
                        PRE_SaveUserImageFromProfileImage) {
   RegisterUser(kTestUser1);
   chromeos::StartupUtils::MarkOobeCompleted();
 }
 
 // Verifies that SaveUserImageFromProfileImage() correctly downloads, sets and
 // persists the chosen user image.
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, SaveUserImageFromProfileImage) {
-  const User* user = UserManager::Get()->FindUser(kTestUser1);
+  const user_manager::User* user = UserManager::Get()->FindUser(kTestUser1);
   ASSERT_TRUE(user);
 
   UserImageManagerImpl::IgnoreProfileDataDownloadDelayForTesting();
   LoginUser(kTestUser1);
 
   run_loop_.reset(new base::RunLoop);
   UserImageManager* user_image_manager =
       UserManager::Get()->GetUserImageManager(kTestUser1);
   user_image_manager->SaveUserImageFromProfileImage();
   run_loop_->Run();
 
   net::TestURLFetcherFactory url_fetcher_factory;
   CompleteProfileMetadataDownload(kTestUser1, &url_fetcher_factory);
   CompleteProfileImageDownload(&url_fetcher_factory);
 
   const gfx::ImageSkia& profile_image =
       user_image_manager->DownloadedProfileImage();
 
   EXPECT_FALSE(user->HasDefaultImage());
-  EXPECT_EQ(User::kProfileImageIndex, user->image_index());
+  EXPECT_EQ(user_manager::User::USER_IMAGE_PROFILE, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(profile_image, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
-                         User::kProfileImageIndex,
+                         user_manager::User::USER_IMAGE_PROFILE,
                          GetUserImagePath(kTestUser1, "jpg"));
 
   const scoped_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(kTestUser1, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(profile_image.width(), saved_image->width());
   EXPECT_EQ(profile_image.height(), saved_image->height());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest,
                        PRE_ProfileImageDownloadDoesNotClobber) {
   RegisterUser(kTestUser1);
   chromeos::StartupUtils::MarkOobeCompleted();
 }
 
 // Sets the user image to the profile image, then sets it to one of the default
 // images while the profile image download is still in progress. Verifies that
 // when the download completes, the profile image is ignored and does not
 // clobber the default image chosen in the meantime.
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest,
                        ProfileImageDownloadDoesNotClobber) {
-  const User* user = UserManager::Get()->FindUser(kTestUser1);
+  const user_manager::User* user = UserManager::Get()->FindUser(kTestUser1);
   ASSERT_TRUE(user);
 
   const gfx::ImageSkia& default_image =
       user_manager::GetDefaultImage(user_manager::kFirstDefaultImageIndex);
 
   UserImageManagerImpl::IgnoreProfileDataDownloadDelayForTesting();
   LoginUser(kTestUser1);
 
   run_loop_.reset(new base::RunLoop);
   UserImageManager* user_image_manager =
@@ skipping 98 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerPolicyTest, PRE_SetAndClear) {
   RegisterUser(kTestUser1);
   chromeos::StartupUtils::MarkOobeCompleted();
 }
 
 // Verifies that the user image can be set through policy. Also verifies that
 // after the policy has been cleared, the user is able to choose a different
 // image.
 IN_PROC_BROWSER_TEST_F(UserImageManagerPolicyTest, SetAndClear) {
-  const User* user = UserManager::Get()->FindUser(kTestUser1);
+  const user_manager::User* user = UserManager::Get()->FindUser(kTestUser1);
   ASSERT_TRUE(user);
 
   LoginUser(kTestUser1);
   base::RunLoop().RunUntilIdle();
 
   policy::CloudPolicyStore* store = GetStoreForUser(user);
   ASSERT_TRUE(store);
 
   // Set policy. Verify that the policy-provided user image is downloaded, set
   // and persisted.
   user_policy_.payload().mutable_useravatarimage()->set_value(
       ConstructPolicy(test::kUserAvatarImage2RelativePath));
   user_policy_.Build();
   fake_session_manager_client_->set_user_policy(kTestUser1,
                                                 user_policy_.GetBlob());
   run_loop_.reset(new base::RunLoop);
   store->Load();
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
-  EXPECT_EQ(User::kExternalImageIndex, user->image_index());
+  EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
-                         User::kExternalImageIndex,
+                         user_manager::User::USER_IMAGE_EXTERNAL,
                          GetUserImagePath(kTestUser1, "jpg"));
 
   scoped_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(kTestUser1, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(policy_image_->width(), saved_image->width());
   EXPECT_EQ(policy_image_->height(), saved_image->height());
 
@@ skipping 42 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerPolicyTest, PRE_PolicyOverridesUser) {
   RegisterUser(kTestUser1);
   chromeos::StartupUtils::MarkOobeCompleted();
 }
 
 // Verifies that when the user chooses a user image and a different image is
 // then set through policy, the policy takes precedence, overriding the
 // previously chosen image.
 IN_PROC_BROWSER_TEST_F(UserImageManagerPolicyTest, PolicyOverridesUser) {
-  const User* user = UserManager::Get()->FindUser(kTestUser1);
+  const user_manager::User* user = UserManager::Get()->FindUser(kTestUser1);
   ASSERT_TRUE(user);
 
   LoginUser(kTestUser1);
   base::RunLoop().RunUntilIdle();
 
   policy::CloudPolicyStore* store = GetStoreForUser(user);
   ASSERT_TRUE(store);
 
   // Choose a user image. Verify that the chosen user image is set and
   // persisted.
@@ skipping 16 matching lines @@
   user_policy_.payload().mutable_useravatarimage()->set_value(
       ConstructPolicy(test::kUserAvatarImage2RelativePath));
   user_policy_.Build();
   fake_session_manager_client_->set_user_policy(kTestUser1,
                                                 user_policy_.GetBlob());
   run_loop_.reset(new base::RunLoop);
   store->Load();
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
-  EXPECT_EQ(User::kExternalImageIndex, user->image_index());
+  EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
-                         User::kExternalImageIndex,
+                         user_manager::User::USER_IMAGE_EXTERNAL,
                          GetUserImagePath(kTestUser1, "jpg"));
 
   scoped_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(kTestUser1, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(policy_image_->width(), saved_image->width());
   EXPECT_EQ(policy_image_->height(), saved_image->height());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerPolicyTest,
                        PRE_UserDoesNotOverridePolicy) {
   RegisterUser(kTestUser1);
   chromeos::StartupUtils::MarkOobeCompleted();
 }
 
 // Verifies that when the user image has been set through policy and the user
 // chooses a different image, the policy takes precedence, preventing the user
 // from overriding the previously chosen image.
 IN_PROC_BROWSER_TEST_F(UserImageManagerPolicyTest, UserDoesNotOverridePolicy) {
-  const User* user = UserManager::Get()->FindUser(kTestUser1);
+  const user_manager::User* user = UserManager::Get()->FindUser(kTestUser1);
   ASSERT_TRUE(user);
 
   LoginUser(kTestUser1);
   base::RunLoop().RunUntilIdle();
 
   policy::CloudPolicyStore* store = GetStoreForUser(user);
   ASSERT_TRUE(store);
 
   // Set policy. Verify that the policy-provided user image is downloaded, set
   // and persisted.
   user_policy_.payload().mutable_useravatarimage()->set_value(
       ConstructPolicy(test::kUserAvatarImage2RelativePath));
   user_policy_.Build();
   fake_session_manager_client_->set_user_policy(kTestUser1,
                                                 user_policy_.GetBlob());
   run_loop_.reset(new base::RunLoop);
   store->Load();
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
-  EXPECT_EQ(User::kExternalImageIndex, user->image_index());
+  EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
-                         User::kExternalImageIndex,
+                         user_manager::User::USER_IMAGE_EXTERNAL,
                          GetUserImagePath(kTestUser1, "jpg"));
 
   scoped_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(kTestUser1, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(policy_image_->width(), saved_image->width());
   EXPECT_EQ(policy_image_->height(), saved_image->height());
 
   // Choose a different user image. Verify that the user image does not change
   // as policy takes precedence.
   UserImageManager* user_image_manager =
       UserManager::Get()->GetUserImageManager(kTestUser1);
   user_image_manager->SaveUserDefaultImageIndex(
       user_manager::kFirstDefaultImageIndex);
 
   EXPECT_FALSE(user->HasDefaultImage());
-  EXPECT_EQ(User::kExternalImageIndex, user->image_index());
+  EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
-                         User::kExternalImageIndex,
+                         user_manager::User::USER_IMAGE_EXTERNAL,
                          GetUserImagePath(kTestUser1, "jpg"));
 
   saved_image = test::ImageLoader(GetUserImagePath(kTestUser1, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(policy_image_->width(), saved_image->width());
   EXPECT_EQ(policy_image_->height(), saved_image->height());
 }
 
 }  // namespace chromeos