CleanUp: Introduce UserInfo. Move session_state stuff to ash/session.

chrome/browser/chromeos/login/user_image_manager_browsertest.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 <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 344 matching lines @@
   run_loop.Run();
 
   // Image info is migrated and the image is converted to JPG.
   ExpectNewUserImageInfo(kTestUser1, User::kExternalImageIndex,
                          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 = GetDefaultImage(kFirstDefaultImageIndex);
-  EXPECT_EQ(saved_image.width(), user->image().width());
-  EXPECT_EQ(saved_image.height(), user->image().height());
+  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);
   ASSERT_TRUE(user);
   // Wait for image load.
   if (user->image_index() == User::kInvalidImageIndex) {
     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 = GetDefaultImage(kFirstDefaultImageIndex);
-  EXPECT_EQ(saved_image.width(), user->image().width());
-  EXPECT_EQ(saved_image.height(), user->image().height());
+  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);
   ASSERT_TRUE(user);
 
   const gfx::ImageSkia& default_image =
       GetDefaultImage(kFirstDefaultImageIndex);
 
   UserImageManager* user_image_manager =
       UserManager::Get()->GetUserImageManager(kTestUser1);
   user_image_manager->SaveUserDefaultImageIndex(kFirstDefaultImageIndex);
 
   EXPECT_TRUE(user->HasDefaultImage());
   EXPECT_EQ(kFirstDefaultImageIndex, user->image_index());
-  EXPECT_TRUE(test::AreImagesEqual(default_image, user->image()));
+  EXPECT_TRUE(test::AreImagesEqual(default_image, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1, 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);
   ASSERT_TRUE(user);
 
   SkBitmap custom_image_bitmap;
   custom_image_bitmap.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
   custom_image_bitmap.allocPixels();
   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(UserImage::CreateAndEncode(custom_image));
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(User::kExternalImageIndex, user->image_index());
-  EXPECT_TRUE(test::AreImagesEqual(custom_image, user->image()));
+  EXPECT_TRUE(test::AreImagesEqual(custom_image, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
                          User::kExternalImageIndex,
                          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());
@@ skipping 17 matching lines @@
   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_TRUE(test::AreImagesEqual(*custom_image, user->image()));
+  EXPECT_TRUE(test::AreImagesEqual(*custom_image, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
                          User::kExternalImageIndex,
                          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());
@@ skipping 23 matching lines @@
 
   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_TRUE(test::AreImagesEqual(profile_image, user->image()));
+  EXPECT_TRUE(test::AreImagesEqual(profile_image, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
                          User::kProfileImageIndex,
                          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());
@@ skipping 29 matching lines @@
 
   net::TestURLFetcherFactory url_fetcher_factory;
   CompleteProfileMetadataDownload(kTestUser1, &url_fetcher_factory);
 
   user_image_manager->SaveUserDefaultImageIndex(kFirstDefaultImageIndex);
 
   CompleteProfileImageDownload(&url_fetcher_factory);
 
   EXPECT_TRUE(user->HasDefaultImage());
   EXPECT_EQ(kFirstDefaultImageIndex, user->image_index());
-  EXPECT_TRUE(test::AreImagesEqual(default_image, user->image()));
+  EXPECT_TRUE(test::AreImagesEqual(default_image, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1, kFirstDefaultImageIndex, base::FilePath());
 }
 
 class UserImageManagerPolicyTest : public UserImageManagerTest,
                                    public policy::CloudPolicyStore::Observer {
  protected:
   UserImageManagerPolicyTest()
       : fake_dbus_thread_manager_(new chromeos::FakeDBusThreadManager),
         fake_session_manager_client_(new chromeos::FakeSessionManagerClient) {
     fake_dbus_thread_manager_->SetFakeClients();
@@ skipping 94 matching lines @@
       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_TRUE(test::AreImagesEqual(*policy_image_, user->image()));
+  EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
                          User::kExternalImageIndex,
                          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());
 
   // Clear policy. Verify that the policy-provided user image remains set as no
   // different user image has been chosen yet.
   user_policy_.payload().Clear();
   user_policy_.Build();
   fake_session_manager_client_->set_user_policy(kTestUser1,
                                                 user_policy_.GetBlob());
   run_loop_.reset(new base::RunLoop);
   store->AddObserver(this);
   store->Load();
   run_loop_->Run();
   store->RemoveObserver(this);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(User::kExternalImageIndex, user->image_index());
-  EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->image()));
+  EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
                          User::kExternalImageIndex,
                          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());
 
   // Choose a different user image. Verify that the chosen user image is set and
   // persisted.
   const gfx::ImageSkia& default_image =
       GetDefaultImage(kFirstDefaultImageIndex);
 
   UserImageManager* user_image_manager =
       UserManager::Get()->GetUserImageManager(kTestUser1);
   user_image_manager->SaveUserDefaultImageIndex(kFirstDefaultImageIndex);
 
   EXPECT_TRUE(user->HasDefaultImage());
   EXPECT_EQ(kFirstDefaultImageIndex, user->image_index());
-  EXPECT_TRUE(test::AreImagesEqual(default_image, user->image()));
+  EXPECT_TRUE(test::AreImagesEqual(default_image, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1, kFirstDefaultImageIndex, base::FilePath());
 }
 
 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
@@ skipping 12 matching lines @@
   // persisted.
   const gfx::ImageSkia& default_image =
       GetDefaultImage(kFirstDefaultImageIndex);
 
   UserImageManager* user_image_manager =
       UserManager::Get()->GetUserImageManager(kTestUser1);
   user_image_manager->SaveUserDefaultImageIndex(kFirstDefaultImageIndex);
 
   EXPECT_TRUE(user->HasDefaultImage());
   EXPECT_EQ(kFirstDefaultImageIndex, user->image_index());
-  EXPECT_TRUE(test::AreImagesEqual(default_image, user->image()));
+  EXPECT_TRUE(test::AreImagesEqual(default_image, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1, kFirstDefaultImageIndex, base::FilePath());
 
   // Set policy. Verify that the policy-provided user image is downloaded, set
   // and persisted, overriding the previously set image.
   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_TRUE(test::AreImagesEqual(*policy_image_, user->image()));
+  EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
                          User::kExternalImageIndex,
                          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());
@@ skipping 25 matching lines @@
       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_TRUE(test::AreImagesEqual(*policy_image_, user->image()));
+  EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
                          User::kExternalImageIndex,
                          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(kFirstDefaultImageIndex);
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(User::kExternalImageIndex, user->image_index());
-  EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->image()));
+  EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectNewUserImageInfo(kTestUser1,
                          User::kExternalImageIndex,
                          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