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

chrome/browser/shell_integration.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.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/metrics/histogram_macros.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/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "chrome/browser/policy/policy_path_parser.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/prefs/pref_service.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_thread.h"
 
 #if defined(OS_CHROMEOS)
@@ skipping 13 matching lines @@
 #endif
 
 using content::BrowserThread;
 
 namespace shell_integration {
 
 namespace {
 
 const struct AppModeInfo* gAppModeInfo = nullptr;
 
+scoped_refptr<base::SequencedTaskRunner>
+CreateTaskRunnerForDefaultWebClientWorker() {
+#if defined(OS_WIN)
+  if (base::win::GetVersion() >= base::win::VERSION_WIN10)
+    // TODO(pmonette): Windows 10's implementation uses a base::Timer which
+    // currently still requires a SingleThreadTaskRunner. Change this to a
+    // SequencedTaskRunner when crbug.com/552633 is fixed.
+    return base::CreateSingleThreadTaskRunnerWithTraits({base::MayBlock()});
+#endif  // defined(OS_WIN)
+  return base::CreateSequencedTaskRunnerWithTraits({base::MayBlock()});
+}
+
 }  // namespace
 
 bool CanSetAsDefaultBrowser() {
   return GetDefaultWebClientSetPermission() != SET_DEFAULT_NOT_ALLOWED;
 }
 
 #if !defined(OS_WIN)
 bool IsElevationNeededForSettingDefaultProtocolClient() {
   return false;
 }
@@ skipping 72 matching lines @@
     return l10n_util::GetStringUTF16(IDS_APP_SHORTCUTS_SUBDIR_NAME_CANARY);
   return l10n_util::GetStringUTF16(IDS_APP_SHORTCUTS_SUBDIR_NAME);
 }
 #endif  // !defined(OS_WIN)
 
 ///////////////////////////////////////////////////////////////////////////////
 // DefaultWebClientWorker
 //
 
 void DefaultWebClientWorker::StartCheckIsDefault() {
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
+  GetTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&DefaultWebClientWorker::CheckIsDefault, this, false));
 }
 
 void DefaultWebClientWorker::StartSetAsDefault() {
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&DefaultWebClientWorker::SetAsDefault, this));
+  GetTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&DefaultWebClientWorker::SetAsDefault, this));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DefaultWebClientWorker, protected:
 
 DefaultWebClientWorker::DefaultWebClientWorker(
     const DefaultWebClientWorkerCallback& callback,
     const char* worker_name)
     : callback_(callback), worker_name_(worker_name) {}
 
 DefaultWebClientWorker::~DefaultWebClientWorker() = default;
 
 void DefaultWebClientWorker::OnCheckIsDefaultComplete(
     DefaultWebClientState state,
     bool is_following_set_as_default) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   UpdateUI(state);
 
   if (is_following_set_as_default)
     ReportSetDefaultResult(state);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DefaultWebClientWorker, private:
 
+// static
+scoped_refptr<base::SequencedTaskRunner>
+DefaultWebClientWorker::GetTaskRunner() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  // TODO(pmonette): The better way to make sure all instances of
+  // DefaultWebClient share a SequencedTaskRunner is to make the worker a
+  // singleton.
+  static scoped_refptr<base::SequencedTaskRunner>* task_runner = nullptr;
+
+  if (!task_runner) {
+    task_runner = new scoped_refptr<base::SequencedTaskRunner>(
+        CreateTaskRunnerForDefaultWebClientWorker());
+  }
+
+  return *task_runner;
+}
+
 void DefaultWebClientWorker::CheckIsDefault(bool is_following_set_as_default) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
+
   DefaultWebClientState state = CheckIsDefaultImpl();
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DefaultBrowserWorker::OnCheckIsDefaultComplete, this, state,
                  is_following_set_as_default));
 }
 
 void DefaultWebClientWorker::SetAsDefault() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   // SetAsDefaultImpl will make sure the callback is executed exactly once.
   SetAsDefaultImpl(
       base::Bind(&DefaultWebClientWorker::CheckIsDefault, this, true));
 }
 
 void DefaultWebClientWorker::ReportSetDefaultResult(
     DefaultWebClientState state) {
   base::LinearHistogram::FactoryGet(
       base::StringPrintf("%s.SetDefaultResult2", worker_name_), 1,
@@ skipping 114 matching lines @@
             return;
         }
       }
 #endif  // defined(OS_WIN)
       break;
   }
   on_finished_callback.Run();
 }
 
 }  // namespace shell_integration