Componentize LoginManagerTest.

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"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/run_loop.h"
 #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/default_user_images.h"
-#include "chrome/browser/chromeos/login/login_manager_test.h"
+#include "chrome/browser/chromeos/login/login_manager_test_helper.h"
 #include "chrome/browser/chromeos/login/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_image.h"
 #include "chrome/browser/chromeos/login/user_image_manager.h"
 #include "chrome/browser/chromeos/login/user_image_manager_impl.h"
 #include "chrome/browser/chromeos/login/user_image_manager_test_util.h"
 #include "chrome/browser/chromeos/login/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"
@@ skipping 47 matching lines @@
       policy::UserCloudPolicyManagerFactoryChromeOS::GetForProfile(profile);
   if (!policy_manager) {
     ADD_FAILURE();
     return NULL;
   }
   return policy_manager->core()->store();
 }
 
 }  // namespace
 
-class UserImageManagerTest : public LoginManagerTest,
+class UserImageManagerTest : public InProcessBrowserTest,
                              public UserManager::Observer {
  protected:
-  UserImageManagerTest() : LoginManagerTest(true) {
+  UserImageManagerTest()
+      : login_manager_test_helper_(new LoginManagerTestHelper) {
+    set_exit_when_last_browser_closes(false);
   }
 
-  // LoginManagerTest overrides:
+  // InProcessBrowserTest overrides:
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
-    LoginManagerTest::SetUpInProcessBrowserTestFixture();
+    login_manager_test_helper_->SetUpLoginUtils(true);
 
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_));
     ASSERT_TRUE(PathService::Get(chrome::DIR_USER_DATA, &user_data_dir_));
   }
 
   virtual void SetUpOnMainThread() OVERRIDE {
-    LoginManagerTest::SetUpOnMainThread();
+    login_manager_test_helper_->SetUp();
     local_state_ = g_browser_process->local_state();
     UserManager::Get()->AddObserver(this);
   }
 
   virtual void TearDownOnMainThread() OVERRIDE {
     UserManager::Get()->RemoveObserver(this);
-    LoginManagerTest::TearDownOnMainThread();
+    InProcessBrowserTest::TearDownOnMainThread();
+  }
+
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    login_manager_test_helper_->SetUpCommandLine(command_line);
+  }
+
+  virtual void CleanUpOnMainThread() OVERRIDE {
+    login_manager_test_helper_->CleanUp();
   }
 
   // UserManager::Observer overrides:
   virtual void LocalStateChanged(UserManager* user_manager) OVERRIDE {
     if (run_loop_)
       run_loop_->Quit();
   }
 
   // Logs in |username|.
   void LogIn(const std::string& username) {
     UserManager::Get()->UserLoggedIn(username, username, false);
   }
 
   // Stores old (pre-migration) user image info.
   void SetOldUserImageInfo(const std::string& username,
                            int image_index,
                            const base::FilePath& image_path) {
-    RegisterUser(username);
+    login_manager_test_helper_->RegisterUser(username);
     DictionaryPrefUpdate images_pref(local_state_, "UserImages");
     base::DictionaryValue* image_properties = new base::DictionaryValue();
     image_properties->Set(
         "index", base::Value::CreateIntegerValue(image_index));
     image_properties->Set(
         "path" , new base::StringValue(image_path.value()));
     images_pref->SetWithoutPathExpansion(username, image_properties);
   }
 
   // Verifies user image info in |images_pref| dictionary.
@@ skipping 135 matching lines @@
       run_loop_->Run();
     }
   }
 
   base::FilePath test_data_dir_;
   base::FilePath user_data_dir_;
 
   PrefService* local_state_;
 
   scoped_ptr<gfx::ImageSkia> decoded_image_;
-
+  scoped_ptr<LoginManagerTestHelper> login_manager_test_helper_;
   scoped_ptr<base::RunLoop> run_loop_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UserImageManagerTest);
 };
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, PRE_DefaultUserImagePreserved) {
   // Setup an old default (stock) user image.
   ScopedUserManagerEnabler(new MockUserManager);
   SetOldUserImageInfo(kTestUser1, kFirstDefaultImageIndex, base::FilePath());
@@ skipping 77 matching lines @@
   }
   // 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->GetImage().width());
   EXPECT_EQ(saved_image.height(), user->GetImage().height());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, PRE_SaveUserDefaultImageIndex) {
-  RegisterUser(kTestUser1);
+  login_manager_test_helper_->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->GetImage()));
   ExpectNewUserImageInfo(kTestUser1, kFirstDefaultImageIndex, base::FilePath());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, PRE_SaveUserImage) {
-  RegisterUser(kTestUser1);
+  login_manager_test_helper_->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);
@@ skipping 18 matching lines @@
   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);
+  login_manager_test_helper_->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);
   ASSERT_TRUE(user);
 
   const base::FilePath custom_image_path =
       test_data_dir_.Append(test::kUserAvatarImage1RelativePath);
@@ skipping 18 matching lines @@
       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);
+  login_manager_test_helper_->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);
   ASSERT_TRUE(user);
 
   UserImageManagerImpl::IgnoreProfileDataDownloadDelayForTesting();
-  LoginUser(kTestUser1);
+  login_manager_test_helper_->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);
@@ skipping 12 matching lines @@
       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);
+  login_manager_test_helper_->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);
   ASSERT_TRUE(user);
 
   const gfx::ImageSkia& default_image =
       GetDefaultImage(kFirstDefaultImageIndex);
 
   UserImageManagerImpl::IgnoreProfileDataDownloadDelayForTesting();
-  LoginUser(kTestUser1);
+  login_manager_test_helper_->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);
 
@@ skipping 81 matching lines @@
   FakeDBusThreadManager* fake_dbus_thread_manager_;
   FakeSessionManagerClient* fake_session_manager_client_;
 
   scoped_ptr<gfx::ImageSkia> policy_image_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UserImageManagerPolicyTest);
 };
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerPolicyTest, PRE_SetAndClear) {
-  RegisterUser(kTestUser1);
+  login_manager_test_helper_->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);
   ASSERT_TRUE(user);
 
-  LoginUser(kTestUser1);
+  login_manager_test_helper_->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();
@@ skipping 54 matching lines @@
       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->GetImage()));
   ExpectNewUserImageInfo(kTestUser1, kFirstDefaultImageIndex, base::FilePath());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerPolicyTest, PRE_PolicyOverridesUser) {
-  RegisterUser(kTestUser1);
+  login_manager_test_helper_->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);
   ASSERT_TRUE(user);
 
-  LoginUser(kTestUser1);
+  login_manager_test_helper_->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.
   const gfx::ImageSkia& default_image =
       GetDefaultImage(kFirstDefaultImageIndex);
 
@@ skipping 28 matching lines @@
       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);
+  login_manager_test_helper_->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);
   ASSERT_TRUE(user);
 
-  LoginUser(kTestUser1);
+  login_manager_test_helper_->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();
@@ skipping 33 matching lines @@
 
   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