On Linux, automatically create app shortcuts on install or update.

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 376 matching lines @@
     // xdg-settings failed: we can't determine or set the default browser.
     return ShellIntegration::UNKNOWN_DEFAULT;
   }
 
   // Allow any reply that starts with "yes".
   return (reply.find("yes") == 0) ? ShellIntegration::IS_DEFAULT :
                                     ShellIntegration::NOT_DEFAULT;
 #endif
 }
 
+// Get the value of NoDisplay from the [Desktop Entry] section of a .desktop
+// file, given in |shortcut_contents|. If the key is not found, returns false.
+bool GetNoDisplayFromDesktopFile(const std::string& shortcut_contents) {
+  GKeyFile* key_file = g_key_file_new();
+  GError* err = NULL;
+  if (!g_key_file_load_from_data(key_file, shortcut_contents.c_str(),
+                                 shortcut_contents.size(), G_KEY_FILE_NONE,
+                                 &err)) {
+    LOG(WARNING) << "Unable to read desktop file template: " << err->message;
+    g_error_free(err);
+    return false;
+  }
+
+  bool nodisplay = false;
+  char* nodisplay_c_string = g_key_file_get_string(key_file, kDesktopEntry,
+                                                   "NoDisplay", &err);
+  if (nodisplay_c_string) {
+    if (!g_strcmp0(nodisplay_c_string, "true"))
+      nodisplay = true;
+    g_free(nodisplay_c_string);
+  }
+
+  g_key_file_free(key_file);
+  return nodisplay;
+}
+
 } // namespace
 
 // static
 ShellIntegration::DefaultWebClientSetPermission
     ShellIntegration::CanSetAsDefaultBrowser() {
   return SET_DEFAULT_UNATTENDED;
 }
 
 // static
 bool ShellIntegration::SetAsDefaultBrowser() {
@@ skipping 43 matching lines @@
   // Allow $CHROME_DESKTOP to override the built-in value, so that development
   // versions can set themselves as the default without interfering with
   // non-official, packaged versions using the built-in value.
   std::string name;
   if (env->GetVar("CHROME_DESKTOP", &name) && !name.empty())
     return name;
   return "chromium-browser.desktop";
 #endif
 }
 
-bool GetDesktopShortcutTemplate(base::Environment* env,
-                                std::string* output) {
+bool GetExistingDesktopShortcutContents(base::Environment* env,
+                                        const base::FilePath& desktop_filename,
+                                        std::string* output) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   std::vector<base::FilePath> search_paths;
 
   // Search paths as specified in the XDG Base Directory Specification.
   // http://standards.freedesktop.org/basedir-spec/latest/
   std::string xdg_data_home;
   std::string home;
   if (env->GetVar("XDG_DATA_HOME", &xdg_data_home) &&
       !xdg_data_home.empty()) {
     search_paths.push_back(base::FilePath(xdg_data_home));
   } else if (env->GetVar("HOME", &home) && !home.empty()) {
     search_paths.push_back(base::FilePath(home).Append(".local").Append(
         "share"));
   }
 
   std::string xdg_data_dirs;
   if (env->GetVar("XDG_DATA_DIRS", &xdg_data_dirs) &&
       !xdg_data_dirs.empty()) {
     base::StringTokenizer tokenizer(xdg_data_dirs, ":");
     while (tokenizer.GetNext()) {
       base::FilePath data_dir(tokenizer.token());
       search_paths.push_back(data_dir);
     }
   } else {
     search_paths.push_back(base::FilePath("/usr/share"));
     search_paths.push_back(base::FilePath("/usr/local/share"));
   }
 
-  std::string template_filename(GetDesktopName(env));
   for (std::vector<base::FilePath>::const_iterator i = search_paths.begin();
        i != search_paths.end(); ++i) {
-    base::FilePath path = i->Append("applications").Append(template_filename);
-    VLOG(1) << "Looking for desktop file template in " << path.value();
+    base::FilePath path = i->Append("applications").Append(desktop_filename);
+    VLOG(1) << "Looking for desktop file in " << path.value();
     if (file_util::PathExists(path)) {
-      VLOG(1) << "Found desktop file template at " << path.value();
+      VLOG(1) << "Found desktop file at " << path.value();
       return file_util::ReadFileToString(path, output);
     }
   }
 
-  LOG(ERROR) << "Could not find desktop file template.";
   return false;
 }
 
+bool GetDesktopShortcutTemplate(base::Environment* env,
+                                std::string* output) {
+  base::FilePath template_filename(GetDesktopName(env));
+  if (GetExistingDesktopShortcutContents(env, template_filename, output)) {
+    return true;
+  } else {
+    LOG(ERROR) << "Could not find desktop file " << template_filename.value()
+               << ".";
+    return false;
+  }
+}
+
 base::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, '_');
 
   base::FilePath desktop_path;
   if (!PathService::Get(base::DIR_USER_DESKTOP, &desktop_path))
     return base::FilePath();
 
@@ skipping 26 matching lines @@
 }
 
 std::string GetDesktopFileContents(
     const std::string& template_contents,
     const std::string& app_name,
     const GURL& url,
     const std::string& extension_id,
     const base::FilePath& extension_path,
     const string16& title,
     const std::string& icon_name,
-    const base::FilePath& profile_path) {
+    const base::FilePath& profile_path,
+    bool no_display) {
   // Although not required by the spec, Nautilus on Ubuntu Karmic creates its
   // launchers with an xdg-open shebang. Follow that convention.
   std::string output_buffer = std::string(kXdgOpenShebang) + "\n";
   if (template_contents.empty())
     return output_buffer;
 
   // See http://standards.freedesktop.org/desktop-entry-spec/latest/
   // http://developer.gnome.org/glib/unstable/glib-Key-value-file-parser.html
   GKeyFile* key_file = g_key_file_new();
   GError* err = NULL;
@@ skipping 80 matching lines @@
       }
     }
 
     g_key_file_set_string(key_file, kDesktopEntry, "Exec", final_path.c_str());
   }
 
   // Set the "Icon" key.
   if (!icon_name.empty())
     g_key_file_set_string(key_file, kDesktopEntry, "Icon", icon_name.c_str());
 
+  // Set the "NoDisplay" key.
+  if (no_display)
+    g_key_file_set_string(key_file, kDesktopEntry, "NoDisplay", "true");
+
 #if defined(TOOLKIT_GTK)
   std::string wmclass = web_app::GetWMClassFromAppName(app_name);
   g_key_file_set_string(key_file, kDesktopEntry, "StartupWMClass",
                         wmclass.c_str());
 #endif
 
   length = 0;
   gchar* data_dump = g_key_file_to_data(key_file, &length, NULL);
   if (data_dump) {
     // If strlen(data_dump[0]) == 0, this check will fail.
@@ skipping 28 matching lines @@
     if (creation_locations.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);
 
+  // If we are to create the shortcut in neither the desktop nor applications
+  // menu, we still want to register the app, so we create a shortcut with
+  // NoDisplay=true.
+  bool no_display = (!creation_locations.on_desktop &&

[benwells, 2013/03/05 04:32:38]

Note for later: this feels a bit strange. It would be better to have a special
location for this.

Having a platform specific ShortcutLocation type would let us do this cleanly.

[Matt Giuca, 2013/03/05 05:25:44]

Well it wouldn't necessarily need to be platform-specific. We could add a new
Boolean called "hidden" which is a platform-neutral way of saying "create a
shortcut such that the system knows about it, but it is not visible to the user
in menus or search results." That would also solve the "delete Desktop shortcut"
bug identified earlier.

Now I'm starting to like this idea. I think I'll just do it in this CL.

+                     !creation_locations.in_applications_menu);
+
   std::string app_name =
       web_app::GenerateApplicationNameFromInfo(shortcut_info);
   std::string contents = ShellIntegrationLinux::GetDesktopFileContents(
       shortcut_template,
       app_name,
       shortcut_info.url,
       shortcut_info.extension_id,
       shortcut_info.extension_path,
       shortcut_info.title,
       icon_name,
-      shortcut_info.profile_path);
+      shortcut_info.profile_path,
+      no_display);
 
   bool success = true;
 
   if (creation_locations.on_desktop)
     success = CreateShortcutOnDesktop(shortcut_filename, contents);
 
-  if (creation_locations.in_applications_menu)
+  // If no_display is true, CreateShortcutInApplicationsMenu will install the
+  // shortcut, but it will not appear in menus or be searchable by users.
+  if (creation_locations.in_applications_menu || no_display)
     success = CreateShortcutInApplicationsMenu(shortcut_filename, contents) &&
               success;
 
   return success;
 }
 
 void DeleteDesktopShortcuts(const base::FilePath& profile_path,
                             const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   base::FilePath shortcut_filename = GetExtensionShortcutFilename(
       profile_path, extension_id);
   DCHECK(!shortcut_filename.empty());
 
   DeleteShortcutOnDesktop(shortcut_filename);
   DeleteShortcutInApplicationsMenu(shortcut_filename);
 }
 
+ShellIntegration::ShortcutLocations DesktopShortcutLocations(
+    base::Environment* env, const base::FilePath& profile_path,
+    const std::string& extension_id) {

[benwells, 2013/03/05 04:32:38]

Nit: one parameter per line.

[Matt Giuca, 2013/03/06 06:29:51]

Done.

+  base::FilePath desktop_path;
+  // If Get returns false, just leave desktop_path empty.
+  PathService::Get(base::DIR_USER_DESKTOP, &desktop_path);
+  return DesktopShortcutLocations(env, profile_path, extension_id,
+                                  desktop_path);
+}
+
+ShellIntegration::ShortcutLocations DesktopShortcutLocations(
+    base::Environment* env, const base::FilePath& profile_path,
+    const std::string& extension_id, const base::FilePath& desktop_path) {

[benwells, 2013/03/05 04:32:38]

Nit: one parameter per line.

[Matt Giuca, 2013/03/06 06:29:51]

Done.

+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  base::FilePath shortcut_filename = GetExtensionShortcutFilename(
+      profile_path, extension_id);
+  DCHECK(!shortcut_filename.empty());
+  ShellIntegration::ShortcutLocations locations;
+
+  // Determine whether there is a shortcut on desktop.
+  if (!desktop_path.empty()) {
+    locations.on_desktop =
+        file_util::PathExists(desktop_path.Append(shortcut_filename));
+  }
+
+  // Determine whether there is a shortcut in applications menu that *does not*
+  // have NoDisplay=true.
+  std::string shortcut_contents;
+  if (GetExistingDesktopShortcutContents(env, shortcut_filename,
+                                         &shortcut_contents)) {
+    locations.in_applications_menu =
+        !GetNoDisplayFromDesktopFile(shortcut_contents);
+  }
+
+  return locations;
+}
+
 }  // namespace ShellIntegrationLinux