Remove app shortcuts when app is uninstalled on Linux.

chrome/browser/shell_integration_linux.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/shell_integration_linux.h"
 
 #include <fcntl.h>
 #include <glib.h>
 #include <stdlib.h>
 #include <sys/stat.h>
@@ skipping 136 matching lines @@
     // |shortcut_filename| we'll just undo his action.
     unlinkat(desktop_fd, shortcut_filename.value().c_str(), 0);
   }
 
   if (HANDLE_EINTR(close(desktop_fd)) < 0)
     PLOG(ERROR) << "close";
 
   return true;
 }
 
+void DeleteShortcutOnDesktop(const FilePath& shortcut_filename) {
+  FilePath desktop_path;
+  if (PathService::Get(chrome::DIR_USER_DESKTOP, &desktop_path))
+    file_util::Delete(desktop_path.Append(shortcut_filename), false);
+}
+
 bool CreateShortcutInApplicationsMenu(const FilePath& shortcut_filename,
                                       const std::string& contents) {
   ScopedTempDir temp_dir;
   if (!temp_dir.CreateUniqueTempDir())
     return false;
 
   FilePath temp_file_path = temp_dir.path().Append(shortcut_filename);
 
   int bytes_written = file_util::WriteFile(temp_file_path, contents.data(),
                                            contents.length());
 
   if (bytes_written != static_cast<int>(contents.length()))
     return false;
 
   std::vector<std::string> argv;
   argv.push_back("xdg-desktop-menu");
   argv.push_back("install");
 
   // Always install in user mode, even if someone runs the browser as root
   // (people do that).
   argv.push_back("--mode");
   argv.push_back("user");
 
   argv.push_back(temp_file_path.value());
   int exit_code;
   LaunchXdgUtility(argv, &exit_code);
   return exit_code == 0;
 }
 
+void DeleteShortcutInApplicationsMenu(const FilePath& shortcut_filename) {
+  std::vector<std::string> argv;
+  argv.push_back("xdg-desktop-menu");
+  argv.push_back("uninstall");
+
+  // Uninstall in user mode, to match the install.
+  argv.push_back("--mode");
+  argv.push_back("user");
+
+  // The file does not need to exist anywhere - xdg-desktop-menu will uninstall
+  // items from the menu with a matching name.
+  argv.push_back(shortcut_filename.value());
+  int exit_code;
+  LaunchXdgUtility(argv, &exit_code);
+}
+
 // Quote a string such that it appears as one verbatim argument for the Exec
 // key in a desktop file.
 std::string QuoteArgForDesktopFileExec(const std::string& arg) {
   // http://standards.freedesktop.org/desktop-entry-spec/latest/ar01s06.html
 
   // Quoting is only necessary if the argument has a reserved character.
   if (arg.find_first_of(" \t\n\"'\\><~|&;$*?#()`") == std::string::npos)
     return arg;  // No quoting necessary.
 
   std::string quoted = "\"";
@@ skipping 252 matching lines @@
     if (file_util::PathExists(path)) {
       VLOG(1) << "Found desktop file template at " << path.value();
       return file_util::ReadFileToString(path, output);
     }
   }
 
   LOG(ERROR) << "Could not find desktop file template.";
   return false;
 }
 
-FilePath GetDesktopShortcutFilename(const GURL& url) {
+FilePath GetWebShortcutFilename(const GURL& url) {
   // Use a prefix, because xdg-desktop-menu requires it.
   std::string filename =
       std::string(chrome::kBrowserProcessExecutableName) + "-" + url.spec();
   file_util::ReplaceIllegalCharactersInPath(&filename, '_');
 
   FilePath desktop_path;
   if (!PathService::Get(chrome::DIR_USER_DESKTOP, &desktop_path))
     return FilePath();
 
   FilePath filepath = desktop_path.Append(filename);
   FilePath alternative_filepath(filepath.value() + ".desktop");
   for (size_t i = 1; i < 100; ++i) {
     if (file_util::PathExists(FilePath(alternative_filepath))) {
       alternative_filepath = FilePath(
           filepath.value() + "_" + base::IntToString(i) + ".desktop");
     } else {
       return FilePath(alternative_filepath).BaseName();
     }
   }
 
   return FilePath();
 }
 
+FilePath GetExtensionShortcutFilename(const FilePath& profile_path,
+                                      const std::string& extension_id) {
+  DCHECK(!extension_id.empty());
+
+  // Use a prefix, because xdg-desktop-menu requires it.
+  std::string filename(chrome::kBrowserProcessExecutableName);
+  filename.append("-")
+      .append(extension_id)
+      .append("-")
+      .append(profile_path.BaseName().value());
+  file_util::ReplaceIllegalCharactersInPath(&filename, '_');
+  return FilePath(filename.append(".desktop"));
+}
+
 std::string GetDesktopFileContents(
     const std::string& template_contents,
     const std::string& app_name,
     const GURL& url,
     const std::string& extension_id,
     const bool is_platform_app,
     const FilePath& extension_path,
     const string16& title,
     const std::string& icon_name,
     const FilePath& profile_path) {
@@ skipping 53 matching lines @@
     g_free(exec_c_string);
     StringTokenizer exec_tokenizer(exec_string, " ");
 
     std::string final_path;
     while (exec_tokenizer.GetNext() && exec_tokenizer.token() != "%U") {
       if (!final_path.empty())
         final_path += " ";
       final_path += exec_tokenizer.token();
     }
     CommandLine cmd_line(CommandLine::NO_PROGRAM);
     cmd_line = ShellIntegration::CommandLineArgsForLauncher(

[Mihai Parparita -not on Chrome, 2012/07/10 22:51:27]

Encoding this data in the filename seems ugly (users can see that, right?).

Since we have it in the command-line for the shortcut, can we extract it from
there?

[benwells, 2012/07/10 22:55:51]

It's not visible to users. Currently the filename for shortcuts is something
like chrome-__1.desktop. I don't think iterating through all shortcuts and menu
items, opening them up to look at the shortcuts, is better. I don't know if it
is possible in a desktop environment neutral way for the menus.

         url, extension_id, is_platform_app, profile_path);
     const CommandLine::SwitchMap& switch_map = cmd_line.GetSwitches();
     for (CommandLine::SwitchMap::const_iterator i = switch_map.begin();
          i != switch_map.end(); ++i) {
       if (i->second.empty()) {
         final_path += " --" + i->first;
       } else {
         final_path += " " + QuoteArgForDesktopFileExec("--" + i->first +
                                                        "=" + i->second);
       }
@@ skipping 24 matching lines @@
 
   g_key_file_free(key_file);
   return output_buffer;
 }
 
 bool CreateDesktopShortcut(
     const ShellIntegration::ShortcutInfo& shortcut_info,
     const std::string& shortcut_template) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  FilePath shortcut_filename =
-      ShellIntegrationLinux::GetDesktopShortcutFilename(shortcut_info.url);
+  FilePath shortcut_filename;
+  if (!shortcut_info.extension_id.empty()) {
+    shortcut_filename = GetExtensionShortcutFilename(
+        shortcut_info.profile_path, shortcut_info.extension_id);
+    // For extensions we do not want duplicate shortcuts. So, delete any that
+    // already exist and replace them.
+    if (shortcut_info.create_on_desktop)
+      DeleteShortcutOnDesktop(shortcut_filename);
+    if (shortcut_info.create_in_applications_menu)
+      DeleteShortcutInApplicationsMenu(shortcut_filename);
+  } else {
+    shortcut_filename = GetWebShortcutFilename(shortcut_info.url);
+  }
   if (shortcut_filename.empty())
     return false;
 
   std::string icon_name = CreateShortcutIcon(shortcut_info, shortcut_filename);
 
   std::string app_name =
       web_app::GenerateApplicationNameFromInfo(shortcut_info);
   std::string contents = ShellIntegrationLinux::GetDesktopFileContents(
       shortcut_template,
       app_name,
@@ skipping 10 matching lines @@
   if (shortcut_info.create_on_desktop)
     success = CreateShortcutOnDesktop(shortcut_filename, contents);
 
   if (shortcut_info.create_in_applications_menu)
     success = CreateShortcutInApplicationsMenu(shortcut_filename, contents) &&
               success;
 
   return success;
 }
 
+void DeleteDesktopShortcuts(const FilePath& profile_path,
+                            const std::string& extension_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  FilePath shortcut_filename = GetExtensionShortcutFilename(
+      profile_path, extension_id);
+  DCHECK(!shortcut_filename.empty());
+
+  DeleteShortcutOnDesktop(shortcut_filename);
+  DeleteShortcutInApplicationsMenu(shortcut_filename);
+}
+
 }  // namespace ShellIntegrationLinux