Add PPDProvider barebones implementation and associated cache skeleton.

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 <vector>
+
+#include "base/files/file_util.h"
+#include "base/memory/ptr_util.h"
+#include "base/path_service.h"

[Lei Zhang, 2016/10/19 01:25:09]

Not used?

[Carlson, 2016/10/19 16:38:26]

Thanks.  Is there any iwyu tooling that's easy to invoke?  I'm sure there are
others that could be cleaned up.  

[Lei Zhang, 2016/10/19 23:15:45]

They exist but they don't work well for Chromium in general. IWYU tools tend to
have trouble with platform-specific code / includes. Though this is ChromeOS
only so maybe they'll work here?

[Carlson, 2016/10/19 23:38:56]

Acknowledged.

+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "chromeos/printing/ppd_cache.h"

[Lei Zhang, 2016/10/19 01:25:09]

This should go above everything else.

[Carlson, 2016/10/19 16:38:26]

Done.

+#include "crypto/sha2.h"

[Lei Zhang, 2016/10/19 01:25:09]

Not used?

[Carlson, 2016/10/19 16:38:26]

Oh boy, this was actually a serious error on my part -- I forgot to
actually...hash, and was just hexencoding the to-be-hashed key instead of the
hashed key.

It'd be nice to have a unit test to catch something like this if I could think
of a reasonable way to structure one.

+#include "net/base/io_buffer.h"
+#include "net/filter/filter.h"
+#include "net/filter/gzip_header.h"
+
+using base::File;

[Lei Zhang, 2016/10/19 01:25:09]

Can we be consistent with the changes to the unit test?

BTW, if you ever have to work with "namespace data_reduction_proxy" then ya,
you'd want to add "using data_reduction_proxy" or else fitting under 80 cols is
going to be hard.

[Carlson, 2016/10/19 16:38:26]

As a compromise, I removed the ones that were seldom used below, but left the
ones that are used many times.

+using base::FilePath;
+using base::Optional;
+using net::Filter;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
+namespace chromeos {
+namespace printing {
+namespace {
+
+// Return true if it looks like contents is already gzipped, false otherwise.
+bool IsGZipped(const string& contents) {
+  const char* ignored;
+  net::GZipHeader header;
+  return header.ReadMore(contents.data(), contents.size(), &ignored) ==
+         net::GZipHeader::COMPLETE_HEADER;
+}
+
+class PpdCacheImpl : public PpdCache {
+ public:
+  explicit PpdCacheImpl(const FilePath& cache_base_dir)
+      : cache_base_dir_(cache_base_dir) {}
+  ~PpdCacheImpl() override {}
+
+  // Public API functions.
+  Optional<FilePath> Find(
+      const Printer::PpdReference& reference) const override {
+    Optional<FilePath> ret;
+
+    // We can't know here if we have a gzipped or un-gzipped version, so just
+    // look for both.
+    FilePath contents_path_base = GetCachePathBase(reference);
+    for (const string& extension : {".ppd", ".ppd.gz"}) {
+      FilePath contents_path = contents_path_base.AddExtension(extension);
+      if (base::PathExists(contents_path)) {
+        ret = contents_path;
+        break;
+      }
+    }
+    return ret;
+  }
+
+  Optional<FilePath> Store(const Printer::PpdReference& reference,
+                           const string& ppd_contents) override {
+    Optional<FilePath> ret;
+    FilePath contents_path;
+    contents_path = GetCachePathBase(reference).AddExtension(".ppd");

[Lei Zhang, 2016/10/19 01:25:09]

combine with previous line?

[Carlson, 2016/10/19 16:38:26]

Done.

+    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;
+    } else {
+      LOG(ERROR) << "Failed to write " << contents_path.LossyDisplayName();
+      //  Try to clean up the file, as it may have partial contents.  Note
+      // that DeleteFile(nonexistant file) should return true, so failure here
+      // means 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;
+  }
+
+ 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
+  // 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
+  // PPD be used for a printer.  There's no obvious attack vector, but
+  // there's also no real cost to being paranoid here, so we use SHA-256 as the

[Lei Zhang, 2016/10/19 01:25:09]

Is this out of date or not implemented?

[Carlson, 2016/10/19 16:38:26]

Noted above, forgot to implement.  Thanks for noticing this.  It's in now.

+  // underlying hash function, and inject fixed field prefixes to prevent
+  // field-substitution spoofing.  This also buys us hash function stability at
+  // the same time.
+  //
+  // Also, care should be taken to preserve the existing hash values if new
+  // fields are added to PpdReference -- that is, if a new field F is added
+  // to PpdReference,  a PpdReference with a default F value should hash to
+  // the same thing as a PpdReference that predates the addition of F to the
+  // structure.
+  //
+  // Note this function expects that the caller will append ".ppd", or ".ppd.gz"
+  // to the output as needed.
+  FilePath GetCachePathBase(const Printer::PpdReference& ref) const {
+    vector<string> pieces;
+    if (!ref.user_supplied_ppd_url.empty()) {
+      pieces.push_back("user_supplied_ppd_url:");
+      pieces.push_back(ref.user_supplied_ppd_url);
+    } else if (!ref.effective_manufacturer.empty() &&
+               !ref.effective_model.empty()) {
+      pieces.push_back("manufacturer:");
+      pieces.push_back(ref.effective_manufacturer);
+      pieces.push_back("model:");
+      pieces.push_back(ref.effective_model);
+    } else {
+      LOG(DFATAL) << "PpdCache hashing empty PpdReference, this probably means "

[Lei Zhang, 2016/10/19 01:25:09]

NOTREACHED() 

[Carlson, 2016/10/19 16:38:26]

Sure.  Out of curiosity, what's the difference?  Is it just that it tags the log
with "NOTREACHED hit." (and maybe is a little better macro name for intent
here?)

[Lei Zhang, 2016/10/19 23:15:45]

NOTREACHED() better describes the intent.

[Carlson, 2016/10/19 23:38:56]

Acknowledged.

+                     "something is wrong";
+    }
+    // The separator here is not needed, but makes debug output more readable.
+    string full_key = base::JoinString(pieces, "|");
+    string ascii_hash = base::HexEncode(full_key.data(), full_key.size());
+    VLOG(3) << "PPD Cache key is " << full_key << " which hashes to "
+            << ascii_hash;
+
+    return cache_base_dir_.Append(ascii_hash);
+  }
+
+  const FilePath cache_base_dir_;
+
+  DISALLOW_COPY_AND_ASSIGN(PpdCacheImpl);
+};
+
+}  // namespace
+
+// static
+unique_ptr<PpdCache> PpdCache::Create(const FilePath& cache_base_dir) {
+  return ::base::MakeUnique<PpdCacheImpl>(cache_base_dir);

[Lei Zhang, 2016/10/19 01:25:09]

More ::base

[Carlson, 2016/10/19 16:38:26]

Done.

+}
+
+}  // namespace printing
+}  // namespace chromeos