Lazily create PPDCache directory on first store.

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 50 matching lines @@
         ret = contents_path;
         break;
       }
     }
     return ret;
   }
 
   base::Optional<base::FilePath> Store(
       const Printer::PpdReference& reference,
       const std::string& ppd_contents) override {
+    base::ThreadRestrictions::AssertIOAllowed();
+    if (!EnsureCacheDirectoryExists()) {
+      return base::nullopt;
+    }
     base::Optional<base::FilePath> ret;
     base::FilePath contents_path =
         GetCachePathBase(reference).AddExtension(".ppd");
     if (IsGZipped(ppd_contents)) {
       contents_path = contents_path.AddExtension(".gz");
     }
     if (base::WriteFile(contents_path, ppd_contents.data(),
                         ppd_contents.size()) ==
         static_cast<int>(ppd_contents.size())) {
       ret = contents_path;
@@ skipping 53 matching lines @@
     }
     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(std::unique_ptr<PpdProvider::AvailablePrintersMap>
                                   available_printers) override {
+    base::ThreadRestrictions::AssertIOAllowed();
+    if (!EnsureCacheDirectoryExists()) {
+      return;
+    }
     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_) {
       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) {
       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 to "
                  << available_printers_file_.MaybeAsASCII();
     }
   }
 
  private:
+  // Create the cache directory if it doesn't already exist.  Returns true
+  // on success.
+  bool EnsureCacheDirectoryExists() {
+    if (base::PathExists(cache_base_dir_) ||
+        base::CreateDirectory(cache_base_dir_)) {
+      return true;
+    }
+    LOG(ERROR) << "Failed to create ppd cache directory "
+               << cache_base_dir_.MaybeAsASCII();
+    return false;
+  }
+
   // 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
   // unnecessarily.
   //
   // There's also a faint possibility that a bad actor might try to do something
   // nefarious by intentionally causing a cache collision that makes the wrong
@@ skipping 91 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