Add CupsFilter extraction from resolved ppds for printing.

chromeos/printing/ppd_provider_unittest.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 <map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
@@ skipping 14 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos {
 namespace printing {
 
 namespace {
 
 // Name of the fake server we're resolving ppds from.
 const char kPpdServer[] = "bogus.google.com";
 
+// A pseudo-ppd that should get cupsFilter lines extracted from it.
+const char kCupsFilterPpdContents[] = R"(
+Other random contents that we don't care about.
+*cupsFilter: "application/vnd.cups-raster 0 my_filter"
+More random contents that we don't care about
+*cupsFilter: "application/vnd.cups-awesome 0 a_different_filter"
+*cupsFilter: "application/vnd.cups-awesomesauce 0 filter3"
+Yet more randome contents that we don't care about.
+More random contents that we don't care about.
+)";
+
+// A pseudo-ppd that should get cupsFilter2 lines extracted from it.
+// We also have cupsFilter lines in here, but since cupsFilter2 lines
+// exist, the cupsFilter lines should be ignored.
+const char kCupsFilter2PpdContents[] = R"(
+Other random contents that we don't care about.
+*cupsFilter: "application/vnd.cups-raster 0 my_filter"
+More random contents that we don't care about
+*cupsFilter2: "foo bar 0 the_real_filter"
+*cupsFilter2: "bar baz 381 another_real_filter"
+Yet more randome contents that we don't care about.
+More random contents that we don't care about.
+)";
+
 class PpdProviderTest : public ::testing::Test {
  public:
   PpdProviderTest()
       : loop_(base::MessageLoop::TYPE_IO),
         request_context_getter_(new net::TestURLRequestContextGetter(
             base::MessageLoop::current()->task_runner())) {}
 
   void SetUp() override {
     ASSERT_TRUE(ppd_cache_temp_dir_.CreateUniqueTempDir());
   }
@@ skipping 53 matching lines @@
             ])"},
         {"metadata/manufacturer_a.json",
          R"([
             ["printer_a", "printer_a_ref"],
             ["printer_b", "printer_b_ref"]
             ])"},
         {"metadata/manufacturer_b.json",
          R"([
             ["printer_c", "printer_c_ref"]
             ])"},
-        {"ppds/printer_a.ppd", "a"},
-        {"ppds/printer_b.ppd", "b"},
+        {"ppds/printer_a.ppd", kCupsFilterPpdContents},
+        {"ppds/printer_b.ppd", kCupsFilter2PpdContents},
         {"ppds/printer_c.ppd", "c"},
         {"user_supplied_ppd_directory/user_supplied.ppd", "u"}};
     int next_file_num = 0;
     for (const auto& entry : server_contents) {
       base::FilePath filename = interceptor_temp_dir_.GetPath().Append(
           base::StringPrintf("%d.json", next_file_num++));
       ASSERT_EQ(
           base::WriteFile(filename, entry.second.data(), entry.second.size()),
           static_cast<int>(entry.second.size()))
           << "Failed to write temp server file";
@@ skipping 23 matching lines @@
   }
 
   // Capture the result of a ResolvePrinters() call.
   void CaptureResolvePrinters(PpdProvider::CallbackResultCode code,
                               const std::vector<std::string>& data) {
     captured_resolve_printers_.push_back({code, data});
   }
 
   // Capture the result of a ResolvePpd() call.
   void CaptureResolvePpd(PpdProvider::CallbackResultCode code,
-                         const std::string& contents) {
-    captured_resolve_ppd_.push_back({code, contents});
+                         const std::string& ppd_contents,
+                         const std::vector<std::string>& ppd_filters) {
+    CapturedResolvePpdResults results;
+    results.code = code;
+    results.ppd_contents = ppd_contents;
+    results.ppd_filters = ppd_filters;
+    captured_resolve_ppd_.push_back(results);
   }
 
   // Capture the result of a ResolveUsbIds() call.
   void CaptureResolveUsbIds(PpdProvider::CallbackResultCode code,
                             const std::string& contents) {
     captured_resolve_usb_ids_.push_back({code, contents});
   }
 
   // Discard the result of a ResolvePpd() call.
   void DiscardResolvePpd(PpdProvider::CallbackResultCode code,
@@ skipping 38 matching lines @@
   base::TestMessageLoop loop_;
 
   std::vector<
       std::pair<PpdProvider::CallbackResultCode, std::vector<std::string>>>
       captured_resolve_manufacturers_;
 
   std::vector<
       std::pair<PpdProvider::CallbackResultCode, std::vector<std::string>>>
       captured_resolve_printers_;
 
-  std::vector<std::pair<PpdProvider::CallbackResultCode, std::string>>
-      captured_resolve_ppd_;
+  struct CapturedResolvePpdResults {
+    PpdProvider::CallbackResultCode code;
+    std::string ppd_contents;
+    std::vector<std::string> ppd_filters;
+  };
+  std::vector<CapturedResolvePpdResults> captured_resolve_ppd_;
 
   std::vector<std::pair<PpdProvider::CallbackResultCode, std::string>>
       captured_resolve_usb_ids_;
 
   std::unique_ptr<net::TestURLRequestInterceptor> interceptor_;
 
   base::ScopedTempDir ppd_cache_temp_dir_;
   base::ScopedTempDir interceptor_temp_dir_;
 
   // Provider to be used in the test.
@@ skipping 176 matching lines @@
   Printer::PpdReference ref;
   ref.effective_make_and_model = "printer_b_ref";
   provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
                                        base::Unretained(this)));
   ref.effective_make_and_model = "printer_c_ref";
   provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
                                        base::Unretained(this)));
   Drain(*provider);
 
   ASSERT_EQ(2UL, captured_resolve_ppd_.size());
-  EXPECT_EQ(PpdProvider::SUCCESS, captured_resolve_ppd_[0].first);
-  EXPECT_EQ("b", captured_resolve_ppd_[0].second);
-  EXPECT_EQ(PpdProvider::SUCCESS, captured_resolve_ppd_[1].first);
-  EXPECT_EQ("c", captured_resolve_ppd_[1].second);
+  EXPECT_EQ(PpdProvider::SUCCESS, captured_resolve_ppd_[0].code);
+  EXPECT_EQ(kCupsFilter2PpdContents, captured_resolve_ppd_[0].ppd_contents);
+  EXPECT_EQ(PpdProvider::SUCCESS, captured_resolve_ppd_[1].code);
+  EXPECT_EQ("c", captured_resolve_ppd_[1].ppd_contents);
 }
 
 // Test that we *don't* resolve a ppd URL over non-file schemes.  It's not clear
 // whether we'll want to do this in the long term, but for now this is
 // disallowed because we're not sure we completely understand the security
 // implications.
 TEST_F(PpdProviderTest, ResolveUserSuppliedUrlPpdFromNetworkFails) {
   StartFakePpdServer();
   auto provider = CreateProvider("en");
 
   Printer::PpdReference ref;
   ref.user_supplied_ppd_url = base::StringPrintf(
       "https://%s/user_supplied_ppd_directory/user_supplied.ppd", kPpdServer);
   provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
                                        base::Unretained(this)));
   Drain(*provider);
 
   ASSERT_EQ(1UL, captured_resolve_ppd_.size());
-  EXPECT_EQ(PpdProvider::INTERNAL_ERROR, captured_resolve_ppd_[0].first);
-  EXPECT_TRUE(captured_resolve_ppd_[0].second.empty());
+  EXPECT_EQ(PpdProvider::INTERNAL_ERROR, captured_resolve_ppd_[0].code);
+  EXPECT_TRUE(captured_resolve_ppd_[0].ppd_contents.empty());
 }
 
 // Test a successful ppd resolution from a user_supplied_url field when
 // reading from a file.  Note we shouldn't need the server to be up
 // to do this successfully, as we should be able to do this offline.
 TEST_F(PpdProviderTest, ResolveUserSuppliedUrlPpdFromFile) {
   auto provider = CreateProvider("en");
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath filename = temp_dir.GetPath().Append("my_spiffy.ppd");
 
   std::string user_ppd_contents = "Woohoo";
 
   ASSERT_EQ(base::WriteFile(filename, user_ppd_contents.data(),
                             user_ppd_contents.size()),
             static_cast<int>(user_ppd_contents.size()));
 
   Printer::PpdReference ref;
   ref.user_supplied_ppd_url =
       base::StringPrintf("file://%s", filename.MaybeAsASCII().c_str());
   provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
                                        base::Unretained(this)));
   Drain(*provider);
 
   ASSERT_EQ(1UL, captured_resolve_ppd_.size());
-  EXPECT_EQ(PpdProvider::SUCCESS, captured_resolve_ppd_[0].first);
-  EXPECT_EQ(user_ppd_contents, captured_resolve_ppd_[0].second);
+  EXPECT_EQ(PpdProvider::SUCCESS, captured_resolve_ppd_[0].code);
+  EXPECT_EQ(user_ppd_contents, captured_resolve_ppd_[0].ppd_contents);
 }
 
 // Test that we cache ppd resolutions when we fetch them and that we can resolve
 // from the cache without the server available.
 TEST_F(PpdProviderTest, ResolvedPpdsGetCached) {
   auto provider = CreateProvider("en");
   std::string user_ppd_contents = "Woohoo";
   Printer::PpdReference ref;
   {
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     base::FilePath filename = temp_dir.GetPath().Append("my_spiffy.ppd");
 
     ASSERT_EQ(base::WriteFile(filename, user_ppd_contents.data(),
                               user_ppd_contents.size()),
               static_cast<int>(user_ppd_contents.size()));
 
     ref.user_supplied_ppd_url =
         base::StringPrintf("file://%s", filename.MaybeAsASCII().c_str());
     provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
                                          base::Unretained(this)));
     Drain(*provider);
 
     ASSERT_EQ(1UL, captured_resolve_ppd_.size());
-    EXPECT_EQ(PpdProvider::SUCCESS, captured_resolve_ppd_[0].first);
-    EXPECT_EQ(user_ppd_contents, captured_resolve_ppd_[0].second);
+    EXPECT_EQ(PpdProvider::SUCCESS, captured_resolve_ppd_[0].code);
+    EXPECT_EQ(user_ppd_contents, captured_resolve_ppd_[0].ppd_contents);
   }
   // ScopedTempDir goes out of scope, so the source file should now be
   // deleted.  But if we resolve again, we should hit the cache and
   // still be successful.
 
   captured_resolve_ppd_.clear();
 
   // Recreate the provider to make sure we don't have any memory caches which
   // would mask problems with disk persistence.
   provider = CreateProvider("en");
 
   // Re-resolve.
   provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
                                        base::Unretained(this)));
   Drain(*provider);
 
   ASSERT_EQ(1UL, captured_resolve_ppd_.size());
-  EXPECT_EQ(PpdProvider::SUCCESS, captured_resolve_ppd_[0].first);
-  EXPECT_EQ(user_ppd_contents, captured_resolve_ppd_[0].second);
+  EXPECT_EQ(PpdProvider::SUCCESS, captured_resolve_ppd_[0].code);
+  EXPECT_EQ(user_ppd_contents, captured_resolve_ppd_[0].ppd_contents);
+}
+
+// Test that the filter extraction code successfully pulls the filters
+// from the ppds resolved.
+TEST_F(PpdProviderTest, ExtractPpdFilters) {
+  StartFakePpdServer();
+  auto provider = CreateProvider("en");
+  Printer::PpdReference ref;
+  ref.effective_make_and_model = "printer_a_ref";
+  provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
+                                       base::Unretained(this)));
+  ref.effective_make_and_model = "printer_b_ref";
+  provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
+                                       base::Unretained(this)));
+  Drain(*provider);
+
+  ASSERT_EQ(2UL, captured_resolve_ppd_.size());
+  EXPECT_EQ(PpdProvider::SUCCESS, captured_resolve_ppd_[0].code);
+  EXPECT_EQ(kCupsFilterPpdContents, captured_resolve_ppd_[0].ppd_contents);
+  EXPECT_EQ(
+      std::vector<std::string>({"a_different_filter", "filter3", "my_filter"}),
+      captured_resolve_ppd_[0].ppd_filters);
+
+  EXPECT_EQ(PpdProvider::SUCCESS, captured_resolve_ppd_[1].code);
+  EXPECT_EQ(kCupsFilter2PpdContents, captured_resolve_ppd_[1].ppd_contents);
+  EXPECT_EQ(
+      std::vector<std::string>({"another_real_filter", "the_real_filter"}),
+      captured_resolve_ppd_[1].ppd_filters);
 }
 
 }  // namespace
 }  // namespace printing
 }  // namespace chromeos