Linux: Change ShellIntegration code to use GetXDGDirectory().

chrome/browser/shell_integration_linux.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/shell_integration_linux.h"
 
 #include <fcntl.h>
 
 #if defined(USE_GLIB)
 #include <glib.h>
@@ skipping 11 matching lines @@
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/nix/xdg_util.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 29 matching lines @@
   *exit_code = EXIT_FAILURE;
   int devnull = open("/dev/null", O_RDONLY);
   if (devnull < 0)
     return false;
   base::FileHandleMappingVector no_stdin;
   no_stdin.push_back(std::make_pair(devnull, STDIN_FILENO));
 
   base::LaunchOptions options;
   options.fds_to_remap = &no_stdin;
   base::Process process = base::LaunchProcess(argv, options);
-  if (!process.IsValid()) {
-    close(devnull);
+  close(devnull);
+  if (!process.IsValid())
     return false;
-  }
-  close(devnull);
-
   return process.WaitForExit(exit_code);
 }
 
 std::string CreateShortcutIcon(const gfx::ImageFamily& icon_images,
                                const base::FilePath& shortcut_filename) {
   if (icon_images.empty())
     return std::string();
 
   // TODO(phajdan.jr): Report errors from this function, possibly as infobars.
   base::ScopedTempDir temp_dir;
@@ skipping 376 matching lines @@
 
   g_key_file_free(key_file);
   return nodisplay;
 #else
   NOTIMPLEMENTED();
   return false;
 #endif
 }
 
 // Gets the path to the Chrome executable or wrapper script.
-// Returns an empty path if the executable path could not be found.
+// Returns an empty path if the executable path could not be found, which should
+// never happen.
 base::FilePath GetChromeExePath() {
   // Try to get the name of the wrapper script that launched Chrome.
   scoped_ptr<base::Environment> environment(base::Environment::Create());
   std::string wrapper_script;
-  if (environment->GetVar("CHROME_WRAPPER", &wrapper_script)) {
+  if (environment->GetVar("CHROME_WRAPPER", &wrapper_script))
     return base::FilePath(wrapper_script);
-  }
 
   // Just return the name of the executable path for Chrome.
   base::FilePath chrome_exe_path;
   PathService::Get(base::FILE_EXE, &chrome_exe_path);
   return chrome_exe_path;
 }
 
 }  // namespace
 
 // static
@@ skipping 39 matching lines @@
   argv.push_back(kXdgSettingsDefaultBrowser);
 
   std::string browser;
   // We don't care about the return value here.
   base::GetAppOutput(base::CommandLine(argv), &browser);
   return browser.find("irefox") != std::string::npos;
 }
 
 namespace shell_integration_linux {
 
-bool GetDataWriteLocation(base::Environment* env, base::FilePath* search_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+base::FilePath GetDataWriteLocation(base::Environment* env) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
-  std::string xdg_data_home;
-  std::string home;
-  if (env->GetVar("XDG_DATA_HOME", &xdg_data_home) && !xdg_data_home.empty()) {
-    *search_path = base::FilePath(xdg_data_home);
-    return true;
-  } else if (env->GetVar("HOME", &home) && !home.empty()) {
-    *search_path = base::FilePath(home).Append(".local").Append("share");
-    return true;
-  }
-  return false;
+  return base::nix::GetXDGDirectory(env, "XDG_DATA_HOME", ".local/share");
 }
 
 std::vector<base::FilePath> GetDataSearchLocations(base::Environment* env) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   std::vector<base::FilePath> search_paths;
-
-  base::FilePath write_location;
-  if (GetDataWriteLocation(env, &write_location))
-    search_paths.push_back(write_location);
+  base::FilePath write_location = GetDataWriteLocation(env);
+  search_paths.push_back(write_location);
 
   std::string xdg_data_dirs;
   if (env->GetVar("XDG_DATA_DIRS", &xdg_data_dirs) && !xdg_data_dirs.empty()) {
     base::StringTokenizer tokenizer(xdg_data_dirs, ":");
     while (tokenizer.GetNext()) {
       base::FilePath data_dir(tokenizer.token());
       search_paths.push_back(data_dir);
     }
   } else {
     search_paths.push_back(base::FilePath("/usr/local/share"));
@@ skipping 54 matching lines @@
   PathService::Get(base::DIR_USER_DESKTOP, &desktop_path);
   return GetExistingShortcutLocations(env, profile_path, extension_id,
                                       desktop_path);
 }
 
 web_app::ShortcutLocations GetExistingShortcutLocations(
     base::Environment* env,
     const base::FilePath& profile_path,
     const std::string& extension_id,
     const base::FilePath& desktop_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   base::FilePath shortcut_filename = GetExtensionShortcutFilename(
       profile_path, extension_id);
   DCHECK(!shortcut_filename.empty());
   web_app::ShortcutLocations locations;
 
   // Determine whether there is a shortcut on desktop.
   if (!desktop_path.empty()) {
     locations.on_desktop =
         base::PathExists(desktop_path.Append(shortcut_filename));
@@ skipping 10 matching lines @@
             ? web_app::APP_MENU_LOCATION_HIDDEN
             : web_app::APP_MENU_LOCATION_SUBDIR_CHROMEAPPS;
   }
 
   return locations;
 }
 
 bool GetExistingShortcutContents(base::Environment* env,
                                  const base::FilePath& desktop_filename,
                                  std::string* output) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   std::vector<base::FilePath> search_paths = GetDataSearchLocations(env);
 
   for (std::vector<base::FilePath>::const_iterator i = search_paths.begin();
        i != search_paths.end(); ++i) {
     base::FilePath path = i->Append("applications").Append(desktop_filename);
     VLOG(1) << "Looking for desktop file in " << path.value();
     if (base::PathExists(path)) {
       VLOG(1) << "Found desktop file at " << path.value();
       return base::ReadFileToString(path, output);
@@ skipping 40 matching lines @@
   base::i18n::ReplaceIllegalCharactersInPath(&filename, '_');
   // Spaces in filenames break xdg-desktop-menu
   // (see https://bugs.freedesktop.org/show_bug.cgi?id=66605).
   base::ReplaceChars(filename, " ", "_", &filename);
   return base::FilePath(filename.append(".desktop"));
 }
 
 std::vector<base::FilePath> GetExistingProfileShortcutFilenames(
     const base::FilePath& profile_path,
     const base::FilePath& directory) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+
   // Use a prefix, because xdg-desktop-menu requires it.
   std::string prefix(chrome::kBrowserProcessExecutableName);
   prefix.append("-");
   std::string suffix("-");
   suffix.append(profile_path.BaseName().value());
   base::i18n::ReplaceIllegalCharactersInPath(&suffix, '_');
   // Spaces in filenames break xdg-desktop-menu
   // (see https://bugs.freedesktop.org/show_bug.cgi?id=66605).
   base::ReplaceChars(suffix, " ", "_", &suffix);
   std::string glob = prefix + "*" + suffix + ".desktop";
@@ skipping 144 matching lines @@
   return output_buffer;
 #else
   NOTIMPLEMENTED();
   return std::string();
 #endif
 }
 
 bool CreateDesktopShortcut(
     const web_app::ShortcutInfo& shortcut_info,
     const web_app::ShortcutLocations& creation_locations) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   base::FilePath shortcut_filename;
   if (!shortcut_info.extension_id.empty()) {
     shortcut_filename = GetExtensionShortcutFilename(
         shortcut_info.profile_path, shortcut_info.extension_id);
     // For extensions we do not want duplicate shortcuts. So, delete any that
     // already exist and replace them.
     if (creation_locations.on_desktop)
       DeleteShortcutOnDesktop(shortcut_filename);
 
@@ skipping 10 matching lines @@
   std::string icon_name =
       CreateShortcutIcon(shortcut_info.favicon, shortcut_filename);
 
   std::string app_name =
       web_app::GenerateApplicationNameFromInfo(shortcut_info);
 
   bool success = true;
 
   base::FilePath chrome_exe_path = GetChromeExePath();
   if (chrome_exe_path.empty()) {
-    LOG(WARNING) << "Could not get executable path.";
+    NOTREACHED();
     return false;
   }
 
   if (creation_locations.on_desktop) {
     std::string contents = GetDesktopFileContents(
         chrome_exe_path,
         app_name,
         shortcut_info.url,
         shortcut_info.extension_id,
         shortcut_info.title,
@@ skipping 41 matching lines @@
   success = CreateShortcutInApplicationsMenu(
       shortcut_filename, contents, directory_filename, directory_contents) &&
       success;
 
   return success;
 }
 
 bool CreateAppListDesktopShortcut(
     const std::string& wm_class,
     const std::string& title) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   base::FilePath desktop_name(kAppListDesktopName);
   base::FilePath shortcut_filename = desktop_name.AddExtension("desktop");
 
   // We do not want duplicate shortcuts. Delete any that already exist and
   // replace them.
   DeleteShortcutInApplicationsMenu(shortcut_filename, base::FilePath());
 
   base::FilePath chrome_exe_path = GetChromeExePath();
   if (chrome_exe_path.empty()) {
-    LOG(WARNING) << "Could not get executable path.";
+    NOTREACHED();
     return false;
   }
 
   gfx::ImageFamily icon_images;
   ResourceBundle& resource_bundle = ResourceBundle::GetSharedInstance();
   icon_images.Add(*resource_bundle.GetImageSkiaNamed(IDR_APP_LIST_16));
   icon_images.Add(*resource_bundle.GetImageSkiaNamed(IDR_APP_LIST_32));
   icon_images.Add(*resource_bundle.GetImageSkiaNamed(IDR_APP_LIST_48));
   icon_images.Add(*resource_bundle.GetImageSkiaNamed(IDR_APP_LIST_256));
   std::string icon_name = CreateShortcutIcon(icon_images, desktop_name);
 
   base::CommandLine command_line(chrome_exe_path);
   command_line.AppendSwitch(switches::kShowAppList);
   std::string contents =
       GetDesktopFileContentsForCommand(command_line,
                                        wm_class,
                                        GURL(),
                                        base::UTF8ToUTF16(title),
                                        icon_name,
                                        kAppListCategories,
                                        false);
   return CreateShortcutInApplicationsMenu(
       shortcut_filename, contents, base::FilePath(), "");
 }
 
 void DeleteDesktopShortcuts(const base::FilePath& profile_path,
                             const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   base::FilePath shortcut_filename = GetExtensionShortcutFilename(
       profile_path, extension_id);
   DCHECK(!shortcut_filename.empty());
 
   DeleteShortcutOnDesktop(shortcut_filename);
   // Delete shortcuts from |kDirectoryFilename|.
   // Note that it is possible that shortcuts were not created in the Chrome Apps
   // directory. It doesn't matter: this will still delete the shortcut even if
   // it isn't in the directory.
   DeleteShortcutInApplicationsMenu(shortcut_filename,
                                    base::FilePath(kDirectoryFilename));
 }
 
 void DeleteAllDesktopShortcuts(const base::FilePath& profile_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   scoped_ptr<base::Environment> env(base::Environment::Create());
 
   // Delete shortcuts from Desktop.
   base::FilePath desktop_path;
   if (PathService::Get(base::DIR_USER_DESKTOP, &desktop_path)) {
     std::vector<base::FilePath> shortcut_filenames_desktop =
         GetExistingProfileShortcutFilenames(profile_path, desktop_path);
-    for (std::vector<base::FilePath>::const_iterator it =
-         shortcut_filenames_desktop.begin();
-         it != shortcut_filenames_desktop.end(); ++it) {
-      DeleteShortcutOnDesktop(*it);
+    for (const auto& shortcut : shortcut_filenames_desktop) {
+      DeleteShortcutOnDesktop(shortcut);
     }
   }
 
   // Delete shortcuts from |kDirectoryFilename|.
-  base::FilePath applications_menu;
-  if (GetDataWriteLocation(env.get(), &applications_menu)) {
-    applications_menu = applications_menu.AppendASCII("applications");
-    std::vector<base::FilePath> shortcut_filenames_app_menu =
-        GetExistingProfileShortcutFilenames(profile_path, applications_menu);
-    for (std::vector<base::FilePath>::const_iterator it =
-         shortcut_filenames_app_menu.begin();
-         it != shortcut_filenames_app_menu.end(); ++it) {
-      DeleteShortcutInApplicationsMenu(*it,
-                                       base::FilePath(kDirectoryFilename));
-    }
+  base::FilePath applications_menu = GetDataWriteLocation(env.get());
+  applications_menu = applications_menu.AppendASCII("applications");
+  std::vector<base::FilePath> shortcut_filenames_app_menu =
+      GetExistingProfileShortcutFilenames(profile_path, applications_menu);
+  for (const auto& menu : shortcut_filenames_app_menu) {
+    DeleteShortcutInApplicationsMenu(menu, base::FilePath(kDirectoryFilename));
   }
 }
 
 }  // namespace shell_integration_linux