Remove usage of SequencedWorkerPool::GetNamedSequenceToken from debug_log_writer.cc.

chrome/browser/chromeos/system_logs/debug_log_writer.cc

 // Copyright 2014 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/chromeos/system_logs/debug_log_writer.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
+#include "base/lazy_instance.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/task_scheduler/post_task.h"
-#include "base/threading/sequenced_worker_pool.h"
 #include "chrome/common/logging_chrome.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/debug_daemon_client.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace chromeos {
 
 namespace {
 
 // Callback for returning status of executed external command.
 typedef base::Callback<void(bool succeeded)> CommandCompletionCallback;
 
 const char kGzipCommand[] = "/bin/gzip";
 const char kTarCommand[] = "/bin/tar";
 
-scoped_refptr<base::SequencedTaskRunner> GetSequencedTaskRunner(
-    const std::string sequence_name) {
-  base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
-  return pool->GetSequencedTaskRunnerWithShutdownBehavior(
-      pool->GetNamedSequenceToken(sequence_name),
-      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
-}
+struct DebugLogWriterTaskRunner {
+  const scoped_refptr<base::SequencedTaskRunner> task_runner =
+      base::CreateSequencedTaskRunnerWithTraits(
+          {base::MayBlock(), base::TaskPriority::BACKGROUND,
+           base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
+};
+
+base::LazyInstance<DebugLogWriterTaskRunner>::Leaky g_sequenced_task_runner =
+    LAZY_INSTANCE_INITIALIZER;
 
 // Called upon completion of |WriteDebugLogToFile|. Closes file
 // descriptor, deletes log file in the case of failure and calls
 // |callback|.
 void WriteDebugLogToFileCompleted(
     const base::FilePath& file_path,
     const std::string& sequence_token_name,
     const DebugLogWriter::StoreLogsCallback& callback,
     bool succeeded) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!succeeded) {
-    bool posted = GetSequencedTaskRunner(sequence_token_name)->PostTaskAndReply(
+    bool posted = g_sequenced_task_runner.Get().task_runner->PostTaskAndReply(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&base::DeleteFile), file_path, false),
         base::Bind(callback, file_path, false));
     DCHECK(posted);
     return;
   }
   if (!callback.is_null())
     callback.Run(file_path, true);
 }
 
@@ skipping 10 matching lines @@
                << ", "
                << "error: " << file->error_details();
     return;
   }
   chromeos::DBusThreadManager::Get()->GetDebugDaemonClient()->DumpDebugLogs(
       should_compress, file->GetPlatformFile(),
       base::Bind(&WriteDebugLogToFileCompleted, file_path, sequence_token_name,
                  callback));
 
   // Close the file on an IO-allowed thread.
-  GetSequencedTaskRunner(sequence_token_name)
-      ->PostTask(FROM_HERE,
-                 base::Bind(&base::DeletePointer<base::File>, file.release()));
+  g_sequenced_task_runner.Get().task_runner->DeleteSoon(FROM_HERE,
+                                                        file.release());
 }
 
 // Runs command with its parameters as defined in |argv|.
 // Upon completion, it will report command run outcome via |callback| on the
 // same thread from where it was initially called from.
 void RunCommand(const std::vector<std::string>& argv,
                 const CommandCompletionCallback& callback) {
   base::Process process = base::LaunchProcess(argv, base::LaunchOptions());
   if (!process.IsValid()) {
     LOG(ERROR) << "Failed to execute command " << argv[0];
@@ skipping 123 matching lines @@
 void StartLogRetrieval(const base::FilePath& file_name_template,
                        bool should_compress,
                        const std::string& sequence_token_name,
                        const DebugLogWriter::StoreLogsCallback& callback) {
   base::FilePath file_path =
       logging::GenerateTimestampedName(file_name_template, base::Time::Now());
 
   int flags = base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE;
   std::unique_ptr<base::File> file(new base::File);
   base::File* file_ptr = file.get();
-  GetSequencedTaskRunner(sequence_token_name)
-      ->PostTaskAndReply(
-          FROM_HERE, base::Bind(&InitializeLogFile, base::Unretained(file_ptr),
-                                file_path, flags),
-          base::Bind(&WriteDebugLogToFile, base::Passed(&file),
-                     sequence_token_name, file_path, should_compress,
-                     callback));
+  g_sequenced_task_runner.Get().task_runner->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&InitializeLogFile, base::Unretained(file_ptr), file_path,
+                 flags),
+      base::Bind(&WriteDebugLogToFile, base::Passed(&file), sequence_token_name,
+                 file_path, should_compress, callback));
 }
 
 const char kDefaultSequenceName[] = "DebugLogWriter";
 
 }  // namespace
 
 // static.
 void DebugLogWriter::StoreLogs(const base::FilePath& fileshelf,
                                bool should_compress,
                                const StoreLogsCallback& callback) {
@@ skipping 18 matching lines @@
       fileshelf.Append(FILE_PATH_LITERAL("combined-logs.tar"));
 
   // Get system logs from /var/log first, then add user-specific stuff.
   StartLogRetrieval(file_path,
                     false,
                     sequence_token_name,
                     base::Bind(&OnSystemLogsAdded, callback));
 }
 
 }  // namespace chromeos