Remove explicit usage of SequencedWorkerPool from UploadList.

components/upload_list/upload_list.cc

 // Copyright 2013 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 "components/upload_list/upload_list.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
+#include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
-#include "base/threading/sequenced_worker_pool.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/task_runner.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 
 UploadList::UploadInfo::UploadInfo(const std::string& upload_id,
                                    const base::Time& upload_time,
                                    const std::string& local_id,
                                    const base::Time& capture_time,
                                    State state)
     : upload_id(upload_id),
       upload_time(upload_time),
       local_id(local_id),
       capture_time(capture_time),
@@ skipping 13 matching lines @@
     : upload_id(upload_id), upload_time(upload_time), state(State::Uploaded) {}
 
 UploadList::UploadInfo::UploadInfo(const UploadInfo& upload_info)
     : upload_id(upload_info.upload_id),
       upload_time(upload_info.upload_time),
       local_id(upload_info.local_id),
       capture_time(upload_info.capture_time),
       state(upload_info.state),
       file_size(upload_info.file_size) {}
 
-UploadList::UploadInfo::~UploadInfo() {}
+UploadList::UploadInfo::~UploadInfo() = default;
 
-UploadList::UploadList(
-    Delegate* delegate,
-    const base::FilePath& upload_log_path,
-    const scoped_refptr<base::SequencedWorkerPool>& worker_pool)
+UploadList::UploadList(Delegate* delegate,
+                       const base::FilePath& upload_log_path,
+                       scoped_refptr<base::TaskRunner> task_runner)
     : delegate_(delegate),
       upload_log_path_(upload_log_path),
-      worker_pool_(worker_pool) {}
+      task_runner_(std::move(task_runner)) {}
 
-UploadList::~UploadList() {}
+UploadList::~UploadList() = default;
 
 void UploadList::LoadUploadListAsynchronously() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  worker_pool_->PostTask(
-      FROM_HERE,
-      base::Bind(&UploadList::PerformLoadAndNotifyDelegate,
-                 this, base::ThreadTaskRunnerHandle::Get()));
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&UploadList::PerformLoadAndNotifyDelegate, this,
+                            base::SequencedTaskRunnerHandle::Get()));
 }
 
 void UploadList::ClearDelegate() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   delegate_ = NULL;
 }
 
 void UploadList::PerformLoadAndNotifyDelegate(
-    const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
+    scoped_refptr<base::SequencedTaskRunner> task_runner) {
   std::vector<UploadInfo> uploads;
   LoadUploadList(&uploads);
   task_runner->PostTask(
       FROM_HERE,
       base::Bind(&UploadList::SetUploadsAndNotifyDelegate, this,
                  std::move(uploads)));
 }
 
 void UploadList::LoadUploadList(std::vector<UploadInfo>* uploads) {
   if (base::PathExists(upload_log_path_)) {
@@ skipping 45 matching lines @@
         !components[4].empty() &&
         base::StringToInt(components[4], &state)) {
       info.state = static_cast<UploadInfo::State>(state);
     }
 
     uploads->push_back(info);
   }
 }
 
 void UploadList::SetUploadsAndNotifyDelegate(std::vector<UploadInfo> uploads) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   uploads_ = std::move(uploads);
   if (delegate_)
     delegate_->OnUploadListAvailable();
 }
 
 void UploadList::GetUploads(size_t max_count,
                             std::vector<UploadInfo>* uploads) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   std::copy(uploads_.begin(),
             uploads_.begin() + std::min(uploads_.size(), max_count),
             std::back_inserter(*uploads));
 }
 
 void UploadList::RequestSingleCrashUploadAsync(const std::string& local_id) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 #if defined(OS_WIN) || defined(OS_MACOSX)
-  DCHECK(thread_checker_.CalledOnValidThread());
-  worker_pool_->PostTask(
+  task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&UploadList::RequestSingleCrashUpload, this, local_id));
 #endif
 }
 
 void UploadList::RequestSingleCrashUpload(const std::string& local_id) {
   // Manual uploads for not uploaded crash reports are not available for non
   // crashpad systems.
   NOTREACHED();
 }