Remove the usage of BrowserThread::FILE in web_ui_user_script_loader.cc

extensions/browser/web_ui_user_script_loader.cc

 // Copyright 2015 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 "extensions/browser/web_ui_user_script_loader.h"
 
+#include <set>
+#include <string>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/memory/ref_counted.h"
+#include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "content/public/browser/browser_context.h"
-#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/guest_view/web_view/web_ui/web_ui_url_fetcher.h"
 
 namespace {
 
-void SerializeOnFileThread(
+void SerializeOnBlockingTask(
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
     std::unique_ptr<extensions::UserScriptList> user_scripts,
     extensions::UserScriptLoader::LoadScriptsCallback callback) {
   std::unique_ptr<base::SharedMemory> memory =
       extensions::UserScriptLoader::Serialize(*user_scripts);
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI, FROM_HERE,
-      base::Bind(callback, base::Passed(&user_scripts), base::Passed(&memory)));
+
+  task_runner->PostTask(
+      FROM_HERE, base::BindOnce(std::move(callback), std::move(user_scripts),
+                                std::move(memory)));
 }
 
 }  // namespace
 
 struct WebUIUserScriptLoader::UserScriptRenderInfo {
   int render_process_id;
   int render_frame_id;
 
   UserScriptRenderInfo() : render_process_id(-1), render_frame_id(-1) {}
 
@@ skipping 25 matching lines @@
   extensions::UserScriptLoader::AddScripts(std::move(scripts));
 }
 
 void WebUIUserScriptLoader::LoadScripts(
     std::unique_ptr<extensions::UserScriptList> user_scripts,
     const std::set<HostID>& changed_hosts,
     const std::set<int>& added_script_ids,
     LoadScriptsCallback callback) {
   DCHECK(!user_scripts_cache_) << "Loading scripts in flight.";
   user_scripts_cache_.swap(user_scripts);
-  scripts_loaded_callback_ = callback;
+  scripts_loaded_callback_ = std::move(callback);
 
   // The total number of the tasks is used to trace whether all the fetches
   // are complete. Therefore, we store all the fetcher pointers in |fetchers_|
   // before we get theis number. Once we get the total number, start each
   // fetch tasks.
   DCHECK_EQ(0u, complete_fetchers_);
 
   for (const std::unique_ptr<extensions::UserScript>& script :
        *user_scripts_cache_) {
     if (added_script_ids.count(script->id()) == 0)
@@ skipping 67 matching lines @@
 
   ++complete_fetchers_;
   if (complete_fetchers_ == fetchers_.size()) {
     complete_fetchers_ = 0;
     OnWebUIURLFetchComplete();
     fetchers_.clear();
   }
 }
 
 void WebUIUserScriptLoader::OnWebUIURLFetchComplete() {
-  content::BrowserThread::PostTask(
-      content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&SerializeOnFileThread, base::Passed(&user_scripts_cache_),
-                 scripts_loaded_callback_));
-  scripts_loaded_callback_.Reset();
-  user_scripts_cache_.reset();
+  base::PostTaskWithTraits(
+      FROM_HERE, {base::MayBlock()},
+      base::BindOnce(
+          &SerializeOnBlockingTask, base::SequencedTaskRunnerHandle::Get(),
+          std::move(user_scripts_cache_), std::move(scripts_loaded_callback_)));
 }