Add in-memory caching to PpdCache available printers.

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 <utility>
 
 #include "base/files/file_util.h"
 #include "base/json/json_parser.h"
@@ skipping 109 matching lines @@
   }
 
   void QueryAvailable(const QueryAvailableCallback& cb) override {
     CHECK(!cb.is_null());
     CHECK(query_sequence_checker_.CalledOnValidSequence());
     CHECK(base::SequencedTaskRunnerHandle::IsSet())
         << "QueryAvailable() must be called from a SequencedTaskRunner context";
     CHECK(query_fetcher_ == nullptr)
         << "Can't have concurrent PpdProvider QueryAvailable() calls";
 
-    base::Optional<PpdProvider::AvailablePrintersMap> result =
+    const PpdProvider::AvailablePrintersMap* result =
         cache_->FindAvailablePrinters();
-    if (result) {
+    if (result != nullptr) {
       // Satisfy from cache.
       base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(cb, PpdProvider::SUCCESS, result.value()));
+          FROM_HERE, base::Bind(cb, PpdProvider::SUCCESS, *result));
       return;
     }
     // Not in the cache, ask QuirksServer.
     query_done_callback_ = cb;
 
     query_fetcher_ =
         net::URLFetcher::Create(GetQuirksServerPpdListURL(),
                                 net::URLFetcher::GET, &forwarding_delegate_);
     query_fetcher_->SetRequestContext(url_context_getter_.get());
     query_fetcher_->SetLoadFlags(
@@ skipping 105 matching lines @@
     auto top_dict =
         base::DictionaryValue::From(base::JSONReader::Read(contents));
     const base::ListValue* top_list;
     if (top_dict == nullptr || !top_dict->GetList(kJSONTopListKey, &top_list)) {
       LOG(ERROR) << "Malformed response from quirks server";
       query_done_callback_.Run(PpdProvider::SERVER_ERROR,
                                PpdProvider::AvailablePrintersMap());
       return;
     }
 
-    PpdProvider::AvailablePrintersMap result;
+    auto result = base::MakeUnique<PpdProvider::AvailablePrintersMap>();
     for (const std::unique_ptr<base::Value>& entry : *top_list) {
       base::DictionaryValue* dict;
       std::string manufacturer;
       std::string model;
       base::ListValue* model_list;
       if (!entry->GetAsDictionary(&dict) ||
           !dict->GetString(kJSONManufacturer, &manufacturer) ||
           !dict->GetList(kJSONModelList, &model_list)) {
         LOG(ERROR) << "Unexpected contents in quirks server printer list.";
         // Just skip this entry instead of aborting the whole thing.
         continue;
       }
 
-      std::vector<std::string>& dest = result[manufacturer];
+      std::vector<std::string>& dest = (*result)[manufacturer];
       for (const std::unique_ptr<base::Value>& model_value : *model_list) {
         if (model_value->GetAsString(&model)) {
           dest.push_back(model);
         } else {
           LOG(ERROR) << "Skipping unknown model for manufacturer "
                      << manufacturer;
         }
       }
     }
-    if (!result.empty()) {
-      cache_->StoreAvailablePrinters(result);
+    query_done_callback_.Run(PpdProvider::SUCCESS, *result);
+    if (!result->empty()) {
+      cache_->StoreAvailablePrinters(std::move(result));
     } else {
       // An empty map means something is probably wrong; if we cache this map,
       // we'll have an empty map until the cache expires.  So complain and
       // refuse to cache.
       LOG(ERROR) << "Available printers map is unexpectedly empty.  Refusing "
                     "to cache this.";
     }
-    query_done_callback_.Run(PpdProvider::SUCCESS, result);
   }
 
   // Generate a url to look up a manufacturer/model from the quirks server
   GURL GetQuirksServerPpdLookupURL(
       const Printer::PpdReference& ppd_reference) const {
     return GURL(base::StringPrintf(
         "https://%s/v2/printer/manufacturers/%s/models/%s?key=%s",
         options_.quirks_server.c_str(),
         ppd_reference.effective_manufacturer.c_str(),
         ppd_reference.effective_model.c_str(), api_key_.c_str()));
@@ skipping 66 matching lines @@
     const std::string& api_key,
     scoped_refptr<net::URLRequestContextGetter> url_context_getter,
     std::unique_ptr<PpdCache> cache,
     const PpdProvider::Options& options) {
   return base::MakeUnique<PpdProviderImpl>(api_key, url_context_getter,
                                            std::move(cache), options);
 }
 
 }  // namespace printing
 }  // namespace chromeos