Update PpdProvider threading model.

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/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/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "crypto/sha2.h"
 #include "net/base/io_buffer.h"
 #include "net/filter/gzip_header.h"
 
 namespace chromeos {
 namespace printing {
 namespace {
 
@@ skipping 15 matching lines @@
                const PpdCache::Options& options)
       : cache_base_dir_(cache_base_dir),
         available_printers_file_(
             cache_base_dir.Append(kAvailablePrintersFilename)),
         options_(options) {}
   ~PpdCacheImpl() override {}
 
   // Public API functions.
   base::Optional<base::FilePath> Find(
       const Printer::PpdReference& reference) const override {
+    base::ThreadRestrictions::AssertIOAllowed();
     base::Optional<base::FilePath> ret;
 
     // We can't know here if we have a gzipped or un-gzipped version, so just
     // look for both.
     base::FilePath contents_path_base = GetCachePathBase(reference);
     for (const std::string& extension : {".ppd", ".ppd.gz"}) {
       base::FilePath contents_path = contents_path_base.AddExtension(extension);
       if (base::PathExists(contents_path)) {
         ret = contents_path;
         break;
@@ skipping 23 matching lines @@
       if (!base::DeleteFile(contents_path, false)) {
         LOG(ERROR) << "Failed to cleanup partially-written file "
                    << contents_path.LossyDisplayName();
         return ret;
       }
     }
     return ret;
   }
 
   const PpdProvider::AvailablePrintersMap* FindAvailablePrinters() override {
+    base::ThreadRestrictions::AssertIOAllowed();
     if (available_printers_ != nullptr &&
         base::Time::Now() - available_printers_timestamp_ <
             options_.max_available_list_staleness) {
       // Satisfy from memory cache.
       return available_printers_.get();
     }
     std::string buf;
     if (!MaybeReadAvailablePrintersCache(&buf)) {
       // Disk cache miss.
       return nullptr;
@@ skipping 48 matching lines @@
       LOG(ERROR) << "Failed to generate JSON";
       return;
     }
     if (contents.size() > options_.max_available_list_cached_size) {
       LOG(ERROR) << "Serialized available printers list too large (size is "
                  << contents.size() << " bytes)";
       return;
     }
     if (base::WriteFile(available_printers_file_, contents.data(),
                         contents.size()) != static_cast<int>(contents.size())) {
-      LOG(ERROR) << "Failed to write available printers cache";
+      LOG(ERROR) << "Failed to write available printers cache to "
+                 << available_printers_file_.MaybeAsASCII();
     }
   }
 
  private:
   // Get the file path at which we expect to find a PPD if it's cached.
   //
   // This is, ultimately, just a hash function.  It's extremely infrequently
   // used (called once when trying to look up information on a printer or store
   // a PPD), and should be stable, as changing the function will make previously
   // cached entries unfindable, causing resolve logic to be reinvoked
@@ skipping 49 matching lines @@
     base::File cache_file(available_printers_file_,
                           base::File::FLAG_OPEN | base::File::FLAG_READ);
     base::File::Info info;
     if (cache_file.IsValid() && cache_file.GetInfo(&info) &&
         (base::Time::Now() - info.last_modified <=
          options_.max_available_list_staleness)) {
       // We have a file that's recent enough to use.
       if (!base::ReadFileToStringWithMaxSize(
               available_printers_file_, buf,
               options_.max_available_list_cached_size)) {
-        LOG(ERROR) << "Failed to read printer cache";
+        LOG(ERROR) << "Failed to read printer cache from "
+                   << available_printers_file_.MaybeAsASCII();
         buf->clear();
         return false;
       }
       available_printers_timestamp_ = info.last_modified;
       return true;
     }
     // Either we don't have an openable file, or it's too old.
     //
     // If we have an invalid file and it's not valid for reasons other than
     // NOT_FOUND, that's unexpected and worth logging.  Otherwise this is
@@ skipping 24 matching lines @@
 }  // namespace
 
 // static
 std::unique_ptr<PpdCache> PpdCache::Create(const base::FilePath& cache_base_dir,
                                            const PpdCache::Options& options) {
   return base::MakeUnique<PpdCacheImpl>(cache_base_dir, options);
 }
 
 }  // namespace printing
 }  // namespace chromeos