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