Remove the usage of BrowserThread::FILE in the shell_integration* files

chrome/browser/shell_integration_linux.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/shell_integration_linux.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 
 #include <memory>
@@ skipping 32 matching lines @@
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/features.h"
 #include "chrome/grit/chrome_unscaled_resources.h"
 #include "components/version_info/version_info.h"
-#include "content/public/browser/browser_thread.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_family.h"
 #include "url/gurl.h"
 
-using content::BrowserThread;
-
 namespace shell_integration {
 
 namespace {
 
 // Helper to launch xdg scripts. We don't want them to ask any questions on the
 // terminal etc. The function returns true if the utility launches and exits
 // cleanly, in which case |exit_code| returns the utility's exit code.
 bool LaunchXdgUtility(const std::vector<std::string>& argv, int* exit_code) {
   // xdg-settings internally runs xdg-mime, which uses mv to move newly-created
   // files on top of originals after making changes to them. In the event that
@@ skipping 488 matching lines @@
 
   // 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
 
 base::FilePath GetDataWriteLocation(base::Environment* env) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   return base::nix::GetXDGDirectory(env, "XDG_DATA_HOME", ".local/share");
 }
 
 std::vector<base::FilePath> GetDataSearchLocations(base::Environment* env) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   std::vector<base::FilePath> search_paths;
   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());
@@ skipping 90 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_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   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_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   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_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   // 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);
@@ 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_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   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 72 matching lines @@
       shortcut_filename, contents, directory_filename, directory_contents) &&
       success;
 
   return success;
 }
 
 #if BUILDFLAG(ENABLE_APP_LIST)
 bool CreateAppListDesktopShortcut(
     const std::string& wm_class,
     const std::string& title) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   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()) {
@@ skipping 19 matching lines @@
                                        icon_name,
                                        kAppListCategories,
                                        false);
   return CreateShortcutInApplicationsMenu(
       shortcut_filename, contents, base::FilePath(), "");
 }
 #endif
 
 void DeleteDesktopShortcuts(const base::FilePath& profile_path,
                             const std::string& extension_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   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_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   std::unique_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 (const auto& shortcut : shortcut_filenames_desktop) {
       DeleteShortcutOnDesktop(shortcut);
     }
   }
 
   // Delete shortcuts from |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