Application shortcuts in Linux are now installed into a "Chrome Apps" folder.

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 155 matching lines @@
 
   return true;
 }
 
 void DeleteShortcutOnDesktop(const base::FilePath& shortcut_filename) {
   base::FilePath desktop_path;
   if (PathService::Get(base::DIR_USER_DESKTOP, &desktop_path))
     file_util::Delete(desktop_path.Append(shortcut_filename), false);
 }
 
+// Creates a shortcut with |shortcut_filename| and |contents| in the system
+// applications menu. If |directory_filename| is non-empty, creates a sub-menu
+// with |directory_filename| and |directory_contents|, and stores the shortcut
+// under the sub-menu.
 bool CreateShortcutInApplicationsMenu(const base::FilePath& shortcut_filename,
-                                      const std::string& contents) {
+                                      const std::string& contents,
+                                      const base::FilePath& directory_filename,
+                                      const std::string& directory_contents) {
   base::ScopedTempDir temp_dir;
   if (!temp_dir.CreateUniqueTempDir())
     return false;
 
+  base::FilePath temp_directory_path;
+  if (!directory_filename.empty()) {
+    temp_directory_path = temp_dir.path().Append(directory_filename);
+
+    int bytes_written = file_util::WriteFile(temp_directory_path,
+                                             directory_contents.data(),
+                                             directory_contents.length());
+
+    if (bytes_written != static_cast<int>(directory_contents.length()))
+      return false;
+  }
+
   base::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");
 
+  // If provided, install the shortcut file inside the given directory.
+  if (!directory_filename.empty())
+    argv.push_back(temp_directory_path.value());
   argv.push_back(temp_file_path.value());
   int exit_code;
   LaunchXdgUtility(argv, &exit_code);
   return exit_code == 0;
 }
 
-void DeleteShortcutInApplicationsMenu(const base::FilePath& shortcut_filename) {
+void DeleteShortcutInApplicationsMenu(
+    const base::FilePath& shortcut_filename,
+    const base::FilePath& directory_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.
+  // If |directory_filename| is supplied, this will also remove the item from
+  // the directory, and remove the directory if it is empty.
+  if (!directory_filename.empty())
+    argv.push_back(directory_filename.value());
   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
 
@@ skipping 21 matching lines @@
 }
 
 const char kDesktopEntry[] = "Desktop Entry";
 
 const char kXdgOpenShebang[] = "#!/usr/bin/env xdg-open";
 
 const char kXdgSettings[] = "xdg-settings";
 const char kXdgSettingsDefaultBrowser[] = "default-web-browser";
 const char kXdgSettingsDefaultSchemeHandler[] = "default-url-scheme-handler";
 
+const char kDirectoryFilename[] = "chrome-apps.directory";
+
 }  // namespace
 
 namespace {
 
 // Utility function to get the path to the version of a script shipped with
 // Chrome. |script| gives the name of the script. |chrome_version| returns the
 // path to the Chrome version of the script, and the return value of the
 // function is true if the function is successful and the Chrome version is
 // not the script found on the PATH.
 bool GetChromeVersionOfScript(const std::string& script,
@@ skipping 420 matching lines @@
     } else {
       output_buffer += data_dump;
     }
     g_free(data_dump);
   }
 
   g_key_file_free(key_file);
   return output_buffer;
 }
 
+std::string GetDirectoryFileContents(const string16& title,
+                                     const std::string& icon_name) {
+  // See http://standards.freedesktop.org/desktop-entry-spec/latest/
+  GKeyFile* key_file = g_key_file_new();
+
+  g_key_file_set_string(key_file, kDesktopEntry, "Version", "1.0");
+  g_key_file_set_string(key_file, kDesktopEntry, "Type", "Directory");
+  std::string final_title = UTF16ToUTF8(title);
+  g_key_file_set_string(key_file, kDesktopEntry, "Name", final_title.c_str());
+  if (!icon_name.empty()) {
+    g_key_file_set_string(key_file, kDesktopEntry, "Icon", icon_name.c_str());
+  } else {
+    g_key_file_set_string(key_file, kDesktopEntry, "Icon",
+                          GetIconName().c_str());
+  }
+
+  gsize length = 0;
+  gchar* data_dump = g_key_file_to_data(key_file, &length, NULL);
+  std::string output_buffer;
+  if (data_dump) {
+    // If strlen(data_dump[0]) == 0, this check will fail.
+    if (data_dump[0] == '\n') {
+      // Older versions of glib produce a leading newline. If this is the case,
+      // remove it to avoid double-newline after the shebang.
+      output_buffer += (data_dump + 1);
+    } else {
+      output_buffer += data_dump;
+    }
+    g_free(data_dump);
+  }
+
+  g_key_file_free(key_file);
+  return output_buffer;
+}
+
 bool CreateDesktopShortcut(
     const ShellIntegration::ShortcutInfo& shortcut_info,
     const ShellIntegration::ShortcutLocations& creation_locations) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   base::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 (creation_locations.on_desktop)
       DeleteShortcutOnDesktop(shortcut_filename);
     if (creation_locations.in_applications_menu || creation_locations.hidden)
-      DeleteShortcutInApplicationsMenu(shortcut_filename);
+      DeleteShortcutInApplicationsMenu(shortcut_filename, base::FilePath());
   } 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);
@@ skipping 17 matching lines @@
         shortcut_info.title,
         icon_name,
         shortcut_info.profile_path,
         false);
     success = CreateShortcutOnDesktop(shortcut_filename, contents);
   }
 
   // The 'in_applications_menu' and 'hidden' locations are actually the same
   // place ('applications').
   if (creation_locations.in_applications_menu || creation_locations.hidden) {
+    base::FilePath directory_filename;
+    std::string directory_contents;
+    if (!creation_locations.applications_menu_subdir.empty()) {
+      directory_filename = base::FilePath(kDirectoryFilename);
+      directory_contents = ShellIntegrationLinux::GetDirectoryFileContents(
+          creation_locations.applications_menu_subdir, "");
+    }
     // Set NoDisplay=true if hidden but not in_applications_menu. This will hide
     // the application from user-facing menus.
     std::string contents = ShellIntegrationLinux::GetDesktopFileContents(
         chrome_exe_path,
         app_name,
         shortcut_info.url,
         shortcut_info.extension_id,
         shortcut_info.extension_path,
         shortcut_info.title,
         icon_name,
         shortcut_info.profile_path,
         !creation_locations.in_applications_menu);
-    success = CreateShortcutInApplicationsMenu(shortcut_filename, contents) &&
-              success;
+    success = CreateShortcutInApplicationsMenu(
+        shortcut_filename, contents, directory_filename, directory_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);
+  // Delete shortcuts from |kDirectoryFilename|.
+  // Note that it is possible that shortcuts were not created in the Chrome Apps
+  // directory (depending on the value of |applications_menu_subdir| when they
+  // were created). It doesn't matter: this will still delete the shortcut even
+  // if it isn't in the directory.
+  DeleteShortcutInApplicationsMenu(shortcut_filename,
+                                   base::FilePath(kDirectoryFilename));
 }
 
 }  // namespace ShellIntegrationLinux