Convert PpdCache and PpdProvider to TaskScheduler.

chromeos/printing/ppd_cache.cc

 // Copyright 2016 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 "chromeos/printing/ppd_cache.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/json/json_parser.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/lock.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chromeos/printing/printing_constants.h"
 #include "crypto/sha2.h"
 #include "net/base/io_buffer.h"
 #include "net/filter/gzip_header.h"
 
 namespace chromeos {
 namespace printing {
 namespace {
 
 class PpdCacheImpl : public PpdCache {
  public:
-  PpdCacheImpl(const base::FilePath& cache_base_dir,
-               const scoped_refptr<base::SequencedTaskRunner>& disk_task_runner)
-      : cache_base_dir_(cache_base_dir), disk_task_runner_(disk_task_runner) {}
+  explicit PpdCacheImpl(const base::FilePath& cache_base_dir)
+      : cache_base_dir_(cache_base_dir),
+        fetch_task_runner_(base::CreateSequencedTaskRunnerWithTraits(
+            {base::TaskPriority::USER_VISIBLE,
+             base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
+        store_task_runner_(base::CreateSequencedTaskRunnerWithTraits(
+            {base::TaskPriority::BACKGROUND,
+             base::TaskShutdownBehavior::BLOCK_SHUTDOWN})) {}
 
   // Public API functions.
   void Find(const std::string& key, const FindCallback& cb) override {
     // Ensure the cache lives until the op is over.
     AddRef();
     ++inflight_ops_;
-    disk_task_runner_->PostTask(
+    fetch_task_runner_->PostTask(
         FROM_HERE, base::Bind(&PpdCacheImpl::FindImpl, this, key,
                               base::SequencedTaskRunnerHandle::Get(), cb));
   }
 
   // Store the given contents at the given key.  If cb is non-null, it will
   // be invoked on completion.
   void Store(const std::string& key,
              const std::string& contents,
              const base::Callback<void()>& cb) override {
     AddRef();
     ++inflight_ops_;
-    disk_task_runner_->PostTask(
+    store_task_runner_->PostTask(

[gab, 2017/06/19 15:13:21]

It's weird to run read/write on different sequences, especially when binding
|this| as that will make access to |this| racy. Looks like the *Impl() methods
don't access member state though? Could they be anonymous methods? If so, that'd
be fine.

[skau, 2017/06/19 23:31:08]

I was able to convert the tasks to anonymous methods.  The two operations have
different needs and they're not expected to be sequenced.

         FROM_HERE, base::Bind(&PpdCacheImpl::StoreImpl, this, key, contents,
                               base::SequencedTaskRunnerHandle::Get(), cb));
   }
 
   bool Idle() const override { return inflight_ops_ == 0; }
 
  private:
   ~PpdCacheImpl() override {}
 
   // If the cache doesn't already exist, create it.
   void MaybeCreateCache() {
     if (!base::PathExists(cache_base_dir_)) {
       base::CreateDirectory(cache_base_dir_);
     }
   }
 
   // Find implementation, runs on the i/o thread.

[gab, 2017/06/19 15:13:22]

Update comment here and below

[skau, 2017/06/19 23:31:08]

Done.

   void FindImpl(const std::string& key,
                 const scoped_refptr<base::SequencedTaskRunner>& callback_runner,
                 const FindCallback& cb) {
     base::ThreadRestrictions::AssertIOAllowed();
     FindResult result;
     result.success = false;
     MaybeCreateCache();
     base::File file(FilePathForKey(key),
                     base::File::FLAG_OPEN | base::File::FLAG_READ);
 
@@ skipping 70 matching lines @@
   // Return the (full) path to the file we expect to find the given key at.
   base::FilePath FilePathForKey(const std::string& key) {
     std::string hashed_key = crypto::SHA256HashString(key);
     return cache_base_dir_.Append(
         base::HexEncode(hashed_key.data(), hashed_key.size()));
   }
 
   int inflight_ops_ = 0;
 
   base::FilePath cache_base_dir_;
-  scoped_refptr<base::SequencedTaskRunner> disk_task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> fetch_task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> store_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(PpdCacheImpl);
 };
 
 }  // namespace
 
 // static
-scoped_refptr<PpdCache> PpdCache::Create(
-    const base::FilePath& cache_base_dir,
-    scoped_refptr<base::SequencedTaskRunner> disk_task_runner) {
-  return scoped_refptr<PpdCache>(
-      new PpdCacheImpl(cache_base_dir, disk_task_runner));
+scoped_refptr<PpdCache> PpdCache::Create(const base::FilePath& cache_base_dir) {
+  return scoped_refptr<PpdCache>(new PpdCacheImpl(cache_base_dir));
 }
 
 }  // namespace printing
 }  // namespace chromeos