Remove packaged app Windows shortcuts when app is uninstalled.

chrome/browser/web_applications/web_app_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 "chrome/browser/web_applications/web_app.h"
 
 #include <shlobj.h>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/gfx/icon_util.h"
 
 namespace {
 
 const FilePath::CharType kIconChecksumFileExt[] = FILE_PATH_LITERAL(".ico.md5");
 
 // Calculates image checksum using MD5.
 void GetImageCheckSum(const SkBitmap& image, base::MD5Digest* digest) {
   DCHECK(digest);
@@ skipping 32 matching lines @@
     return true;
 
   base::MD5Digest downloaded_image_checksum;
   GetImageCheckSum(image, &downloaded_image_checksum);
 
   // Update icon if checksums are not equal.
   return memcmp(&persisted_image_checksum, &downloaded_image_checksum,
                 sizeof(base::MD5Digest)) != 0;
 }
 
-}  // namespace
-
-namespace web_app {
-
-namespace internals {
-
-// Saves |image| to |icon_file| if the file is outdated and refresh shell's
-// icon cache to ensure correct icon is displayed. Returns true if icon_file
-// is up to date or successfully updated.
-bool CheckAndSaveIcon(const FilePath& icon_file, const SkBitmap& image) {
-  if (ShouldUpdateIcon(icon_file, image)) {
-    if (SaveIconWithCheckSum(icon_file, image)) {
-      // Refresh shell's icon cache. This call is quite disruptive as user would
-      // see explorer rebuilding the icon cache. It would be great that we find
-      // a better way to achieve this.
-      SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST | SHCNF_FLUSHNOWAIT,
-                     NULL, NULL);
-    } else {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-bool CreatePlatformShortcut(
-    const FilePath& web_app_path,
-    const FilePath& profile_path,
-    const ShellIntegration::ShortcutInfo& shortcut_info) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
-
+std::vector<FilePath> GetShortcutPaths(bool create_on_desktop,

[Mihai Parparita -not on Chrome, 2012/08/09 01:09:47]

Having so many boolean params makes code harder to read. An enum is most likely
overkill though. Can you just pass in ShortcutInfo (and in
DeletePlatformShortcuts, override the create flags to always make them true)?

[benwells, 2012/08/10 07:10:00]

Done.

+                                       bool create_in_applications_menu,
+                                       bool create_in_quick_launch_bar) {
   // Shortcut paths under which to create shortcuts.
   std::vector<FilePath> shortcut_paths;
 
   // Locations to add to shortcut_paths.
   struct {
     const bool& use_this_location;
     int location_id;
     const wchar_t* sub_dir;
   } locations[] = {
     {
-      shortcut_info.create_on_desktop,
+      create_on_desktop,
       chrome::DIR_USER_DESKTOP,
       NULL
     }, {
-      shortcut_info.create_in_applications_menu,
+      create_in_applications_menu,
       base::DIR_START_MENU,
       NULL
     }, {
-      shortcut_info.create_in_quick_launch_bar,
+      create_in_quick_launch_bar,
       // For Win7, create_in_quick_launch_bar means pinning to taskbar. Use
       // base::PATH_START as a flag for this case.
       (base::win::GetVersion() >= base::win::VERSION_WIN7) ?
           base::PATH_START : base::DIR_APP_DATA,
       (base::win::GetVersion() >= base::win::VERSION_WIN7) ?
           NULL : L"Microsoft\\Internet Explorer\\Quick Launch"
     }
   };
 
   // Populate shortcut_paths.
   for (int i = 0; i < arraysize(locations); ++i) {
     if (locations[i].use_this_location) {
       FilePath path;
 
       // Skip the Win7 case.
       if (locations[i].location_id == base::PATH_START)
         continue;
 
       if (!PathService::Get(locations[i].location_id, &path)) {
-        return false;
+        continue;
       }
 
       if (locations[i].sub_dir != NULL)
         path = path.Append(locations[i].sub_dir);
 
       shortcut_paths.push_back(path);
     }
   }
 
-  bool pin_to_taskbar =
-      shortcut_info.create_in_quick_launch_bar &&
-      (base::win::GetVersion() >= base::win::VERSION_WIN7);
+  return shortcut_paths;
+}
+
+bool ShortcutIsForProfile(const FilePath& shortcut_file_name,
+                          const FilePath& profile_path) {
+  string16 cmd_line_string;
+  if (file_util::ResolveShortcut(shortcut_file_name, NULL, &cmd_line_string)) {
+    cmd_line_string = L"program " + cmd_line_string;
+    CommandLine shortcut_cmd_line = CommandLine::FromString(cmd_line_string);
+    return shortcut_cmd_line.HasSwitch(switches::kProfileDirectory) &&
+           shortcut_cmd_line.GetSwitchValuePath(switches::kProfileDirectory) ==
+               profile_path.BaseName();
+  }
+
+  return false;
+}
+
+std::vector<FilePath> MatchingShortcutsForProfileAndExtension(
+    const FilePath& shortcut_path,
+    const FilePath& profile_path,
+    const string16& shortcut_name) {
+  std::vector<FilePath> shortcut_paths;
+  FilePath base_path = shortcut_path.
+      Append(web_app::internals::GetSanitizedFileName(shortcut_name)).
+      ReplaceExtension(FILE_PATH_LITERAL(".lnk"));
+
+  const int fileNamesToCheck = 10;
+  for (int i = 0; i < fileNamesToCheck; ++i) {
+    FilePath shortcut_file = base_path;
+    if (i) {
+      shortcut_file = shortcut_file.InsertBeforeExtensionASCII(
+          StringPrintf(" (%d)", i));
+    }
+    if (file_util::PathExists(shortcut_file) &&
+        ShortcutIsForProfile(shortcut_file, profile_path)) {
+      shortcut_paths.push_back(shortcut_file);
+    }
+  }
+  return shortcut_paths;
+}
+
+}  // namespace
+
+namespace web_app {
+
+namespace internals {
+
+// Saves |image| to |icon_file| if the file is outdated and refresh shell's
+// icon cache to ensure correct icon is displayed. Returns true if icon_file
+// is up to date or successfully updated.
+bool CheckAndSaveIcon(const FilePath& icon_file, const SkBitmap& image) {
+  if (ShouldUpdateIcon(icon_file, image)) {
+    if (SaveIconWithCheckSum(icon_file, image)) {
+      // Refresh shell's icon cache. This call is quite disruptive as user would
+      // see explorer rebuilding the icon cache. It would be great that we find
+      // a better way to achieve this.
+      SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST | SHCNF_FLUSHNOWAIT,
+                     NULL, NULL);
+    } else {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool CreatePlatformShortcuts(
+    const FilePath& web_app_path,
+    const ShellIntegration::ShortcutInfo& shortcut_info) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+
+  // Shortcut paths under which to create shortcuts.
+  std::vector<FilePath> shortcut_paths = GetShortcutPaths(
+      shortcut_info.create_on_desktop,
+      shortcut_info.create_in_applications_menu,
+      shortcut_info.create_in_quick_launch_bar);
+
+  bool pin_to_taskbar = shortcut_info.create_in_quick_launch_bar &&
+                        (base::win::GetVersion() >= base::win::VERSION_WIN7);
 
   // For Win7's pinning support, any shortcut could be used. So we only create
   // the shortcut file when there is no shortcut file will be created. That is,
   // user only selects "Pin to taskbar".
   if (pin_to_taskbar && shortcut_paths.empty()) {
     // Creates the shortcut in web_app_path in this case.
     shortcut_paths.push_back(web_app_path);
   }
 
-  if (shortcut_paths.empty()) {
+  if (shortcut_paths.empty())
     return false;
-  }
 
   // Ensure web_app_path exists
   if (!file_util::PathExists(web_app_path) &&
       !file_util::CreateDirectory(web_app_path)) {
     return false;
   }
 
   // Generates file name to use with persisted ico and shortcut file.
   FilePath file_name =
       web_app::internals::GetSanitizedFileName(shortcut_info.title);
 
   // Creates an ico file to use with shortcut.
   FilePath icon_file = web_app_path.Append(file_name).ReplaceExtension(
       FILE_PATH_LITERAL(".ico"));
   if (!web_app::internals::CheckAndSaveIcon(icon_file,
         *shortcut_info.favicon.ToSkBitmap())) {
     return false;
   }
 
   FilePath chrome_exe;
-  if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
+  if (!PathService::Get(base::FILE_EXE, &chrome_exe))
     return false;
-  }
 
   // Working directory.
   FilePath chrome_folder = chrome_exe.DirName();
 
   CommandLine cmd_line(CommandLine::NO_PROGRAM);
   cmd_line = ShellIntegration::CommandLineArgsForLauncher(shortcut_info.url,
       shortcut_info.extension_id, shortcut_info.is_platform_app,
       shortcut_info.profile_path);
 
   // TODO(evan): we rely on the fact that command_line_string() is
   // properly quoted for a Windows command line.  The method on
   // CommandLine should probably be renamed to better reflect that
   // fact.
   string16 wide_switches(cmd_line.GetCommandLineString());
 
   // Sanitize description
   string16 description = shortcut_info.description;
   if (description.length() >= MAX_PATH)
     description.resize(MAX_PATH - 1);
 
   // Generates app id from web app url and profile path.
   std::string app_name =
       web_app::GenerateApplicationNameFromInfo(shortcut_info);
   string16 app_id = ShellIntegration::GetAppModelIdForProfile(
-      UTF8ToUTF16(app_name), profile_path);
+      UTF8ToUTF16(app_name), shortcut_info.profile_path);
 
   FilePath shortcut_to_pin;
-
   bool success = true;
   for (size_t i = 0; i < shortcut_paths.size(); ++i) {
     FilePath shortcut_file = shortcut_paths[i].Append(file_name).
         ReplaceExtension(FILE_PATH_LITERAL(".lnk"));
 
     int unique_number =
         file_util::GetUniquePathNumber(shortcut_file, FILE_PATH_LITERAL(""));
     if (unique_number == -1) {
       success = false;
       continue;
@@ skipping 23 matching lines @@
       success &= file_util::TaskbarPinShortcutLink(
           shortcut_to_pin.value().c_str());
     } else {
       success = false;
     }
   }
 
   return success;
 }
 
-void DeletePlatformShortcuts(const FilePath& profile_path,
-                             const std::string& extension_id) {
-  // TODO(benwells): Implement this.
+void DeletePlatformShortcuts(
+    const FilePath& web_app_path,
+    const ShellIntegration::ShortcutInfo& shortcut_info) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+
+  // Get all possible locations for shortcuts.
+  std::vector<FilePath> shortcut_locations = GetShortcutPaths(true, true, true);
+  if (base::win::GetVersion() >= base::win::VERSION_WIN7)
+    shortcut_locations.push_back(web_app_path);
+
+  for (std::vector<FilePath>::const_iterator i = shortcut_locations.begin();
+       i != shortcut_locations.end(); ++i) {
+    std::vector<FilePath> shortcut_files =
+        MatchingShortcutsForProfileAndExtension(*i, shortcut_info.profile_path,
+            shortcut_info.title);
+    for (std::vector<FilePath>::const_iterator j = shortcut_files.begin();
+         j != shortcut_files.end(); ++j) {
+      // Any shortcut could have been pinned, either by chrome or the user, so
+      // they are all unpinned.
+      file_util::TaskbarUnpinShortcutLink(j->value().c_str());
+      file_util::Delete(*j, false);
+    }
+  }
 }
 
 }  // namespace internals
 
 }  // namespace web_app