Create Linux platform app shortcuts to run in their own process.

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.h"
+#include "chrome/browser/shell_integration_linux.h"
 
 #include <fcntl.h>
 #include <glib.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <string>
 #include <vector>
@@ skipping 90 matching lines @@
   argv.push_back(base::IntToString(bitmap->width()));
 
   argv.push_back(temp_file_path.value());
   std::string icon_name = temp_file_path.BaseName().RemoveExtension().value();
   argv.push_back(icon_name);
   int exit_code;
   LaunchXdgUtility(argv, &exit_code);
   return icon_name;
 }
 
-void CreateShortcutOnDesktop(const FilePath& shortcut_filename,
+bool CreateShortcutOnDesktop(const FilePath& shortcut_filename,
                              const std::string& contents) {
-  // TODO(phajdan.jr): Report errors from this function, possibly as infobars.
-
   // Make sure that we will later call openat in a secure way.
   DCHECK_EQ(shortcut_filename.BaseName().value(), shortcut_filename.value());
 
   FilePath desktop_path;
   if (!PathService::Get(chrome::DIR_USER_DESKTOP, &desktop_path))
-    return;
+    return false;
 
   int desktop_fd = open(desktop_path.value().c_str(), O_RDONLY | O_DIRECTORY);
   if (desktop_fd < 0)
-    return;
+    return false;
 
   int fd = openat(desktop_fd, shortcut_filename.value().c_str(),
                   O_CREAT | O_EXCL | O_WRONLY,
                   S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
   if (fd < 0) {
     if (HANDLE_EINTR(close(desktop_fd)) < 0)
       PLOG(ERROR) << "close";
-    return;
+    return false;
   }
 
   ssize_t bytes_written = file_util::WriteFileDescriptor(fd, contents.data(),
                                                          contents.length());
   if (HANDLE_EINTR(close(fd)) < 0)
     PLOG(ERROR) << "close";
 
   if (bytes_written != static_cast<ssize_t>(contents.length())) {
     // Delete the file. No shortuct is better than corrupted one. Use unlinkat
     // to make sure we're deleting the file in the directory we think we are.
     // Even if an attacker manager to put something other at
     // |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 CreateShortcutInApplicationsMenu(const FilePath& shortcut_filename,
+bool CreateShortcutInApplicationsMenu(const FilePath& shortcut_filename,
                                       const std::string& contents) {
-  // TODO(phajdan.jr): Report errors from this function, possibly as infobars.
   ScopedTempDir temp_dir;
   if (!temp_dir.CreateUniqueTempDir())
-    return;
+    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;
+    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;
 }
 
 // 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.
@@ skipping 276 matching lines @@
 
   return FilePath();
 }
 
 // static
 std::string ShellIntegration::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& web_app_path,
+    const FilePath& extension_path,
     const string16& title,
     const std::string& icon_name) {
   if (template_contents.empty())
     return std::string(kXdgOpenShebang) + "\n";
 
   // 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;
   // Loading the data will strip translations and comments from the desktop
@@ skipping 44 matching lines @@
     std::string exec_string(exec_c_string);
     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 =
-        ShellIntegration::CommandLineArgsForLauncher(url, extension_id);
+    CommandLine cmd_line(CommandLine::NO_PROGRAM);
+    if (is_platform_app) {
+      cmd_line = ShellIntegration::CommandLineArgsForPlatformApp(
+          extension_id, web_app_path, extension_path);
+    } else {
+      cmd_line = ShellIntegration::CommandLineArgsForLauncher(
+          url, extension_id);
+    }
     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 19 matching lines @@
   if (data_dump) {
     output_buffer += data_dump;
     g_free(data_dump);
   }
 
   g_key_file_free(key_file);
   return output_buffer;
 }
 
 // static
-void ShellIntegration::CreateDesktopShortcut(
-    const ShortcutInfo& shortcut_info, const std::string& shortcut_template) {
-  // TODO(phajdan.jr): Report errors from this function, possibly as infobars.
+bool ShellIntegration::CreateDesktopShortcut(
+    const ShortcutInfo& shortcut_info,
+    const std::string& shortcut_template) {
+  DCHECK(!shortcut_info.is_platform_app);
+  DCHECK(shortcut_info.extension_id.empty());
 
+  return ShellIntegrationLinux::CreateDesktopShortcutForChromeApp(
+      shortcut_info, FilePath(), shortcut_template);
+}
+
+namespace ShellIntegrationLinux {
+
+bool CreateDesktopShortcutForChromeApp(
+    const ShellIntegration::ShortcutInfo& shortcut_info,
+    const FilePath& web_app_path,
+    const std::string& shortcut_template) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  FilePath shortcut_filename = GetDesktopShortcutFilename(shortcut_info.url);
+  FilePath shortcut_filename = ShellIntegration::GetDesktopShortcutFilename(
+      shortcut_info.url);
   if (shortcut_filename.empty())
-    return;
+    return false;
 
   std::string icon_name = CreateShortcutIcon(shortcut_info, shortcut_filename);
 
   std::string app_name =
       web_app::GenerateApplicationNameFromInfo(shortcut_info);
-  std::string contents = GetDesktopFileContents(
+  std::string contents = ShellIntegration::GetDesktopFileContents(
       shortcut_template,
       app_name,
       shortcut_info.url,
       shortcut_info.extension_id,
+      shortcut_info.is_platform_app,
+      web_app_path,
+      shortcut_info.extension_path,
       shortcut_info.title,
       icon_name);
 
+  bool success = true;
+
   if (shortcut_info.create_on_desktop)
-    CreateShortcutOnDesktop(shortcut_filename, contents);
+    success = CreateShortcutOnDesktop(shortcut_filename, contents);
 
   if (shortcut_info.create_in_applications_menu)
-    CreateShortcutInApplicationsMenu(shortcut_filename, contents);
+    success = CreateShortcutInApplicationsMenu(shortcut_filename, contents) &&
+              success;
+
+  return success;
 }
+
+}  // namespace ShellIntegrationLinux