Improve JumpList icon folders' naming style

chrome/browser/win/jumplist.cc

 // Copyright 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 "chrome/browser/win/jumplist.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 170 matching lines @@
 
   return jumplist_updater->AddTasks(items);
 }
 
 // Updates the application JumpList, which consists of 1) delete old icon files;
 // 2) create new icon files; 3) notify the OS.
 // Note that any timeout error along the way results in the old jumplist being
 // left as-is, while any non-timeout error results in the old jumplist being
 // left as-is, but without icon files.
 bool UpdateJumpList(const wchar_t* app_id,
-                    const base::FilePath& icon_dir,
+                    const Profile* profile,
                     const ShellLinkItemList& most_visited_pages,
                     const ShellLinkItemList& recently_closed_pages,
                     bool most_visited_pages_have_updates,
                     bool recently_closed_pages_have_updates,
                     IncognitoModePrefs::Availability incognito_availability) {
   if (!JumpListUpdater::IsEnabled())
     return true;
 
   // Records the time cost of starting a JumpListUpdater.
   base::ElapsedTimer begin_update_timer;
@@ skipping 34 matching lines @@
       MulDiv(user_max_items_adjusted, kMostVisited, kTotal);
   size_t recently_closed_items = user_max_items_adjusted - most_visited_items;
   if (recently_closed_pages.size() < recently_closed_items) {
     most_visited_items += recently_closed_items - recently_closed_pages.size();
     recently_closed_items = recently_closed_pages.size();
   }
 
   if (most_visited_pages_have_updates) {
     // Delete the content in JumpListIconsMostVisited folder and log the results
     // to UMA.
-    base::FilePath icon_dir_most_visited = icon_dir.DirName().Append(
-        icon_dir.BaseName().value() + FILE_PATH_LITERAL("MostVisited"));
+    base::FilePath icon_dir_most_visited = profile->GetPath().Append(

[grt (UTC plus 2), 2017/05/01 09:22:56]

a Profile* may only be used on the UI thread. you must pass the path over to
this thread rather than the Profile* (for reference, see browser_context.h,
which defines Profile's base class).

[chengx, 2017/05/03 05:47:01]

Done. I've updated to pass the profile path.

+        chrome::kJumpListIconDirname + FILE_PATH_LITERAL("MostVisited"));
 
     DeleteDirectoryContentAndLogResults(icon_dir_most_visited,
                                         kFileDeleteLimit);
 
     // If the directory doesn't exist (we have tried to create it in
     // DeleteDirectoryContentAndLogResults) or is not empty, skip updating the
     // jumplist icons. The jumplist links should be updated anyway, as it
     // doesn't involve disk IO. In this case, Chrome's icon will be used for the
     // new links.
     if (base::DirectoryExists(icon_dir_most_visited) &&
         base::IsDirectoryEmpty(icon_dir_most_visited)) {
       // Create icon files for shortcuts in the "Most Visited" category.
       CreateIconFiles(icon_dir_most_visited, most_visited_pages,
                       most_visited_items);
     }
   }
 
   if (recently_closed_pages_have_updates) {
     // Delete the content in JumpListIconsRecentClosed folder and log the
     // results to UMA.
-    base::FilePath icon_dir_recent_closed = icon_dir.DirName().Append(
-        icon_dir.BaseName().value() + FILE_PATH_LITERAL("RecentClosed"));
+    base::FilePath icon_dir_recent_closed = profile->GetPath().Append(
+        chrome::kJumpListIconDirname + FILE_PATH_LITERAL("RecentClosed"));
 
     DeleteDirectoryContentAndLogResults(icon_dir_recent_closed,
                                         kFileDeleteLimit);
 
     if (base::DirectoryExists(icon_dir_recent_closed) &&
         base::IsDirectoryEmpty(icon_dir_recent_closed)) {
       // Create icon files for shortcuts in the "Recently Closed" category.
       CreateIconFiles(icon_dir_recent_closed, recently_closed_pages,
                       recently_closed_items);
     }
@@ skipping 22 matching lines @@
   if (!UpdateTaskCategory(&jumplist_updater, incognito_availability))
     return false;
 
   // Commit this transaction and send the updated JumpList to Windows.
   return jumplist_updater.CommitUpdate();
 }
 
 // Updates the jumplist, once all the data has been fetched.
 void RunUpdateJumpList(IncognitoModePrefs::Availability incognito_availability,
                        const std::wstring& app_id,
-                       const base::FilePath& icon_dir,
+                       const Profile* profile,
                        base::RefCountedData<JumpListData>* ref_counted_data) {
   JumpListData* data = &ref_counted_data->data;
   ShellLinkItemList local_most_visited_pages;
   ShellLinkItemList local_recently_closed_pages;
   bool most_visited_pages_have_updates;
   bool recently_closed_pages_have_updates;
 
   {
     base::AutoLock auto_lock(data->list_lock_);
     // Make sure we are not out of date: if icon_urls_ is not empty, then
@@ skipping 14 matching lines @@
     data->recently_closed_pages_have_updates_ = false;
   }
 
   if (!most_visited_pages_have_updates && !recently_closed_pages_have_updates)
     return;
 
   // Updates the application JumpList. If it fails, reset the flags to true if
   // they were so that the corresponding JumpList categories will be tried to
   // update again in the next run.
   if (!UpdateJumpList(
-          app_id.c_str(), icon_dir, local_most_visited_pages,
+          app_id.c_str(), profile, local_most_visited_pages,
           local_recently_closed_pages, most_visited_pages_have_updates,
           recently_closed_pages_have_updates, incognito_availability)) {
     base::AutoLock auto_lock(data->list_lock_);
     if (most_visited_pages_have_updates)
       data->most_visited_pages_have_updates_ = true;
     if (recently_closed_pages_have_updates)
       data->recently_closed_pages_have_updates_ = true;
   }
 }
 
@@ skipping 29 matching lines @@
   // When we add this object to the observer list, we save the pointer to this
   // TabRestoreService object. This pointer is used when we remove this object
   // from the observer list.
   sessions::TabRestoreService* tab_restore_service =
       TabRestoreServiceFactory::GetForProfile(profile_);
   if (!tab_restore_service)
     return;
 
   app_id_ =
       shell_integration::win::GetChromiumModelIdForProfile(profile_->GetPath());
-  icon_dir_ = profile_->GetPath().Append(chrome::kJumpListIconDirname);
 
   scoped_refptr<history::TopSites> top_sites =
       TopSitesFactory::GetForProfile(profile_);
   if (top_sites) {
     // TopSites updates itself after a delay. This is especially noticable when
     // your profile is empty. Ask TopSites to update itself when jumplist is
     // initialized.
     top_sites->SyncWithHistory();
     // Register as TopSitesObserver so that we can update ourselves when the
     // TopSites changes.
@@ skipping 265 matching lines @@
   TRACE_EVENT0("browser", "JumpList::DeferredRunUpdate");
   // Check if incognito windows (or normal windows) are disabled by policy.
   IncognitoModePrefs::Availability incognito_availability =
       profile_ ? IncognitoModePrefs::GetAvailability(profile_->GetPrefs())
                : IncognitoModePrefs::ENABLED;
 
   // Post a task to update the JumpList, which consists of 1) delete old icons,
   // 2) create new icons, 3) notify the OS.
   update_jumplist_task_runner_->PostTask(
       FROM_HERE, base::Bind(&RunUpdateJumpList, incognito_availability, app_id_,
-                            icon_dir_, base::RetainedRef(jumplist_data_)));
+                            profile_, base::RetainedRef(jumplist_data_)));
 
   // Post a task to delete JumpListIcons folder as it's no longer needed.
   // Now we have JumpListIconsMostVisited folder and JumpListIconsRecentClosed
   // folder instead.
+  base::FilePath icon_dir =
+      profile_->GetPath().Append(chrome::kJumpListIconDirname);
+
   delete_jumplisticons_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DeleteDirectoryAndLogResults, icon_dir_, kFileDeleteLimit));
+      base::Bind(&DeleteDirectoryAndLogResults, icon_dir, kFileDeleteLimit));
 
   // Post a task to delete JumpListIconsOld folder as it's no longer needed.
-  base::FilePath icon_dir_old = icon_dir_.DirName().Append(
-      icon_dir_.BaseName().value() + FILE_PATH_LITERAL("Old"));
+  base::FilePath icon_dir_old = profile_->GetPath().Append(
+      chrome::kJumpListIconDirname + FILE_PATH_LITERAL("Old"));
 
   delete_jumplisticons_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DeleteDirectoryAndLogResults,
                             std::move(icon_dir_old), kFileDeleteLimit));
 }
 
 void JumpList::TopSitesLoaded(history::TopSites* top_sites) {
 }
 
 void JumpList::TopSitesChanged(history::TopSites* top_sites,
                                ChangeReason change_reason) {
   top_sites->GetMostVisitedURLs(
       base::Bind(&JumpList::OnMostVisitedURLsAvailable,
                  weak_ptr_factory_.GetWeakPtr()),
       false);
 }