chrome/browser/shell_integration_linux.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/shell_integration_linux.h"
   6
   7 #include <fcntl.h>
   8
   9 #if defined(USE_GLIB)
  10 #include <glib.h>
  11 #endif
  12
  13 #include <stdlib.h>
  14 #include <sys/stat.h>
  15 #include <sys/types.h>
  16 #include <unistd.h>
  17
  18 #include <string>
  19 #include <vector>
  20
  21 #include "base/base_paths.h"
  22 #include "base/command_line.h"
  23 #include "base/environment.h"
  24 #include "base/files/file_enumerator.h"
  25 #include "base/files/file_path.h"
  26 #include "base/files/file_util.h"
  27 #include "base/files/scoped_temp_dir.h"
  28 #include "base/i18n/file_util_icu.h"
  29 #include "base/memory/ref_counted_memory.h"
  30 #include "base/memory/scoped_ptr.h"
  31 #include "base/message_loop/message_loop.h"
  32 #include "base/nix/xdg_util.h"
  33 #include "base/path_service.h"
  34 #include "base/posix/eintr_wrapper.h"
  35 #include "base/process/kill.h"
  36 #include "base/process/launch.h"
  37 #include "base/strings/string_number_conversions.h"
  38 #include "base/strings/string_tokenizer.h"
  39 #include "base/strings/string_util.h"
  40 #include "base/strings/utf_string_conversions.h"
  41 #include "base/threading/thread.h"
  42 #include "base/threading/thread_restrictions.h"
  43 #include "build/build_config.h"
  44 #include "chrome/browser/shell_integration.h"
  45 #include "chrome/common/channel_info.h"
  46 #include "chrome/common/chrome_constants.h"
  47 #include "chrome/common/chrome_switches.h"
  48 #include "components/version_info/version_info.h"
  49 #include "content/public/browser/browser_thread.h"
  50 #include "grit/chrome_unscaled_resources.h"
  51 #include "ui/base/resource/resource_bundle.h"
  52 #include "ui/gfx/image/image_family.h"
  53 #include "url/gurl.h"
  54
  55 using content::BrowserThread;
  56
  57 namespace {
  58
  59 // The Categories for the App Launcher desktop shortcut. Should be the same as
  60 // the Chrome desktop shortcut, so they are in the same sub-menu.
  61 const char kAppListCategories[] = "Network;WebBrowser;";
  62
  63 // Helper to launch xdg scripts. We don't want them to ask any questions on the
  64 // terminal etc. The function returns true if the utility launches and exits
  65 // cleanly, in which case |exit_code| returns the utility's exit code.
  66 bool LaunchXdgUtility(const std::vector<std::string>& argv, int* exit_code) {
  67   // xdg-settings internally runs xdg-mime, which uses mv to move newly-created
  68   // files on top of originals after making changes to them. In the event that
  69   // the original files are owned by another user (e.g. root, which can happen
  70   // if they are updated within sudo), mv will prompt the user to confirm if
  71   // standard input is a terminal (otherwise it just does it). So make sure it's
  72   // not, to avoid locking everything up waiting for mv.
  73   *exit_code = EXIT_FAILURE;
  74   int devnull = open("/dev/null", O_RDONLY);
  75   if (devnull < 0)
  76     return false;
  77   base::FileHandleMappingVector no_stdin;
  78   no_stdin.push_back(std::make_pair(devnull, STDIN_FILENO));
  79
  80   base::LaunchOptions options;
  81   options.fds_to_remap = &no_stdin;
  82   base::Process process = base::LaunchProcess(argv, options);
  83   close(devnull);
  84   if (!process.IsValid())
  85     return false;
  86   return process.WaitForExit(exit_code);
  87 }
  88
  89 std::string CreateShortcutIcon(const gfx::ImageFamily& icon_images,
  90                                const base::FilePath& shortcut_filename) {
  91   if (icon_images.empty())
  92     return std::string();
  93
  94   // TODO(phajdan.jr): Report errors from this function, possibly as infobars.
  95   base::ScopedTempDir temp_dir;
  96   if (!temp_dir.CreateUniqueTempDir())
  97     return std::string();
  98
  99   base::FilePath temp_file_path = temp_dir.path().Append(
 100       shortcut_filename.ReplaceExtension("png"));
 101   std::string icon_name = temp_file_path.BaseName().RemoveExtension().value();
 102
 103   for (gfx::ImageFamily::const_iterator it = icon_images.begin();
 104        it != icon_images.end(); ++it) {
 105     int width = it->Width();
 106     scoped_refptr<base::RefCountedMemory> png_data = it->As1xPNGBytes();
 107     if (png_data->size() == 0) {
 108       // If the bitmap could not be encoded to PNG format, skip it.
 109       LOG(WARNING) << "Could not encode icon " << icon_name << ".png at size "
 110                    << width << ".";
 111       continue;
 112     }
 113     int bytes_written = base::WriteFile(temp_file_path,
 114                                         png_data->front_as<char>(),
 115                                         png_data->size());
 116
 117     if (bytes_written != static_cast<int>(png_data->size()))
 118       return std::string();
 119
 120     std::vector<std::string> argv;
 121     argv.push_back("xdg-icon-resource");
 122     argv.push_back("install");
 123
 124     // Always install in user mode, even if someone runs the browser as root
 125     // (people do that).
 126     argv.push_back("--mode");
 127     argv.push_back("user");
 128
 129     argv.push_back("--size");
 130     argv.push_back(base::IntToString(width));
 131
 132     argv.push_back(temp_file_path.value());
 133     argv.push_back(icon_name);
 134     int exit_code;
 135     if (!LaunchXdgUtility(argv, &exit_code) || exit_code) {
 136       LOG(WARNING) << "Could not install icon " << icon_name << ".png at size "
 137                    << width << ".";
 138     }
 139   }
 140   return icon_name;
 141 }
 142
 143 bool CreateShortcutOnDesktop(const base::FilePath& shortcut_filename,
 144                              const std::string& contents) {
 145   // Make sure that we will later call openat in a secure way.
 146   DCHECK_EQ(shortcut_filename.BaseName().value(), shortcut_filename.value());
 147
 148   base::FilePath desktop_path;
 149   if (!PathService::Get(base::DIR_USER_DESKTOP, &desktop_path))
 150     return false;
 151
 152   int desktop_fd = open(desktop_path.value().c_str(), O_RDONLY | O_DIRECTORY);
 153   if (desktop_fd < 0)
 154     return false;
 155
 156   int fd = openat(desktop_fd, shortcut_filename.value().c_str(),
 157                   O_CREAT | O_EXCL | O_WRONLY,
 158                   S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
 159   if (fd < 0) {
 160     if (IGNORE_EINTR(close(desktop_fd)) < 0)
 161       PLOG(ERROR) << "close";
 162     return false;
 163   }
 164
 165   if (!base::WriteFileDescriptor(fd, contents.c_str(), contents.size())) {
 166     // Delete the file. No shortuct is better than corrupted one. Use unlinkat
 167     // to make sure we're deleting the file in the directory we think we are.
 168     // Even if an attacker manager to put something other at
 169     // |shortcut_filename| we'll just undo his action.
 170     unlinkat(desktop_fd, shortcut_filename.value().c_str(), 0);
 171   }
 172
 173   if (IGNORE_EINTR(close(fd)) < 0)
 174     PLOG(ERROR) << "close";
 175
 176   if (IGNORE_EINTR(close(desktop_fd)) < 0)
 177     PLOG(ERROR) << "close";
 178
 179   return true;
 180 }
 181
 182 void DeleteShortcutOnDesktop(const base::FilePath& shortcut_filename) {
 183   base::FilePath desktop_path;
 184   if (PathService::Get(base::DIR_USER_DESKTOP, &desktop_path))
 185     base::DeleteFile(desktop_path.Append(shortcut_filename), false);
 186 }
 187
 188 // Creates a shortcut with |shortcut_filename| and |contents| in the system
 189 // applications menu. If |directory_filename| is non-empty, creates a sub-menu
 190 // with |directory_filename| and |directory_contents|, and stores the shortcut
 191 // under the sub-menu.
 192 bool CreateShortcutInApplicationsMenu(const base::FilePath& shortcut_filename,
 193                                       const std::string& contents,
 194                                       const base::FilePath& directory_filename,
 195                                       const std::string& directory_contents) {
 196   base::ScopedTempDir temp_dir;
 197   if (!temp_dir.CreateUniqueTempDir())
 198     return false;
 199
 200   base::FilePath temp_directory_path;
 201   if (!directory_filename.empty()) {
 202     temp_directory_path = temp_dir.path().Append(directory_filename);
 203
 204     int bytes_written = base::WriteFile(temp_directory_path,
 205                                         directory_contents.data(),
 206                                         directory_contents.length());
 207
 208     if (bytes_written != static_cast<int>(directory_contents.length()))
 209       return false;
 210   }
 211
 212   base::FilePath temp_file_path = temp_dir.path().Append(shortcut_filename);
 213
 214   int bytes_written = base::WriteFile(temp_file_path, contents.data(),
 215                                       contents.length());
 216
 217   if (bytes_written != static_cast<int>(contents.length()))
 218     return false;
 219
 220   std::vector<std::string> argv;
 221   argv.push_back("xdg-desktop-menu");
 222   argv.push_back("install");
 223
 224   // Always install in user mode, even if someone runs the browser as root
 225   // (people do that).
 226   argv.push_back("--mode");
 227   argv.push_back("user");
 228
 229   // If provided, install the shortcut file inside the given directory.
 230   if (!directory_filename.empty())
 231     argv.push_back(temp_directory_path.value());
 232   argv.push_back(temp_file_path.value());
 233   int exit_code;
 234   LaunchXdgUtility(argv, &exit_code);
 235   return exit_code == 0;
 236 }
 237
 238 void DeleteShortcutInApplicationsMenu(
 239     const base::FilePath& shortcut_filename,
 240     const base::FilePath& directory_filename) {
 241   std::vector<std::string> argv;
 242   argv.push_back("xdg-desktop-menu");
 243   argv.push_back("uninstall");
 244
 245   // Uninstall in user mode, to match the install.
 246   argv.push_back("--mode");
 247   argv.push_back("user");
 248
 249   // The file does not need to exist anywhere - xdg-desktop-menu will uninstall
 250   // items from the menu with a matching name.
 251   // If |directory_filename| is supplied, this will also remove the item from
 252   // the directory, and remove the directory if it is empty.
 253   if (!directory_filename.empty())
 254     argv.push_back(directory_filename.value());
 255   argv.push_back(shortcut_filename.value());
 256   int exit_code;
 257   LaunchXdgUtility(argv, &exit_code);
 258 }
 259
 260 #if defined(USE_GLIB)
 261 // Quote a string such that it appears as one verbatim argument for the Exec
 262 // key in a desktop file.
 263 std::string QuoteArgForDesktopFileExec(const std::string& arg) {
 264   // http://standards.freedesktop.org/desktop-entry-spec/latest/ar01s06.html
 265
 266   // Quoting is only necessary if the argument has a reserved character.
 267   if (arg.find_first_of(" \t\n\"'\\><~|&;$*?#()`") == std::string::npos)
 268     return arg;  // No quoting necessary.
 269
 270   std::string quoted = "\"";
 271   for (size_t i = 0; i < arg.size(); ++i) {
 272     // Note that the set of backslashed characters is smaller than the
 273     // set of reserved characters.
 274     switch (arg[i]) {
 275       case '"':
 276       case '`':
 277       case '$':
 278       case '\\':
 279         quoted += '\\';
 280         break;
 281     }
 282     quoted += arg[i];
 283   }
 284   quoted += '"';
 285
 286   return quoted;
 287 }
 288
 289 // Quote a command line so it is suitable for use as the Exec key in a desktop
 290 // file. Note: This should be used instead of GetCommandLineString, which does
 291 // not properly quote the string; this function is designed for the Exec key.
 292 std::string QuoteCommandLineForDesktopFileExec(
 293     const base::CommandLine& command_line) {
 294   // http://standards.freedesktop.org/desktop-entry-spec/latest/ar01s06.html
 295
 296   std::string quoted_path = "";
 297   const base::CommandLine::StringVector& argv = command_line.argv();
 298   for (base::CommandLine::StringVector::const_iterator i = argv.begin();
 299        i != argv.end(); ++i) {
 300     if (i != argv.begin())
 301       quoted_path += " ";
 302     quoted_path += QuoteArgForDesktopFileExec(*i);
 303   }
 304
 305   return quoted_path;
 306 }
 307
 308 const char kDesktopEntry[] = "Desktop Entry";
 309
 310 const char kXdgOpenShebang[] = "#!/usr/bin/env xdg-open";
 311 #endif
 312
 313 const char kXdgSettings[] = "xdg-settings";
 314 const char kXdgSettingsDefaultBrowser[] = "default-web-browser";
 315 const char kXdgSettingsDefaultSchemeHandler[] = "default-url-scheme-handler";
 316
 317 const char kDirectoryFilename[] = "chrome-apps.directory";
 318
 319 #if defined(GOOGLE_CHROME_BUILD)
 320 const char kAppListDesktopName[] = "chrome-app-list";
 321 #else  // CHROMIUM_BUILD
 322 const char kAppListDesktopName[] = "chromium-app-list";
 323 #endif
 324
 325 // Utility function to get the path to the version of a script shipped with
 326 // Chrome. |script| gives the name of the script. |chrome_version| returns the
 327 // path to the Chrome version of the script, and the return value of the
 328 // function is true if the function is successful and the Chrome version is
 329 // not the script found on the PATH.
 330 bool GetChromeVersionOfScript(const std::string& script,
 331                               std::string* chrome_version) {
 332   // Get the path to the Chrome version.
 333   base::FilePath chrome_dir;
 334   if (!PathService::Get(base::DIR_EXE, &chrome_dir))
 335     return false;
 336
 337   base::FilePath chrome_version_path = chrome_dir.Append(script);
 338   *chrome_version = chrome_version_path.value();
 339
 340   // Check if this is different to the one on path.
 341   std::vector<std::string> argv;
 342   argv.push_back("which");
 343   argv.push_back(script);
 344   std::string path_version;
 345   if (base::GetAppOutput(base::CommandLine(argv), &path_version)) {
 346     // Remove trailing newline
 347     path_version.erase(path_version.length() - 1, 1);
 348     base::FilePath path_version_path(path_version);
 349     return (chrome_version_path != path_version_path);
 350   }
 351   return false;
 352 }
 353
 354 // Value returned by xdg-settings if it can't understand our request.
 355 const int EXIT_XDG_SETTINGS_SYNTAX_ERROR = 1;
 356
 357 // We delegate the difficulty of setting the default browser and default url
 358 // scheme handler in Linux desktop environments to an xdg utility, xdg-settings.
 359
 360 // When calling this script we first try to use the script on PATH. If that
 361 // fails we then try to use the script that we have included. This gives
 362 // scripts on the system priority over ours, as distribution vendors may have
 363 // tweaked the script, but still allows our copy to be used if the script on the
 364 // system fails, as the system copy may be missing capabilities of the Chrome
 365 // copy.
 366
 367 // If |protocol| is empty this function sets Chrome as the default browser,
 368 // otherwise it sets Chrome as the default handler application for |protocol|.
 369 bool SetDefaultWebClient(const std::string& protocol) {
 370 #if defined(OS_CHROMEOS)
 371   return true;
 372 #else
 373   scoped_ptr<base::Environment> env(base::Environment::Create());
 374
 375   std::vector<std::string> argv;
 376   argv.push_back(kXdgSettings);
 377   argv.push_back("set");
 378   if (protocol.empty()) {
 379     argv.push_back(kXdgSettingsDefaultBrowser);
 380   } else {
 381     argv.push_back(kXdgSettingsDefaultSchemeHandler);
 382     argv.push_back(protocol);
 383   }
 384   argv.push_back(shell_integration_linux::GetDesktopName(env.get()));
 385
 386   int exit_code;
 387   bool ran_ok = LaunchXdgUtility(argv, &exit_code);
 388   if (ran_ok && exit_code == EXIT_XDG_SETTINGS_SYNTAX_ERROR) {
 389     if (GetChromeVersionOfScript(kXdgSettings, &argv[0])) {
 390       ran_ok = LaunchXdgUtility(argv, &exit_code);
 391     }
 392   }
 393
 394   return ran_ok && exit_code == EXIT_SUCCESS;
 395 #endif
 396 }
 397
 398 // If |protocol| is empty this function checks if Chrome is the default browser,
 399 // otherwise it checks if Chrome is the default handler application for
 400 // |protocol|.
 401 ShellIntegration::DefaultWebClientState GetIsDefaultWebClient(
 402     const std::string& protocol) {
 403 #if defined(OS_CHROMEOS)
 404   return ShellIntegration::UNKNOWN_DEFAULT;
 405 #else
 406   base::ThreadRestrictions::AssertIOAllowed();
 407
 408   scoped_ptr<base::Environment> env(base::Environment::Create());
 409
 410   std::vector<std::string> argv;
 411   argv.push_back(kXdgSettings);
 412   argv.push_back("check");
 413   if (protocol.empty()) {
 414     argv.push_back(kXdgSettingsDefaultBrowser);
 415   } else {
 416     argv.push_back(kXdgSettingsDefaultSchemeHandler);
 417     argv.push_back(protocol);
 418   }
 419   argv.push_back(shell_integration_linux::GetDesktopName(env.get()));
 420
 421   std::string reply;
 422   int success_code;
 423   bool ran_ok = base::GetAppOutputWithExitCode(base::CommandLine(argv), &reply,
 424                                                &success_code);
 425   if (ran_ok && success_code == EXIT_XDG_SETTINGS_SYNTAX_ERROR) {
 426     if (GetChromeVersionOfScript(kXdgSettings, &argv[0])) {
 427       ran_ok = base::GetAppOutputWithExitCode(base::CommandLine(argv), &reply,
 428                                               &success_code);
 429     }
 430   }
 431
 432   if (!ran_ok || success_code != EXIT_SUCCESS) {
 433     // xdg-settings failed: we can't determine or set the default browser.
 434     return ShellIntegration::UNKNOWN_DEFAULT;
 435   }
 436
 437   // Allow any reply that starts with "yes".
 438   return (reply.find("yes") == 0) ? ShellIntegration::IS_DEFAULT :
 439                                     ShellIntegration::NOT_DEFAULT;
 440 #endif
 441 }
 442
 443 // Get the value of NoDisplay from the [Desktop Entry] section of a .desktop
 444 // file, given in |shortcut_contents|. If the key is not found, returns false.
 445 bool GetNoDisplayFromDesktopFile(const std::string& shortcut_contents) {
 446 #if defined(USE_GLIB)
 447   // An empty file causes a crash with glib <= 2.32, so special case here.
 448   if (shortcut_contents.empty())
 449     return false;
 450
 451   GKeyFile* key_file = g_key_file_new();
 452   GError* err = NULL;
 453   if (!g_key_file_load_from_data(key_file, shortcut_contents.c_str(),
 454                                  shortcut_contents.size(), G_KEY_FILE_NONE,
 455                                  &err)) {
 456     LOG(WARNING) << "Unable to read desktop file template: " << err->message;
 457     g_error_free(err);
 458     g_key_file_free(key_file);
 459     return false;
 460   }
 461
 462   bool nodisplay = false;
 463   char* nodisplay_c_string = g_key_file_get_string(key_file, kDesktopEntry,
 464                                                    "NoDisplay", &err);
 465   if (nodisplay_c_string) {
 466     if (!g_strcmp0(nodisplay_c_string, "true"))
 467       nodisplay = true;
 468     g_free(nodisplay_c_string);
 469   } else {
 470     g_error_free(err);
 471   }
 472
 473   g_key_file_free(key_file);
 474   return nodisplay;
 475 #else
 476   NOTIMPLEMENTED();
 477   return false;
 478 #endif
 479 }
 480
 481 // Gets the path to the Chrome executable or wrapper script.
 482 // Returns an empty path if the executable path could not be found, which should
 483 // never happen.
 484 base::FilePath GetChromeExePath() {
 485   // Try to get the name of the wrapper script that launched Chrome.
 486   scoped_ptr<base::Environment> environment(base::Environment::Create());
 487   std::string wrapper_script;
 488   if (environment->GetVar("CHROME_WRAPPER", &wrapper_script))
 489     return base::FilePath(wrapper_script);
 490
 491   // Just return the name of the executable path for Chrome.
 492   base::FilePath chrome_exe_path;
 493   PathService::Get(base::FILE_EXE, &chrome_exe_path);
 494   return chrome_exe_path;
 495 }
 496
 497 }  // namespace
 498
 499 // static
 500 ShellIntegration::DefaultWebClientSetPermission
 501 ShellIntegration::CanSetAsDefaultBrowser() {
 502   return SET_DEFAULT_UNATTENDED;
 503 }
 504
 505 // static
 506 bool ShellIntegration::SetAsDefaultBrowser() {
 507   return SetDefaultWebClient(std::string());
 508 }
 509
 510 // static
 511 bool ShellIntegration::SetAsDefaultProtocolClient(
 512     const std::string& protocol) {
 513   return SetDefaultWebClient(protocol);
 514 }
 515
 516 // static
 517 ShellIntegration::DefaultWebClientState
 518 ShellIntegration::GetDefaultBrowser() {
 519   return GetIsDefaultWebClient(std::string());
 520 }
 521
 522 // static
 523 base::string16 ShellIntegration::GetApplicationNameForProtocol(
 524     const GURL& url) {
 525   return base::ASCIIToUTF16("xdg-open");
 526 }
 527
 528 // static
 529 ShellIntegration::DefaultWebClientState
 530 ShellIntegration::IsDefaultProtocolClient(const std::string& protocol) {
 531   return GetIsDefaultWebClient(protocol);
 532 }
 533
 534 // static
 535 bool ShellIntegration::IsFirefoxDefaultBrowser() {
 536   std::vector<std::string> argv;
 537   argv.push_back(kXdgSettings);
 538   argv.push_back("get");
 539   argv.push_back(kXdgSettingsDefaultBrowser);
 540
 541   std::string browser;
 542   // We don't care about the return value here.
 543   base::GetAppOutput(base::CommandLine(argv), &browser);
 544   return browser.find("irefox") != std::string::npos;
 545 }
 546
 547 namespace shell_integration_linux {
 548
 549 base::FilePath GetDataWriteLocation(base::Environment* env) {
 550   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 551
 552   return base::nix::GetXDGDirectory(env, "XDG_DATA_HOME", ".local/share");
 553 }
 554
 555 std::vector<base::FilePath> GetDataSearchLocations(base::Environment* env) {
 556   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 557
 558   std::vector<base::FilePath> search_paths;
 559   base::FilePath write_location = GetDataWriteLocation(env);
 560   search_paths.push_back(write_location);
 561
 562   std::string xdg_data_dirs;
 563   if (env->GetVar("XDG_DATA_DIRS", &xdg_data_dirs) && !xdg_data_dirs.empty()) {
 564     base::StringTokenizer tokenizer(xdg_data_dirs, ":");
 565     while (tokenizer.GetNext()) {
 566       base::FilePath data_dir(tokenizer.token());
 567       search_paths.push_back(data_dir);
 568     }
 569   } else {
 570     search_paths.push_back(base::FilePath("/usr/local/share"));
 571     search_paths.push_back(base::FilePath("/usr/share"));
 572   }
 573
 574   return search_paths;
 575 }
 576
 577 std::string GetProgramClassName() {
 578   scoped_ptr<base::Environment> env(base::Environment::Create());
 579   std::string desktop_file(GetDesktopName(env.get()));
 580   std::size_t last = desktop_file.find(".desktop");
 581   if (last != std::string::npos)
 582     return desktop_file.substr(0, last);
 583   return desktop_file;
 584 }
 585
 586 std::string GetDesktopName(base::Environment* env) {
 587 #if defined(GOOGLE_CHROME_BUILD)
 588   version_info::Channel product_channel(chrome::GetChannel());
 589   switch (product_channel) {
 590     case version_info::Channel::DEV:
 591       return "google-chrome-unstable.desktop";
 592     case version_info::Channel::BETA:
 593       return "google-chrome-beta.desktop";
 594     default:
 595       return "google-chrome.desktop";
 596   }
 597 #else  // CHROMIUM_BUILD
 598   // Allow $CHROME_DESKTOP to override the built-in value, so that development
 599   // versions can set themselves as the default without interfering with
 600   // non-official, packaged versions using the built-in value.
 601   std::string name;
 602   if (env->GetVar("CHROME_DESKTOP", &name) && !name.empty())
 603     return name;
 604   return "chromium-browser.desktop";
 605 #endif
 606 }
 607
 608 std::string GetIconName() {
 609 #if defined(GOOGLE_CHROME_BUILD)
 610   return "google-chrome";
 611 #else  // CHROMIUM_BUILD
 612   return "chromium-browser";
 613 #endif
 614 }
 615
 616 web_app::ShortcutLocations GetExistingShortcutLocations(
 617     base::Environment* env,
 618     const base::FilePath& profile_path,
 619     const std::string& extension_id) {
 620   base::FilePath desktop_path;
 621   // If Get returns false, just leave desktop_path empty.
 622   PathService::Get(base::DIR_USER_DESKTOP, &desktop_path);
 623   return GetExistingShortcutLocations(env, profile_path, extension_id,
 624                                       desktop_path);
 625 }
 626
 627 web_app::ShortcutLocations GetExistingShortcutLocations(
 628     base::Environment* env,
 629     const base::FilePath& profile_path,
 630     const std::string& extension_id,
 631     const base::FilePath& desktop_path) {
 632   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 633
 634   base::FilePath shortcut_filename = GetExtensionShortcutFilename(
 635       profile_path, extension_id);
 636   DCHECK(!shortcut_filename.empty());
 637   web_app::ShortcutLocations locations;
 638
 639   // Determine whether there is a shortcut on desktop.
 640   if (!desktop_path.empty()) {
 641     locations.on_desktop =
 642         base::PathExists(desktop_path.Append(shortcut_filename));
 643   }
 644
 645   // Determine whether there is a shortcut in the applications directory.
 646   std::string shortcut_contents;
 647   if (GetExistingShortcutContents(env, shortcut_filename, &shortcut_contents)) {
 648     // If the shortcut contents contain NoDisplay=true, it should be hidden.
 649     // Otherwise since these shortcuts are for apps, they are always in the
 650     // "Chrome Apps" directory.
 651     locations.applications_menu_location =
 652         GetNoDisplayFromDesktopFile(shortcut_contents)
 653             ? web_app::APP_MENU_LOCATION_HIDDEN
 654             : web_app::APP_MENU_LOCATION_SUBDIR_CHROMEAPPS;
 655   }
 656
 657   return locations;
 658 }
 659
 660 bool GetExistingShortcutContents(base::Environment* env,
 661                                  const base::FilePath& desktop_filename,
 662                                  std::string* output) {
 663   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 664
 665   std::vector<base::FilePath> search_paths = GetDataSearchLocations(env);
 666
 667   for (std::vector<base::FilePath>::const_iterator i = search_paths.begin();
 668        i != search_paths.end(); ++i) {
 669     base::FilePath path = i->Append("applications").Append(desktop_filename);
 670     VLOG(1) << "Looking for desktop file in " << path.value();
 671     if (base::PathExists(path)) {
 672       VLOG(1) << "Found desktop file at " << path.value();
 673       return base::ReadFileToString(path, output);
 674     }
 675   }
 676
 677   return false;
 678 }
 679
 680 base::FilePath GetWebShortcutFilename(const GURL& url) {
 681   // Use a prefix, because xdg-desktop-menu requires it.
 682   std::string filename =
 683       std::string(chrome::kBrowserProcessExecutableName) + "-" + url.spec();
 684   base::i18n::ReplaceIllegalCharactersInPath(&filename, '_');
 685
 686   base::FilePath desktop_path;
 687   if (!PathService::Get(base::DIR_USER_DESKTOP, &desktop_path))
 688     return base::FilePath();
 689
 690   base::FilePath filepath = desktop_path.Append(filename);
 691   base::FilePath alternative_filepath(filepath.value() + ".desktop");
 692   for (size_t i = 1; i < 100; ++i) {
 693     if (base::PathExists(base::FilePath(alternative_filepath))) {
 694       alternative_filepath = base::FilePath(
 695           filepath.value() + "_" + base::SizeTToString(i) + ".desktop");
 696     } else {
 697       return base::FilePath(alternative_filepath).BaseName();
 698     }
 699   }
 700
 701   return base::FilePath();
 702 }
 703
 704 base::FilePath GetExtensionShortcutFilename(const base::FilePath& profile_path,
 705                                             const std::string& extension_id) {
 706   DCHECK(!extension_id.empty());
 707
 708   // Use a prefix, because xdg-desktop-menu requires it.
 709   std::string filename(chrome::kBrowserProcessExecutableName);
 710   filename.append("-")
 711       .append(extension_id)
 712       .append("-")
 713       .append(profile_path.BaseName().value());
 714   base::i18n::ReplaceIllegalCharactersInPath(&filename, '_');
 715   // Spaces in filenames break xdg-desktop-menu
 716   // (see https://bugs.freedesktop.org/show_bug.cgi?id=66605).
 717   base::ReplaceChars(filename, " ", "_", &filename);
 718   return base::FilePath(filename.append(".desktop"));
 719 }
 720
 721 std::vector<base::FilePath> GetExistingProfileShortcutFilenames(
 722     const base::FilePath& profile_path,
 723     const base::FilePath& directory) {
 724   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 725
 726   // Use a prefix, because xdg-desktop-menu requires it.
 727   std::string prefix(chrome::kBrowserProcessExecutableName);
 728   prefix.append("-");
 729   std::string suffix("-");
 730   suffix.append(profile_path.BaseName().value());
 731   base::i18n::ReplaceIllegalCharactersInPath(&suffix, '_');
 732   // Spaces in filenames break xdg-desktop-menu
 733   // (see https://bugs.freedesktop.org/show_bug.cgi?id=66605).
 734   base::ReplaceChars(suffix, " ", "_", &suffix);
 735   std::string glob = prefix + "*" + suffix + ".desktop";
 736
 737   base::FileEnumerator files(directory, false, base::FileEnumerator::FILES,
 738                              glob);
 739   base::FilePath shortcut_file = files.Next();
 740   std::vector<base::FilePath> shortcut_paths;
 741   while (!shortcut_file.empty()) {
 742     shortcut_paths.push_back(shortcut_file.BaseName());
 743     shortcut_file = files.Next();
 744   }
 745   return shortcut_paths;
 746 }
 747
 748 std::string GetDesktopFileContents(
 749     const base::FilePath& chrome_exe_path,
 750     const std::string& app_name,
 751     const GURL& url,
 752     const std::string& extension_id,
 753     const base::string16& title,
 754     const std::string& icon_name,
 755     const base::FilePath& profile_path,
 756     const std::string& categories,
 757     bool no_display) {
 758   base::CommandLine cmd_line =
 759       ShellIntegration::CommandLineArgsForLauncher(url, extension_id,
 760                                                    profile_path);
 761   cmd_line.SetProgram(chrome_exe_path);
 762   return GetDesktopFileContentsForCommand(cmd_line, app_name, url, title,
 763                                           icon_name, categories, no_display);
 764 }
 765
 766 std::string GetDesktopFileContentsForCommand(
 767     const base::CommandLine& command_line,
 768     const std::string& app_name,
 769     const GURL& url,
 770     const base::string16& title,
 771     const std::string& icon_name,
 772     const std::string& categories,
 773     bool no_display) {
 774 #if defined(USE_GLIB)
 775   // Although not required by the spec, Nautilus on Ubuntu Karmic creates its
 776   // launchers with an xdg-open shebang. Follow that convention.
 777   std::string output_buffer = std::string(kXdgOpenShebang) + "\n";
 778
 779   // See http://standards.freedesktop.org/desktop-entry-spec/latest/
 780   GKeyFile* key_file = g_key_file_new();
 781
 782   // Set keys with fixed values.
 783   g_key_file_set_string(key_file, kDesktopEntry, "Version", "1.0");
 784   g_key_file_set_string(key_file, kDesktopEntry, "Terminal", "false");
 785   g_key_file_set_string(key_file, kDesktopEntry, "Type", "Application");
 786
 787   // Set the "Name" key.
 788   std::string final_title = base::UTF16ToUTF8(title);
 789   // Make sure no endline characters can slip in and possibly introduce
 790   // additional lines (like Exec, which makes it a security risk). Also
 791   // use the URL as a default when the title is empty.
 792   if (final_title.empty() ||
 793       final_title.find("\n") != std::string::npos ||
 794       final_title.find("\r") != std::string::npos) {
 795     final_title = url.spec();
 796   }
 797   g_key_file_set_string(key_file, kDesktopEntry, "Name", final_title.c_str());
 798
 799   // Set the "Exec" key.
 800   std::string final_path = QuoteCommandLineForDesktopFileExec(command_line);
 801   g_key_file_set_string(key_file, kDesktopEntry, "Exec", final_path.c_str());
 802
 803   // Set the "Icon" key.
 804   if (!icon_name.empty()) {
 805     g_key_file_set_string(key_file, kDesktopEntry, "Icon", icon_name.c_str());
 806   } else {
 807     g_key_file_set_string(key_file, kDesktopEntry, "Icon",
 808                           GetIconName().c_str());
 809   }
 810
 811   // Set the "Categories" key.
 812   if (!categories.empty()) {
 813     g_key_file_set_string(
 814         key_file, kDesktopEntry, "Categories", categories.c_str());
 815   }
 816
 817   // Set the "NoDisplay" key.
 818   if (no_display)
 819     g_key_file_set_string(key_file, kDesktopEntry, "NoDisplay", "true");
 820
 821   std::string wmclass = web_app::GetWMClassFromAppName(app_name);
 822   g_key_file_set_string(key_file, kDesktopEntry, "StartupWMClass",
 823                         wmclass.c_str());
 824
 825   gsize length = 0;
 826   gchar* data_dump = g_key_file_to_data(key_file, &length, NULL);
 827   if (data_dump) {
 828     // If strlen(data_dump[0]) == 0, this check will fail.
 829     if (data_dump[0] == '\n') {
 830       // Older versions of glib produce a leading newline. If this is the case,
 831       // remove it to avoid double-newline after the shebang.
 832       output_buffer += (data_dump + 1);
 833     } else {
 834       output_buffer += data_dump;
 835     }
 836     g_free(data_dump);
 837   }
 838
 839   g_key_file_free(key_file);
 840   return output_buffer;
 841 #else
 842   NOTIMPLEMENTED();
 843   return std::string();
 844 #endif
 845 }
 846
 847 std::string GetDirectoryFileContents(const base::string16& title,
 848                                      const std::string& icon_name) {
 849 #if defined(USE_GLIB)
 850   // See http://standards.freedesktop.org/desktop-entry-spec/latest/
 851   GKeyFile* key_file = g_key_file_new();
 852
 853   g_key_file_set_string(key_file, kDesktopEntry, "Version", "1.0");
 854   g_key_file_set_string(key_file, kDesktopEntry, "Type", "Directory");
 855   std::string final_title = base::UTF16ToUTF8(title);
 856   g_key_file_set_string(key_file, kDesktopEntry, "Name", final_title.c_str());
 857   if (!icon_name.empty()) {
 858     g_key_file_set_string(key_file, kDesktopEntry, "Icon", icon_name.c_str());
 859   } else {
 860     g_key_file_set_string(key_file, kDesktopEntry, "Icon",
 861                           GetIconName().c_str());
 862   }
 863
 864   gsize length = 0;
 865   gchar* data_dump = g_key_file_to_data(key_file, &length, NULL);
 866   std::string output_buffer;
 867   if (data_dump) {
 868     // If strlen(data_dump[0]) == 0, this check will fail.
 869     if (data_dump[0] == '\n') {
 870       // Older versions of glib produce a leading newline. If this is the case,
 871       // remove it to avoid double-newline after the shebang.
 872       output_buffer += (data_dump + 1);
 873     } else {
 874       output_buffer += data_dump;
 875     }
 876     g_free(data_dump);
 877   }
 878
 879   g_key_file_free(key_file);
 880   return output_buffer;
 881 #else
 882   NOTIMPLEMENTED();
 883   return std::string();
 884 #endif
 885 }
 886
 887 bool CreateDesktopShortcut(
 888     const web_app::ShortcutInfo& shortcut_info,
 889     const web_app::ShortcutLocations& creation_locations) {
 890   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 891
 892   base::FilePath shortcut_filename;
 893   if (!shortcut_info.extension_id.empty()) {
 894     shortcut_filename = GetExtensionShortcutFilename(
 895         shortcut_info.profile_path, shortcut_info.extension_id);
 896     // For extensions we do not want duplicate shortcuts. So, delete any that
 897     // already exist and replace them.
 898     if (creation_locations.on_desktop)
 899       DeleteShortcutOnDesktop(shortcut_filename);
 900
 901     if (creation_locations.applications_menu_location !=
 902             web_app::APP_MENU_LOCATION_NONE) {
 903       DeleteShortcutInApplicationsMenu(shortcut_filename, base::FilePath());
 904     }
 905   } else {
 906     shortcut_filename = GetWebShortcutFilename(shortcut_info.url);
 907   }
 908   if (shortcut_filename.empty())
 909     return false;
 910
 911   std::string icon_name =
 912       CreateShortcutIcon(shortcut_info.favicon, shortcut_filename);
 913
 914   std::string app_name =
 915       web_app::GenerateApplicationNameFromInfo(shortcut_info);
 916
 917   bool success = true;
 918
 919   base::FilePath chrome_exe_path = GetChromeExePath();
 920   if (chrome_exe_path.empty()) {
 921     NOTREACHED();
 922     return false;
 923   }
 924
 925   if (creation_locations.on_desktop) {
 926     std::string contents = GetDesktopFileContents(
 927         chrome_exe_path,
 928         app_name,
 929         shortcut_info.url,
 930         shortcut_info.extension_id,
 931         shortcut_info.title,
 932         icon_name,
 933         shortcut_info.profile_path,
 934         "",
 935         false);
 936     success = CreateShortcutOnDesktop(shortcut_filename, contents);
 937   }
 938
 939   if (creation_locations.applications_menu_location ==
 940           web_app::APP_MENU_LOCATION_NONE) {
 941     return success;
 942   }
 943
 944   base::FilePath directory_filename;
 945   std::string directory_contents;
 946   switch (creation_locations.applications_menu_location) {
 947     case web_app::APP_MENU_LOCATION_ROOT:
 948     case web_app::APP_MENU_LOCATION_HIDDEN:
 949       break;
 950     case web_app::APP_MENU_LOCATION_SUBDIR_CHROMEAPPS:
 951       directory_filename = base::FilePath(kDirectoryFilename);
 952       directory_contents = GetDirectoryFileContents(
 953           ShellIntegration::GetAppShortcutsSubdirName(), "");
 954       break;
 955     default:
 956       NOTREACHED();
 957       break;
 958   }
 959
 960   // Set NoDisplay=true if hidden. This will hide the application from
 961   // user-facing menus.
 962   std::string contents = GetDesktopFileContents(
 963       chrome_exe_path,
 964       app_name,
 965       shortcut_info.url,
 966       shortcut_info.extension_id,
 967       shortcut_info.title,
 968       icon_name,
 969       shortcut_info.profile_path,
 970       "",
 971       creation_locations.applications_menu_location ==
 972           web_app::APP_MENU_LOCATION_HIDDEN);
 973   success = CreateShortcutInApplicationsMenu(
 974       shortcut_filename, contents, directory_filename, directory_contents) &&
 975       success;
 976
 977   return success;
 978 }
 979
 980 bool CreateAppListDesktopShortcut(
 981     const std::string& wm_class,
 982     const std::string& title) {
 983   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 984
 985   base::FilePath desktop_name(kAppListDesktopName);
 986   base::FilePath shortcut_filename = desktop_name.AddExtension("desktop");
 987
 988   // We do not want duplicate shortcuts. Delete any that already exist and
 989   // replace them.
 990   DeleteShortcutInApplicationsMenu(shortcut_filename, base::FilePath());
 991
 992   base::FilePath chrome_exe_path = GetChromeExePath();
 993   if (chrome_exe_path.empty()) {
 994     NOTREACHED();
 995     return false;
 996   }
 997
 998   gfx::ImageFamily icon_images;
 999   ResourceBundle& resource_bundle = ResourceBundle::GetSharedInstance();
1000   icon_images.Add(*resource_bundle.GetImageSkiaNamed(IDR_APP_LIST_16));
1001   icon_images.Add(*resource_bundle.GetImageSkiaNamed(IDR_APP_LIST_32));
1002   icon_images.Add(*resource_bundle.GetImageSkiaNamed(IDR_APP_LIST_48));
1003   icon_images.Add(*resource_bundle.GetImageSkiaNamed(IDR_APP_LIST_256));
1004   std::string icon_name = CreateShortcutIcon(icon_images, desktop_name);
1005
1006   base::CommandLine command_line(chrome_exe_path);
1007   command_line.AppendSwitch(switches::kShowAppList);
1008   std::string contents =
1009       GetDesktopFileContentsForCommand(command_line,
1010                                        wm_class,
1011                                        GURL(),
1012                                        base::UTF8ToUTF16(title),
1013                                        icon_name,
1014                                        kAppListCategories,
1015                                        false);
1016   return CreateShortcutInApplicationsMenu(
1017       shortcut_filename, contents, base::FilePath(), "");
1018 }
1019
1020 void DeleteDesktopShortcuts(const base::FilePath& profile_path,
1021                             const std::string& extension_id) {
1022   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
1023
1024   base::FilePath shortcut_filename = GetExtensionShortcutFilename(
1025       profile_path, extension_id);
1026   DCHECK(!shortcut_filename.empty());
1027
1028   DeleteShortcutOnDesktop(shortcut_filename);
1029   // Delete shortcuts from |kDirectoryFilename|.
1030   // Note that it is possible that shortcuts were not created in the Chrome Apps
1031   // directory. It doesn't matter: this will still delete the shortcut even if
1032   // it isn't in the directory.
1033   DeleteShortcutInApplicationsMenu(shortcut_filename,
1034                                    base::FilePath(kDirectoryFilename));
1035 }
1036
1037 void DeleteAllDesktopShortcuts(const base::FilePath& profile_path) {
1038   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
1039
1040   scoped_ptr<base::Environment> env(base::Environment::Create());
1041
1042   // Delete shortcuts from Desktop.
1043   base::FilePath desktop_path;
1044   if (PathService::Get(base::DIR_USER_DESKTOP, &desktop_path)) {
1045     std::vector<base::FilePath> shortcut_filenames_desktop =
1046         GetExistingProfileShortcutFilenames(profile_path, desktop_path);
1047     for (const auto& shortcut : shortcut_filenames_desktop) {
1048       DeleteShortcutOnDesktop(shortcut);
1049     }
1050   }
1051
1052   // Delete shortcuts from |kDirectoryFilename|.
1053   base::FilePath applications_menu = GetDataWriteLocation(env.get());
1054   applications_menu = applications_menu.AppendASCII("applications");
1055   std::vector<base::FilePath> shortcut_filenames_app_menu =
1056       GetExistingProfileShortcutFilenames(profile_path, applications_menu);
1057   for (const auto& menu : shortcut_filenames_app_menu) {
1058     DeleteShortcutInApplicationsMenu(menu, base::FilePath(kDirectoryFilename));
1059   }
1060 }
1061
1062 }  // namespace shell_integration_linux