Create profile .ico file on profile creation

chrome/browser/profiles/profile_shortcut_manager_unittest_win.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 <objbase.h>  // For CoInitialize().
 
 #include "base/base_paths.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/test/scoped_path_override.h"
 #include "base/test/test_shortcut_win.h"
 #include "base/win/shortcut.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_shortcut_manager.h"
 #include "chrome/browser/profiles/profile_shortcut_manager_win.h"
 #include "chrome/browser/shell_integration.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/product.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "content/public/test/test_browser_thread.h"
 #include "grit/chromium_strings.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 
 class ProfileShortcutManagerTest : public testing::Test {
  protected:
   ProfileShortcutManagerTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_),
         profile_info_cache_(NULL),
         fake_user_desktop_(base::DIR_USER_DESKTOP),
-        fake_system_desktop_(base::DIR_COMMON_DESKTOP) {
+        fake_system_desktop_(base::DIR_COMMON_DESKTOP),
+        fake_user_data_(chrome::DIR_USER_DATA) {
   }
 
   virtual void SetUp() OVERRIDE {
     CoInitialize(NULL);
 
     TestingBrowserProcess* browser_process =
         TestingBrowserProcess::GetGlobal();
     profile_manager_.reset(new TestingProfileManager(browser_process));
     ASSERT_TRUE(profile_manager_->SetUp());
     profile_info_cache_ = profile_manager_->profile_info_cache();
@@ skipping 12 matching lines @@
 
     // Delete all profiles and ensure their shortcuts got removed.
     const int num_profiles = profile_info_cache_->GetNumberOfProfiles();
     for (int i = 0; i < num_profiles; ++i) {
       const base::FilePath profile_path =
           profile_info_cache_->GetPathOfProfileAtIndex(0);
       string16 profile_name = profile_info_cache_->GetNameOfProfileAtIndex(0);
       profile_info_cache_->DeleteProfileFromCache(profile_path);
       RunPendingTasks();
       ASSERT_FALSE(ProfileShortcutExistsAtDefaultPath(profile_name));
+      // The icon file is not deleted until the profile directory is deleted.
       const base::FilePath icon_path =
-          profile_path.AppendASCII(profiles::internal::kProfileIconFileName);
-      ASSERT_FALSE(base::PathExists(icon_path));
+          profiles::internal::GetProfileIconPath(profile_path);
+      ASSERT_TRUE(base::PathExists(icon_path));
     }
   }
 
   base::FilePath CreateProfileDirectory(const string16& profile_name) {
     const base::FilePath profile_path =
         profile_info_cache_->GetUserDataDir().Append(profile_name);
-    file_util::CreateDirectoryW(profile_path);
+    file_util::CreateDirectory(profile_path);
     return profile_path;
   }
 
   void RunPendingTasks() {
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
     base::MessageLoop::current()->Run();
   }
 
   void SetupDefaultProfileShortcut(const tracked_objects::Location& location) {
@@ skipping 33 matching lines @@
 
   // Calls base::win::ValidateShortcut() with expected properties for the
   // shortcut at |shortcut_path| for the profile at |profile_path|.
   void ValidateProfileShortcutAtPath(const tracked_objects::Location& location,
                                      const base::FilePath& shortcut_path,
                                      const base::FilePath& profile_path) {
     EXPECT_TRUE(base::PathExists(shortcut_path)) << location.ToString();
 
     // Ensure that the corresponding icon exists.
     const base::FilePath icon_path =
-        profile_path.AppendASCII(profiles::internal::kProfileIconFileName);
+        profiles::internal::GetProfileIconPath(profile_path);
     EXPECT_TRUE(base::PathExists(icon_path)) << location.ToString();
 
     base::win::ShortcutProperties expected_properties;
     expected_properties.set_app_id(
         ShellIntegration::GetChromiumModelIdForProfile(profile_path));
     expected_properties.set_target(GetExePath());
     expected_properties.set_description(GetDistribution()->GetAppDescription());
     expected_properties.set_dual_mode(false);
     expected_properties.set_arguments(
         profiles::internal::CreateProfileShortcutFlags(profile_path));
@@ skipping 122 matching lines @@
   }
 
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   scoped_ptr<TestingProfileManager> profile_manager_;
   scoped_ptr<ProfileShortcutManager> profile_shortcut_manager_;
   ProfileInfoCache* profile_info_cache_;
   base::ScopedPathOverride fake_user_desktop_;
   base::ScopedPathOverride fake_system_desktop_;
+  base::ScopedPathOverride fake_user_data_;
   string16 profile_1_name_;
   base::FilePath profile_1_path_;
   string16 profile_2_name_;
   base::FilePath profile_2_path_;
   string16 profile_3_name_;
   base::FilePath profile_3_path_;
 };
 
 TEST_F(ProfileShortcutManagerTest, ShortcutFilename) {
   const string16 kProfileName = L"Harry";
@@ skipping 463 matching lines @@
 
   // Delete the shortcut for the first profile, but keep the one for the 2nd.
   ASSERT_TRUE(base::Delete(profile_1_shortcut_path, false));
   ASSERT_FALSE(base::PathExists(profile_1_shortcut_path));
   ASSERT_TRUE(base::PathExists(profile_2_shortcut_path));
 
   const base::FilePath system_level_shortcut_path =
       CreateRegularSystemLevelShortcut(FROM_HERE);
 
   // Delete the profile that has a shortcut, which will exercise the non-profile
-  // shortcut creation path in |DeleteDesktopShortcutsAndIconFile()|, which is
+  // shortcut creation path in |DeleteDesktopShortcuts()|, which is
   // not covered by the |DeleteSecondToLastProfileWithSystemLevelShortcut| test.
   profile_info_cache_->DeleteProfileFromCache(profile_2_path_);
   RunPendingTasks();
 
   // Verify that only the system-level shortcut still exists.
   EXPECT_TRUE(base::PathExists(system_level_shortcut_path));
   EXPECT_FALSE(base::PathExists(
                    GetDefaultShortcutPathForProfile(string16())));
   EXPECT_FALSE(base::PathExists(profile_1_shortcut_path));
   EXPECT_FALSE(base::PathExists(profile_2_shortcut_path));
 }
+
+TEST_F(ProfileShortcutManagerTest, CreateProfileIcon) {
+  SetupDefaultProfileShortcut(FROM_HERE);
+
+  const base::FilePath icon_path =
+      profiles::internal::GetProfileIconPath(profile_1_path_);
+
+  EXPECT_TRUE(base::PathExists(icon_path));
+  EXPECT_TRUE(base::Delete(icon_path, false));
+  EXPECT_FALSE(base::PathExists(icon_path));
+
+  profile_shortcut_manager_->CreateOrUpdateProfileIcon(profile_1_path_,
+                                                       base::Closure());
+  RunPendingTasks();
+  EXPECT_TRUE(base::PathExists(icon_path));
+}
+
+TEST_F(ProfileShortcutManagerTest, UnbadgeProfileIconOnDeletion) {
+  SetupDefaultProfileShortcut(FROM_HERE);
+  const base::FilePath icon_path_1 =
+      profiles::internal::GetProfileIconPath(profile_1_path_);
+  const base::FilePath icon_path_2 =
+      profiles::internal::GetProfileIconPath(profile_2_path_);
+
+  // Default profile has unbadged icon to start.
+  std::string unbadged_icon_1;
+  EXPECT_TRUE(file_util::ReadFileToString(icon_path_1, &unbadged_icon_1));
+
+  // Creating a new profile adds a badge to both the new profile icon and the
+  // default profile icon. Since they use the same icon index, the icon files
+  // should be the same.
+  CreateProfileWithShortcut(FROM_HERE, profile_2_name_, profile_2_path_);
+
+  std::string badged_icon_1;
+  EXPECT_TRUE(file_util::ReadFileToString(icon_path_1, &badged_icon_1));
+  std::string badged_icon_2;
+  EXPECT_TRUE(file_util::ReadFileToString(icon_path_2, &badged_icon_2));
+
+  EXPECT_NE(badged_icon_1, unbadged_icon_1);
+  EXPECT_EQ(badged_icon_1, badged_icon_2);
+
+  // Deleting the default profile will unbadge the new profile's icon and should
+  // result in an icon that is identical to the unbadged default profile icon.
+  profile_info_cache_->DeleteProfileFromCache(profile_1_path_);
+  RunPendingTasks();
+
+  std::string unbadged_icon_2;
+  EXPECT_TRUE(file_util::ReadFileToString(icon_path_2, &unbadged_icon_2));
+  EXPECT_EQ(unbadged_icon_1, unbadged_icon_2);
+}
+
+TEST_F(ProfileShortcutManagerTest, ProfileIconOnAvatarChange) {
+  SetupAndCreateTwoShortcuts(FROM_HERE);
+  const base::FilePath icon_path_1 =
+      profiles::internal::GetProfileIconPath(profile_1_path_);
+  const base::FilePath icon_path_2 =
+      profiles::internal::GetProfileIconPath(profile_2_path_);
+  const size_t profile_index_1 =
+      profile_info_cache_->GetIndexOfProfileWithPath(profile_1_path_);
+
+  std::string badged_icon_1;
+  EXPECT_TRUE(file_util::ReadFileToString(icon_path_1, &badged_icon_1));
+  std::string badged_icon_2;
+  EXPECT_TRUE(file_util::ReadFileToString(icon_path_2, &badged_icon_2));
+
+  // Profile 1 and 2 are created with the same icon.
+  EXPECT_EQ(badged_icon_1, badged_icon_2);
+
+  // Change profile 1's icon.
+  profile_info_cache_->SetAvatarIconOfProfileAtIndex(profile_index_1, 1);
+  RunPendingTasks();
+
+  std::string new_badged_icon_1;
+  EXPECT_TRUE(file_util::ReadFileToString(icon_path_1, &new_badged_icon_1));
+  EXPECT_NE(new_badged_icon_1, badged_icon_1);
+
+  // Ensure the new icon is not the unbadged icon.
+  profile_info_cache_->DeleteProfileFromCache(profile_2_path_);
+  RunPendingTasks();
+
+  std::string unbadged_icon_1;
+  EXPECT_TRUE(file_util::ReadFileToString(icon_path_1, &unbadged_icon_1));
+  EXPECT_NE(unbadged_icon_1, new_badged_icon_1);
+
+  // Ensure the icon doesn't change on avatar change without 2 profiles.
+  profile_info_cache_->SetAvatarIconOfProfileAtIndex(profile_index_1, 1);
+  RunPendingTasks();
+
+  std::string unbadged_icon_1_a;
+  EXPECT_TRUE(file_util::ReadFileToString(icon_path_1, &unbadged_icon_1_a));
+  EXPECT_EQ(unbadged_icon_1, unbadged_icon_1_a);
+}