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

chrome/browser/shell_integration_win.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_win.h"
 
 #include <windows.h>
 #include <objbase.h>
 #include <shlwapi.h>
 #include <shobjidl.h>
@@ skipping 14 matching lines @@
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_propvariant.h"
 #include "base/win/shortcut.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/policy/policy_path_parser.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/browser/win/settings_app_monitor.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/shell_handler_win.mojom.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/install_static/install_util.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/scoped_user_protocol_entry.h"
 #include "chrome/installer/util/shell_util.h"
 #include "components/variations/variations_associated_data.h"
-#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/utility_process_mojo_client.h"
 #include "ui/base/l10n/l10n_util.h"
 
-using content::BrowserThread;
-
 namespace shell_integration {
 
 namespace {
 
 // Helper function for GetAppId to generates profile id
 // from profile path. "profile_id" is composed of sanitized basenames of
 // user data dir and profile dir joined by a ".".
 base::string16 GetProfileIdFromPath(const base::FilePath& profile_path) {
   // Return empty string if profile_path is empty
   if (profile_path.empty())
@@ skipping 70 matching lines @@
     app_name = GetAppListAppName();
   } else {
     app_name = ShellUtil::GetBrowserModelId(is_per_user_install);
   }
   DCHECK(!app_name.empty());
 
   return win::GetAppModelIdForProfile(app_name, profile_path);
 }
 
 void MigrateTaskbarPinsCallback() {
-  // This should run on the file thread.
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   // Get full path of chrome.
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe))
     return;
 
   base::FilePath pins_path;
   if (!PathService::Get(base::DIR_TASKBAR_PINS, &pins_path)) {
     NOTREACHED();
     return;
@@ skipping 156 matching lines @@
 // This helper class manages both the timer and the registry watchers and makes
 // sure the callback for the end of the settings interaction is only run once.
 // This class also manages its own lifetime.
 class OpenSystemSettingsHelper {
  public:
   // Begin the monitoring and will call |on_finished_callback| when done.
   // Takes in a null-terminated array of |protocols| whose registry keys must be
   // watched. The array must contain at least one element.
   static void Begin(const wchar_t* const protocols[],
                     const base::Closure& on_finished_callback) {
-    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+    base::ThreadRestrictions::AssertIOAllowed();
 
     delete instance_;
     instance_ = new OpenSystemSettingsHelper(protocols, on_finished_callback);
   }
 
  private:
   // The reason the settings interaction concluded. Do not modify the ordering
   // because it is used for UMA.
   enum ConcludeReason { REGISTRY_WATCHER, TIMEOUT, NUM_CONCLUDE_REASON_TYPES };
 
@@ skipping 15 matching lines @@
     }
     // Only the watchers that were succesfully initialized are counted.
     registry_watcher_count_ = registry_key_watchers_.size();
 
     timer_.Start(
         FROM_HERE, base::TimeDelta::FromMinutes(2),
         base::Bind(&OpenSystemSettingsHelper::ConcludeInteraction,
                    weak_ptr_factory_.GetWeakPtr(), ConcludeReason::TIMEOUT));
   }
 
+  ~OpenSystemSettingsHelper() {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  }
+
   // Called when a change is detected on one of the registry keys being watched.
   // Note: All types of modification to the registry key will trigger this
   //       function even if the value change is the only one that matters. This
   //       is good enough for now.
   void OnRegistryKeyChanged() {
-    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     // Make sure all the registry watchers have fired.
     if (--registry_watcher_count_ == 0) {
       UMA_HISTOGRAM_MEDIUM_TIMES(
           "DefaultBrowser.SettingsInteraction.RegistryWatcherDuration",
           base::TimeTicks::Now() - start_time_);
 
       ConcludeInteraction(ConcludeReason::REGISTRY_WATCHER);
     }
   }
 
   // Ends the monitoring with the system settings. Will call
   // |on_finished_callback_| and then dispose of this class instance to make
   // sure the callback won't get called subsequently.
   void ConcludeInteraction(ConcludeReason conclude_reason) {
-    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
     UMA_HISTOGRAM_ENUMERATION(
         "DefaultBrowser.SettingsInteraction.ConcludeReason", conclude_reason,
         NUM_CONCLUDE_REASON_TYPES);
     on_finished_callback_.Run();
     delete instance_;
     instance_ = nullptr;
   }
 
   // Helper function to create a registry watcher for a given |key_path|. Do
   // nothing on initialization failure.
   void AddRegistryKeyWatcher(const wchar_t* key_path) {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
     auto reg_key = base::MakeUnique<base::win::RegKey>(HKEY_CURRENT_USER,
                                                        key_path, KEY_NOTIFY);
 
     if (reg_key->Valid() &&
         reg_key->StartWatching(
             base::Bind(&OpenSystemSettingsHelper::OnRegistryKeyChanged,
                        weak_ptr_factory_.GetWeakPtr()))) {
       registry_key_watchers_.push_back(std::move(reg_key));
     }
   }
@@ skipping 15 matching lines @@
   // There can be multiple registry key watchers as some settings modify
   // multiple protocol associations. e.g. Changing the default browser modifies
   // the http and https associations.
   std::vector<std::unique_ptr<base::win::RegKey>> registry_key_watchers_;
 
   base::OneShotTimer timer_;
 
   // Records the time it takes for the final registry watcher to get signaled.
   base::TimeTicks start_time_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   // Weak ptrs are used to bind this class to the callbacks of the timer and the
   // registry watcher. This makes it possible to self-delete after one of the
   // callbacks is executed to cancel the remaining ones.
   base::WeakPtrFactory<OpenSystemSettingsHelper> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(OpenSystemSettingsHelper);
 };
 
 OpenSystemSettingsHelper* OpenSystemSettingsHelper::instance_ = nullptr;
 
@@ skipping 11 matching lines @@
                           const ResultCallback& result_callback);
 
   void OnConnectionError();
   void OnIsPinnedToTaskbarResult(bool succeeded, bool is_pinned_to_taskbar);
 
   content::UtilityProcessMojoClient<chrome::mojom::ShellHandler> shell_handler_;
 
   ErrorCallback error_callback_;
   ResultCallback result_callback_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   DISALLOW_COPY_AND_ASSIGN(IsPinnedToTaskbarHelper);
 };
 
 // static
 void IsPinnedToTaskbarHelper::GetState(const ErrorCallback& error_callback,
                                        const ResultCallback& result_callback) {
   // Self-deleting when the ShellHandler completes.
   new IsPinnedToTaskbarHelper(error_callback, result_callback);
 }
 
@@ skipping 13 matching lines @@
       &IsPinnedToTaskbarHelper::OnConnectionError, base::Unretained(this)));
   shell_handler_.set_disable_sandbox();
   shell_handler_.Start();
 
   shell_handler_.service()->IsPinnedToTaskbar(
       base::Bind(&IsPinnedToTaskbarHelper::OnIsPinnedToTaskbarResult,
                  base::Unretained(this)));
 }
 
 void IsPinnedToTaskbarHelper::OnConnectionError() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
   error_callback_.Run();
   delete this;
 }
 
 void IsPinnedToTaskbarHelper::OnIsPinnedToTaskbarResult(
     bool succeeded,
     bool is_pinned_to_taskbar) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
   result_callback_.Run(succeeded, is_pinned_to_taskbar);
   delete this;
 }
 
 }  // namespace
 
 bool SetAsDefaultBrowser() {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     LOG(ERROR) << "Error getting app exe path";
     return false;
   }
 
   // From UI currently we only allow setting default browser for current user.
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   if (!ShellUtil::MakeChromeDefault(dist, ShellUtil::CURRENT_USER, chrome_exe,
                                     true /* elevate_if_not_admin */)) {
     LOG(ERROR) << "Chrome could not be set as default browser.";
     return false;
   }
 
   VLOG(1) << "Chrome registered as default browser.";
   return true;
 }
 
 bool SetAsDefaultProtocolClient(const std::string& protocol) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   if (protocol.empty())
     return false;
 
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     LOG(ERROR) << "Error getting app exe path";
     return false;
   }
 
   base::string16 wprotocol(base::UTF8ToUTF16(protocol));
@@ skipping 75 matching lines @@
 
 DefaultWebClientState IsDefaultProtocolClient(const std::string& protocol) {
   return GetDefaultWebClientStateFromShellUtilDefaultState(
       ShellUtil::GetChromeDefaultProtocolClientState(
           base::UTF8ToUTF16(protocol)));
 }
 
 namespace win {
 
 bool SetAsDefaultBrowserUsingIntentPicker() {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED() << "Error getting app exe path";
     return false;
   }
 
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   if (!ShellUtil::ShowMakeChromeDefaultSystemUI(dist, chrome_exe)) {
     LOG(ERROR) << "Failed to launch the set-default-browser Windows UI.";
     return false;
   }
 
   VLOG(1) << "Set-default-browser Windows UI completed.";
   return true;
 }
 
 void SetAsDefaultBrowserUsingSystemSettings(
     const base::Closure& on_finished_callback) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED() << "Error getting app exe path";
     on_finished_callback.Run();
     return;
   }
 
   // Create an action recorder that will open the settings app once it has
   // initialized.
   std::unique_ptr<DefaultBrowserActionRecorder> recorder(
       new DefaultBrowserActionRecorder(base::Bind(
           base::IgnoreResult(&ShellUtil::ShowMakeChromeDefaultSystemUI),
           base::Unretained(BrowserDistribution::GetDistribution()),
           chrome_exe)));
 
   // The helper manages its own lifetime. Bind the action recorder
   // into the finished callback to keep it alive throughout the
   // interaction.
   static const wchar_t* const kProtocols[] = {L"http", L"https", nullptr};
   OpenSystemSettingsHelper::Begin(
       kProtocols, base::Bind(&OnSettingsAppFinished, base::Passed(&recorder),
                              on_finished_callback));
 }
 
 bool SetAsDefaultProtocolClientUsingIntentPicker(const std::string& protocol) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED() << "Error getting app exe path";
     return false;
   }
 
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   base::string16 wprotocol(base::UTF8ToUTF16(protocol));
   if (!ShellUtil::ShowMakeChromeDefaultProtocolClientSystemUI(dist, chrome_exe,
                                                               wprotocol)) {
     LOG(ERROR) << "Failed to launch the set-default-client Windows UI.";
     return false;
   }
 
   VLOG(1) << "Set-default-client Windows UI completed.";
   return true;
 }
 
 void SetAsDefaultProtocolClientUsingSystemSettings(
     const std::string& protocol,
     const base::Closure& on_finished_callback) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED() << "Error getting app exe path";
     on_finished_callback.Run();
     return;
   }
 
   // The helper manages its own lifetime.
   base::string16 wprotocol(base::UTF8ToUTF16(protocol));
@@ skipping 17 matching lines @@
 
 base::string16 GetChromiumModelIdForProfile(
     const base::FilePath& profile_path) {
   return GetAppModelIdForProfile(
       ShellUtil::GetBrowserModelId(InstallUtil::IsPerUserInstall()),
       profile_path);
 }
 
 void MigrateTaskbarPins() {
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;

[gab, 2017/05/26 18:44:06]

Can we remove this check while you're here, we only support Win7+ now

[Patrick Monette, 2017/05/29 18:54:14]

Will do in another CL

 
-  // This needs to happen eventually (e.g. so that the appid is fixed and the
-  // run-time Chrome icon is merged with the taskbar shortcut), but this is not
-  // urgent and shouldn't delay Chrome startup.
-  static const int64_t kMigrateTaskbarPinsDelaySeconds = 15;
-  BrowserThread::PostDelayedTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&MigrateTaskbarPinsCallback),
-      base::TimeDelta::FromSeconds(kMigrateTaskbarPinsDelaySeconds));
+  // This needs to happen (e.g. so that the appid is fixed and the
+  // run-time Chrome icon is merged with the taskbar shortcut), but it is not an
+  // urgent task.
+  base::PostTaskWithTraits(FROM_HERE,
+                           {base::MayBlock(), base::TaskPriority::BACKGROUND},
+                           base::Bind(&MigrateTaskbarPinsCallback));
 }
 
 void GetIsPinnedToTaskbarState(
     const ConnectionErrorCallback& on_error_callback,
     const IsPinnedToTaskbarCallback& result_callback) {
   IsPinnedToTaskbarHelper::GetState(on_error_callback, result_callback);
 }
 
 int MigrateShortcutsInPathInternal(const base::FilePath& chrome_exe,
                                    const base::FilePath& path) {
@@ skipping 98 matching lines @@
             base::win::SHORTCUT_UPDATE_EXISTING)) {
       ++shortcuts_migrated;
     }
   }
   return shortcuts_migrated;
 }
 
 }  // namespace win
 
 }  // namespace shell_integration