Convert PpdCache and PpdProvider to TaskScheduler.

chromeos/printing/ppd_provider.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_provider.h"
 
 #include <algorithm>
 #include <deque>
 #include <set>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/json/json_parser.h"
 #include "base/memory/ptr_util.h"
+#include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner_util.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/ppd_cache.h"
 #include "chromeos/printing/printing_constants.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
@@ skipping 112 matching lines @@
   DCHECK(PpdReferenceIsWellFormed(reference));
   // The key prefixes here are arbitrary, but ensure we can't have an (unhashed)
   // collision between keys generated from different PpdReference fields.
   if (!reference.effective_make_and_model.empty()) {
     return std::string("em:") + reference.effective_make_and_model;
   } else {
     return std::string("up:") + reference.user_supplied_ppd_url;
   }
 }
 
+// Handles the result after PPD storage.
+void OnPpdStored() {}
+
+// Fetch the file pointed at by |url| and store it in |file_contents|.
+// Returns true if the fetch was successful.
+bool FetchFile(const GURL& url, std::string* file_contents) {
+  CHECK(url.is_valid());
+  CHECK(url.SchemeIs("file"));
+  base::ThreadRestrictions::AssertIOAllowed();
+
+  return base::ReadFileToString(base::FilePath(url.path()), file_contents);
+}
+
 struct ManufacturerMetadata {
   // Key used to look up the printer list on the server.  This is initially
   // populated.
   std::string reference;
 
   // Map from localized printer name to canonical-make-and-model string for
   // the given printer.  Populated on demand.
   std::unique_ptr<std::unordered_map<std::string, std::string>> printers;
 };
 
@@ skipping 25 matching lines @@
     FT_PRINTERS,       // List of printers from a manufacturer.
     FT_PPD_INDEX,      // Master ppd index.
     FT_PPD,            // A Ppd file.
     FT_USB_DEVICES     // USB device id to canonical name map.
   };
 
   PpdProviderImpl(
       const std::string& browser_locale,
       scoped_refptr<net::URLRequestContextGetter> url_context_getter,
       scoped_refptr<PpdCache> ppd_cache,
-      scoped_refptr<base::SequencedTaskRunner> disk_task_runner,
       const PpdProvider::Options& options)
       : browser_locale_(browser_locale),
         url_context_getter_(url_context_getter),
         ppd_cache_(ppd_cache),
-        disk_task_runner_(disk_task_runner),
+        disk_task_runner_(base::CreateSequencedTaskRunnerWithTraits(
+            {base::TaskPriority::USER_VISIBLE, base::MayBlock(),
+             base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
         options_(options),
         weak_factory_(this) {}
 
   // Resolving manufacturers requires a couple of steps, because of
   // localization.  First we have to figure out what locale to use, which
   // involves grabbing a list of available locales from the server.  Once we
   // have decided on a locale, we go out and fetch the manufacturers map in that
   // localization.
   //
   // This means when a request comes in, we either queue it and start background
@@ skipping 140 matching lines @@
       FinishPpdResolution(cb, PpdProvider::INTERNAL_ERROR, std::string());
       return;
     }
     // First step, check the cache.  If the cache lookup fails, we'll (try to)
     // consult the server.
     ppd_cache_->Find(PpdReferenceToCacheKey(reference),
                      base::Bind(&PpdProviderImpl::ResolvePpdCacheLookupDone,
                                 weak_factory_.GetWeakPtr(), reference, cb));
   }
 
-  // Our only sources of long running ops are cache fetches and network fetches.
-  bool Idle() const override { return ppd_cache_->Idle() && !fetch_inflight_; }
-
   // Common handler that gets called whenever a fetch completes.  Note this
   // is used both for |fetcher_| fetches (i.e. http[s]) and file-based fetches;
   // |source| may be null in the latter case.
   void OnURLFetchComplete(const net::URLFetcher* source) override {
     switch (fetcher_target_) {
       case FT_LOCALES:
         OnLocalesFetchComplete();
         break;
       case FT_MANUFACTURERS:
         OnManufacturersFetchComplete();
@@ skipping 66 matching lines @@
 
     if (url.SchemeIs("http") || url.SchemeIs("https")) {
       fetcher_ = net::URLFetcher::Create(url, net::URLFetcher::GET, this);
       fetcher_->SetRequestContext(url_context_getter_.get());
       fetcher_->SetLoadFlags(net::LOAD_BYPASS_CACHE | net::LOAD_DISABLE_CACHE |
                              net::LOAD_DO_NOT_SAVE_COOKIES |
                              net::LOAD_DO_NOT_SEND_COOKIES |
                              net::LOAD_DO_NOT_SEND_AUTH_DATA);
       fetcher_->Start();
     } else if (url.SchemeIs("file")) {
-      disk_task_runner_->PostTaskAndReply(
-          FROM_HERE, base::Bind(&PpdProviderImpl::FetchFile, this, url),
-          base::Bind(&PpdProviderImpl::OnURLFetchComplete, this, nullptr));
+      auto file_contents = base::MakeUnique<std::string>();
+      std::string* content_ptr = file_contents.get();
+      base::PostTaskAndReplyWithResult(
+          disk_task_runner_.get(), FROM_HERE,
+          base::Bind(&FetchFile, url, content_ptr),
+          base::Bind(&PpdProviderImpl::OnFileFetchComplete, this,
+                     base::Passed(&file_contents)));
     }
   }
 
-  // Fetch the file pointed at by url and store it in |file_fetch_contents_|.
-  // Use |file_fetch_success_| to indicate success or failure.
-  void FetchFile(const GURL& url) {
-    CHECK(url.is_valid());
-    CHECK(url.SchemeIs("file"));
-    base::ThreadRestrictions::AssertIOAllowed();
-    file_fetch_success_ = base::ReadFileToString(base::FilePath(url.path()),
-                                                 &file_fetch_contents_);
+  // Handle the result of a file fetch.
+  void OnFileFetchComplete(std::unique_ptr<std::string> file_contents,
+                           bool success) {
+    file_fetch_success_ = success;
+    file_fetch_contents_ = success ? *file_contents : "";
+    OnURLFetchComplete(nullptr);
   }
 
   void FinishPpdResolution(const ResolvePpdCallback& cb,
                            PpdProvider::CallbackResultCode result_code,
                            const std::string& ppd_contents) {
     if (result_code == PpdProvider::SUCCESS) {
       base::SequencedTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(cb, PpdProvider::SUCCESS, ppd_contents,
                                 ExtractFiltersFromPpd(ppd_contents)));
     } else {
@@ skipping 174 matching lines @@
     DCHECK(!ppd_resolution_queue_.empty());
     std::string contents;
 
     if ((ValidateAndGetResponseAsString(&contents) != PpdProvider::SUCCESS) ||
         contents.size() > kMaxPpdSizeBytes) {
       FinishPpdResolution(ppd_resolution_queue_.front().second,
                           PpdProvider::SERVER_ERROR, std::string());
     } else {
       ppd_cache_->Store(
           PpdReferenceToCacheKey(ppd_resolution_queue_.front().first), contents,
-          base::Callback<void()>());
+          base::Bind(&OnPpdStored));
       FinishPpdResolution(ppd_resolution_queue_.front().second,
                           PpdProvider::SUCCESS, contents);
     }
     ppd_resolution_queue_.pop_front();
   }
 
   // Called when |fetcher_| should have just downloaded a usb device map
   // for the vendor at the head of the |usb_resolution_queue_|.
   void OnUsbFetchComplete() {
     DCHECK(!usb_resolution_queue_.empty());
@@ skipping 316 matching lines @@
   ~PpdProviderImpl() override {}
 };
 
 }  // namespace
 
 // static
 scoped_refptr<PpdProvider> PpdProvider::Create(
     const std::string& browser_locale,
     scoped_refptr<net::URLRequestContextGetter> url_context_getter,
     scoped_refptr<PpdCache> ppd_cache,
-    scoped_refptr<base::SequencedTaskRunner> disk_task_runner,
     const PpdProvider::Options& options) {
-  return scoped_refptr<PpdProvider>(
-      new PpdProviderImpl(browser_locale, url_context_getter, ppd_cache,
-                          disk_task_runner, options));
+  return scoped_refptr<PpdProvider>(new PpdProviderImpl(
+      browser_locale, url_context_getter, ppd_cache, options));
 }
 }  // namespace printing
 }  // namespace chromeos