Migrate history_report to TaskScheduler API

GetBlockingPool() is replaced by SequencedTaskRunner. There's no
per-task trait in SequencedTaskRunner, so the shutdown behavior are
all set to BLOCK_SHUTDOWN.

Bug: 667892
Change-Id: I6e8f2507b201a8cb077d7338f504684ca1e232c8
Reviewed-on: https://chromium-review.googlesource.com/580620Reviewed-by: Tommy Nyquist <nyquist@chromium.org>
Commit-Queue: Tommy Nyquist <nyquist@chromium.org>
Cr-Commit-Position: refs/heads/master@{#488836}

chrome/browser/android/history_report/delta_file_service.cc

@@ -7,6 +7,8 @@
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/task_scheduler/task_traits.h"
 #include "chrome/browser/android/history_report/delta_file_backend_leveldb.h"
 #include "chrome/browser/android/history_report/delta_file_commons.h"
 #include "content/public/browser/browser_thread.h"
@@ -66,48 +68,33 @@ namespace history_report {
 using content::BrowserThread;
 
 DeltaFileService::DeltaFileService(const base::FilePath& dir)
-    : worker_pool_token_(BrowserThread::GetBlockingPool()->GetSequenceToken()),
-      delta_file_backend_(new DeltaFileBackend(dir)) {
-}
+    : task_runner_(base::CreateSequencedTaskRunnerWithTraits(
+          base::TaskShutdownBehavior::BLOCK_SHUTDOWN)),
+      delta_file_backend_(new DeltaFileBackend(dir)) {}
 
 DeltaFileService::~DeltaFileService() {}
 
 void DeltaFileService::PageAdded(const GURL& url) {
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DoAddPage,
-                 base::Unretained(delta_file_backend_.get()),
-                 url),
-      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+      base::Bind(&DoAddPage, base::Unretained(delta_file_backend_.get()), url));
 }
 
 void DeltaFileService::PageDeleted(const GURL& url) {
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
-      FROM_HERE,
-      base::Bind(&DoDeletePage,
-                 base::Unretained(delta_file_backend_.get()),
-                 url),
-      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&DoDeletePage,
+                            base::Unretained(delta_file_backend_.get()), url));
 }
 
 int64_t DeltaFileService::Trim(int64_t lower_bound) {
   int64_t result;
   base::WaitableEvent finished(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                                base::WaitableEvent::InitialState::NOT_SIGNALED);
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DoTrim,
-                 base::Unretained(delta_file_backend_.get()),
-                 lower_bound,
-                 base::Unretained(&finished),
-                 base::Unretained(&result)),
-      base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+      base::Bind(&DoTrim, base::Unretained(delta_file_backend_.get()),
+                 lower_bound, base::Unretained(&finished),
+                 base::Unretained(&result)));
   finished.Wait();
   return result;
 }
@@ -118,17 +105,11 @@ std::unique_ptr<std::vector<DeltaFileEntryWithData>> DeltaFileService::Query(
   std::unique_ptr<std::vector<DeltaFileEntryWithData>> result;
   base::WaitableEvent finished(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                                base::WaitableEvent::InitialState::NOT_SIGNALED);
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DoQuery,
-                 base::Unretained(delta_file_backend_.get()),
-                 last_seq_no,
-                 limit,
-                 base::Unretained(&finished),
-                 base::Unretained(&result)),
-      base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+      base::Bind(&DoQuery, base::Unretained(delta_file_backend_.get()),
+                 last_seq_no, limit, base::Unretained(&finished),
+                 base::Unretained(&result)));
   finished.Wait();
   return result;
 }
@@ -137,43 +118,28 @@ bool DeltaFileService::Recreate(const std::vector<std::string>& urls) {
   bool result = false;
   base::WaitableEvent finished(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                                base::WaitableEvent::InitialState::NOT_SIGNALED);
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DoRecreate,
-                 base::Unretained(delta_file_backend_.get()),
-                 urls,
-                 base::Unretained(&finished),
-                 base::Unretained(&result)),
-      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+      base::Bind(&DoRecreate, base::Unretained(delta_file_backend_.get()), urls,
+                 base::Unretained(&finished), base::Unretained(&result)));
   finished.Wait();
   return result;
 }
 
 void DeltaFileService::Clear() {
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DoClear,
-                 base::Unretained(delta_file_backend_.get())),
-      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+      base::Bind(&DoClear, base::Unretained(delta_file_backend_.get())));
 }
 
 std::string DeltaFileService::Dump() {
   std::string dump;
   base::WaitableEvent finished(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                                base::WaitableEvent::InitialState::NOT_SIGNALED);
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DoDump,
-                 base::Unretained(delta_file_backend_.get()),
-                 base::Unretained(&finished),
-                 base::Unretained(&dump)),
-      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+      base::Bind(&DoDump, base::Unretained(delta_file_backend_.get()),
+                 base::Unretained(&finished), base::Unretained(&dump)));
   finished.Wait();
   return dump;
 }

chrome/browser/android/history_report/delta_file_service.h

@@ -52,8 +52,7 @@ class DeltaFileService {
   std::string Dump();
 
  private:
-
-  base::SequencedWorkerPool::SequenceToken worker_pool_token_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
   std::unique_ptr<DeltaFileBackend> delta_file_backend_;
 
   DISALLOW_COPY_AND_ASSIGN(DeltaFileService);

chrome/browser/android/history_report/usage_reports_buffer_service.cc

@@ -7,6 +7,8 @@
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/task_scheduler/task_traits.h"
 #include "chrome/browser/android/history_report/usage_reports_buffer_backend.h"
 #include "chrome/browser/android/proto/delta_file.pb.h"
 #include "content/public/browser/browser_thread.h"
@@ -63,34 +65,23 @@ namespace history_report {
 using content::BrowserThread;
 
 UsageReportsBufferService::UsageReportsBufferService(const base::FilePath& dir)
-    : worker_pool_token_(BrowserThread::GetBlockingPool()->GetSequenceToken()),
-      backend_(new UsageReportsBufferBackend(dir)) {
-}
+    : task_runner_(base::CreateSequencedTaskRunnerWithTraits(
+          base::TaskShutdownBehavior::BLOCK_SHUTDOWN)),
+      backend_(new UsageReportsBufferBackend(dir)) {}
 
 UsageReportsBufferService::~UsageReportsBufferService() {}
 
 void UsageReportsBufferService::Init() {
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
-      FROM_HERE,
-      base::Bind(&DoInit, base::Unretained(backend_.get())),
-      base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&DoInit, base::Unretained(backend_.get())));
 }
 
 void UsageReportsBufferService::AddVisit(const std::string& id,
                                          int64_t timestamp_ms,
                                          bool typed_visit) {
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
-      FROM_HERE,
-      base::Bind(&DoAddVisit,
-                 base::Unretained(backend_.get()),
-                 id,
-                 timestamp_ms,
-                 typed_visit),
-      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&DoAddVisit, base::Unretained(backend_.get()), id,
+                            timestamp_ms, typed_visit));
 }
 
 std::unique_ptr<std::vector<UsageReport>>
@@ -98,18 +89,13 @@ UsageReportsBufferService::GetUsageReportsBatch(int32_t batch_size) {
   std::unique_ptr<std::vector<UsageReport>> result;
   base::WaitableEvent finished(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                                base::WaitableEvent::InitialState::NOT_SIGNALED);
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
   // It's ok to pass unretained pointers here because this is a synchronous
   // call.
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DoGetUsageReportsBatch,
-                 base::Unretained(backend_.get()),
-                 batch_size,
-                 base::Unretained(&finished),
-                 base::Unretained(&result)),
-      base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+      base::Bind(&DoGetUsageReportsBatch, base::Unretained(backend_.get()),
+                 batch_size, base::Unretained(&finished),
+                 base::Unretained(&result)));
   finished.Wait();
   return result;
 }
@@ -118,33 +104,23 @@ void UsageReportsBufferService::Remove(
     const std::vector<std::string>& report_ids) {
   base::WaitableEvent finished(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                                base::WaitableEvent::InitialState::NOT_SIGNALED);
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
   // It's ok to pass unretained pointers here because this is a synchronous
   // call.
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DoRemove,
-                 base::Unretained(backend_.get()),
-                 base::Unretained(&report_ids),
-                 base::Unretained(&finished)),
-      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+      base::Bind(&DoRemove, base::Unretained(backend_.get()),
+                 base::Unretained(&report_ids), base::Unretained(&finished)));
   finished.Wait();
 }
 
 void UsageReportsBufferService::Clear() {
   base::WaitableEvent finished(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                                base::WaitableEvent::InitialState::NOT_SIGNALED);
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
   // It's ok to pass unretained pointers here because this is a synchronous
   // call.
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
-      FROM_HERE,
-      base::Bind(&DoClear,
-                 base::Unretained(backend_.get()),
-                 base::Unretained(&finished)),
-      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&DoClear, base::Unretained(backend_.get()),
+                                    base::Unretained(&finished)));
   finished.Wait();
 }
 
@@ -152,17 +128,12 @@ std::string UsageReportsBufferService::Dump() {
   std::string dump;
   base::WaitableEvent finished(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                                base::WaitableEvent::InitialState::NOT_SIGNALED);
-  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
   // It's ok to pass unretained pointers here because this is a synchronous
   // call.
-  pool->PostSequencedWorkerTaskWithShutdownBehavior(
-      worker_pool_token_,
+  task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DoDump,
-                 base::Unretained(backend_.get()),
-                 base::Unretained(&finished),
-                 base::Unretained(&dump)),
-      base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+      base::Bind(&DoDump, base::Unretained(backend_.get()),
+                 base::Unretained(&finished), base::Unretained(&dump)));
   finished.Wait();
   return dump;
 }

chrome/browser/android/history_report/usage_reports_buffer_service.h

@@ -53,8 +53,7 @@ class UsageReportsBufferService {
   std::string Dump();
 
  private:
-  // Token used to serialize buffer operations.
-  base::SequencedWorkerPool::SequenceToken worker_pool_token_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
   // Non thread safe backend.
   std::unique_ptr<UsageReportsBufferBackend> backend_;