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 <shlwapi.h>
 #include <shobjidl.h>
 #include <propkey.h>  // Needs to come after shobjidl.h.
@@ skipping 13 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);

[Lei Zhang, 2017/05/19 23:23:13]

Looks like you wrote this code. If you are ok without any DCHECKs to help
enforce threading requirements, ok.

[Patrick Monette, 2017/05/26 01:50:12]

Your comment made me realize that there is actually a threading requirement for
the deletion of the OpenSystemSettingsHelper. I added a SequenceChecker.

-
     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 };
 
   OpenSystemSettingsHelper(const wchar_t* const protocols[],
@@ skipping 19 matching lines @@
         FROM_HERE, base::TimeDelta::FromMinutes(2),
         base::Bind(&OpenSystemSettingsHelper::ConcludeInteraction,
                    weak_ptr_factory_.GetWeakPtr(), ConcludeReason::TIMEOUT));
   }
 
   // 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);
-
     // 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);
-
     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.
@@ skipping 236 matching lines @@
     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::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(
@@ skipping 26 matching lines @@
     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 19 matching lines @@
     const base::FilePath& profile_path) {
   return GetAppModelIdForProfile(
       ShellUtil::GetBrowserModelId(InstallUtil::IsPerUserInstall()),
       profile_path);
 }
 
 void MigrateTaskbarPins() {
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
-  // 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