Add in-memory caching to PpdCache available printers.

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"
@@ skipping 73 matching lines @@
       // something is exceptionally hosed.
       if (!base::DeleteFile(contents_path, false)) {
         LOG(ERROR) << "Failed to cleanup partially-written file "
                    << contents_path.LossyDisplayName();
         return ret;
       }
     }
     return ret;
   }
 
-  base::Optional<PpdProvider::AvailablePrintersMap> FindAvailablePrinters()
-      override {
+  const PpdProvider::AvailablePrintersMap* FindAvailablePrinters() override {
+    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)) {
-      return base::nullopt;
+      // Disk cache miss.
+      return nullptr;
     }
     auto dict = base::DictionaryValue::From(base::JSONReader::Read(buf));
     if (dict == nullptr) {
       LOG(ERROR) << "Failed to deserialize available printers cache";
-      return base::nullopt;
+      return nullptr;
     }
-    PpdProvider::AvailablePrintersMap ret;
+    // Note if we got here, we've already set available_printers_timestamp_ to
+    // the mtime of the file we read from.
+    available_printers_.reset(new PpdProvider::AvailablePrintersMap);
     const base::ListValue* models;
     std::string model;
     for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd();
          it.Advance()) {
-      auto& out = ret[it.key()];
+      auto& out = (*available_printers_)[it.key()];
       if (!it.value().GetAsList(&models)) {
         LOG(ERROR) << "Skipping malformed printer make: " << it.key();
         continue;
       }
       for (const auto& model_value : *models) {
         if (model_value->GetAsString(&model)) {
           out.push_back(model);
         } else {
           LOG(ERROR) << "Skipping malformed printer model in: " << it.key()
                      << ".  Expected a string, found a "
                      << base::Value::GetTypeName(model_value->GetType());
         }
       }
     }
-    return ret;
+    return available_printers_.get();
   }
 
   // Note we throw up our hands and fail (gracefully) to store if we encounter
   // non-unicode things in the strings of |available_printers|.  Since these
   // strings come from a source we control, being less paranoid about these
   // values seems reasonable.
-  void StoreAvailablePrinters(
-      const PpdProvider::AvailablePrintersMap& available_printers) override {
+  void StoreAvailablePrinters(std::unique_ptr<PpdProvider::AvailablePrintersMap>
+                                  available_printers) override {
+    available_printers_ = std::move(available_printers);
+    available_printers_timestamp_ = base::Time::Now();
     // Convert the map to Values, in preparation for jsonification.
     base::DictionaryValue top_level;
-    for (const auto& entry : available_printers) {
+    for (const auto& entry : *available_printers_) {
       auto printers = base::MakeUnique<base::ListValue>();
       printers->AppendStrings(entry.second);
       top_level.Set(entry.first, std::move(printers));
     }
     std::string contents;
     if (!base::JSONWriter::Write(top_level, &contents)) {
       LOG(ERROR) << "Failed to generate JSON";
       return;
     }
     if (contents.size() > options_.max_available_list_cached_size) {
@@ skipping 70 matching lines @@
         (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";
         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
     // a normal cache miss.
     if (!cache_file.IsValid() &&
         cache_file.error_details() != base::File::FILE_ERROR_NOT_FOUND) {
       LOG(ERROR) << "Unexpected result when attempting to open printer cache: "
                  << base::File::ErrorToString(cache_file.error_details());
     }
     return false;
   }
 
+  // In-memory copy of the available printers map, null if we don't have an
+  // in-memory copy yet.  Filled in the first time the map is fetched (whether
+  // from disk or server), and remains for the life of the PpdCache.

[skau, 2016/11/10 20:46:37]

This isn't strictly true.  It's reset when the cached value expires.

[Carlson, 2016/11/11 01:39:27]

You're right, I changed this after I wrote the comment.  Fixed comment.

+  std::unique_ptr<PpdProvider::AvailablePrintersMap> available_printers_;
+  // Timestamp for the in-memory copy of the cache.  (The on-disk version uses
+  // the file mtime).
+  base::Time available_printers_timestamp_;
+
   const base::FilePath cache_base_dir_;
   const base::FilePath available_printers_file_;
   const PpdCache::Options options_;
 
   DISALLOW_COPY_AND_ASSIGN(PpdCacheImpl);
 };
 
 }  // 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