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"
@@ skipping 20 matching lines @@
 
 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) {

[gab, 2013/07/16 14:10:38]

This should also mock chrome::DIR_USER_DATA (otherwise tests are using the same
directory which could lead to a lot of races and weird behaviors like you
encountered).

[calamity, 2013/07/18 08:39:08]

The TestingProfileManager has its own scoped temp dir which profiles get created
in. Do we need to use that directory as the user data dir or will another scoped
temp dir be fine? I've tried with a separate folder for user data dir and it
seems to be fine.

[gab, 2013/07/18 16:51:01]

Ah, I hadn't noticed the TestingProfileManager, it probably makes sense to
override chrome::DIR_USER_DATA to point to TestingProfileManager's
profiles_dir() then (although I'm no longer convinced this is really necessary
anymore -- I thought they were created in the default user-data-dir, but if
there is already a test override for the manager I guess this is not needed...)

(I personally prefer overriding the path to mocking the manager, but this is a
discussion for another day... You can remove |fake_user_data_| for now I'd say)

[calamity, 2013/07/19 04:23:17]

Done.

   }
 
   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 13 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));
       const base::FilePath icon_path =
-          profile_path.AppendASCII(profiles::internal::kProfileIconFileName);
-      ASSERT_FALSE(base::PathExists(icon_path));
+          profiles::internal::GetProfileIconPath(profile_path);
+      // The icon file should not be deleted on shortcut deletion.
+      ASSERT_TRUE(base::PathExists(icon_path));
+      ASSERT_TRUE(base::Delete(icon_path, false));
     }
   }
 
   base::FilePath CreateProfileDirectory(const string16& profile_name) {
     const base::FilePath profile_path =
         profile_info_cache_->GetUserDataDir().Append(profile_name);
     file_util::CreateDirectoryW(profile_path);

[gab, 2013/07/16 14:10:38]

s/CreateDirectoryW/CreateDirectory (not sure how CreateDirectoryW even compiles
as it's not in file_util.h...)

[calamity, 2013/07/18 08:39:08]

Done.

     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 605 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);
+}