Tunnel PWGRasterConfig capability to the ticket and to the utility process

chrome/browser/local_discovery/privet_http_unittest.cc

 // Copyright 2013 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 "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/local_discovery/privet_http_impl.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
+#include "printing/bitmap_transform_settings.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::StrictMock;
 using testing::NiceMock;
 
 namespace local_discovery {
 
 namespace {
 
@@ skipping 158 matching lines @@
 const char kSampleInvalidDocumentTypeResponse[] = "{"
     "\"error\" : \"invalid_document_type\""
     "}";
 
 const char kSampleCreatejobResponse[] = "{ \"job_id\": \"1234\" }";
 
 const char kSampleEmptyJSONResponse[] = "{}";
 
 const char kSampleCJT[] = "{ \"version\" : \"1.0\" }";
 
+const char kSampleCapabilitiesResponsePWGSettings[] =
+    "{"
+    "\"version\" : \"1.0\","
+    "\"printer\" : {"
+    " \"pwg_raster_config\" : {"
+    "   \"document_sheet_back\" : \"MANUAL_TUMBLE\","
+    "   \"reverse_order_streaming\": true"
+    "  },"
+    "  \"supported_content_type\" : ["
+    "   { \"content_type\" : \"image/pwg-raster\" }"
+    "  ]"
+    "}"
+    "}";
+
+const char kSampleCJTDuplex[] =
+    "{"
+    "\"version\" : \"1.0\","
+    "\"print\": { \"duplex\": {\"type\": \"SHORT_EDGE\"} }"
+    "}";
+
+const char kSampleCJTDuplexPWGSettings[] =
+    "{"
+    "\"version\" : \"1.0\","
+    "\"print\": {"
+    "  \"pwg_raster_config\" : {"
+    "    \"document_sheet_back\" : \"MANUAL_TUMBLE\","
+    "    \"reverse_order_streaming\": true"
+    "   },"
+    "  \"duplex\": {\"type\": \"SHORT_EDGE\"} }"
+    "}";
+
 // Return the representation of the given JSON that would be outputted by
 // JSONWriter. This ensures the same JSON values are represented by the same
 // string.
 std::string NormalizeJson(const std::string& json) {
   std::string result = json;
   scoped_ptr<base::Value> value(base::JSONReader::Read(result));
   DCHECK(value);
   base::JSONWriter::Write(value.get(), &result);
   return result;
 }
@@ skipping 214 matching lines @@
 class FakePWGRasterConverter : public PWGRasterConverter {
  public:
   FakePWGRasterConverter() {
   }
 
   virtual ~FakePWGRasterConverter() {
   }
 
   virtual void Start(base::RefCountedMemory* data,
                      const printing::PdfRenderSettings& conversion_settings,
+                     const printing::BitmapTransformSettings& bitmap_settings,
                      const ResultCallback& callback) OVERRIDE {
+    bitmap_settings_ = bitmap_settings;
     std::string data_str(data->front_as<char>(), data->size());
     callback.Run(true, base::FilePath().AppendASCII(data_str + "test.pdf"));
   }
+
+  const printing::BitmapTransformSettings& bitmap_settings() {
+    return bitmap_settings_;
+  }
+
+ private:
+  printing::BitmapTransformSettings bitmap_settings_;
 };
 
 TEST_F(PrivetHTTPTest, CreatePrivetStorageList) {
   MockJSONCallback mock_callback;
   scoped_ptr<PrivetJSONOperation> storage_list_operation =
       privet_client_->CreateStorageListOperation(
           "/path/to/nothing",
           mock_callback.callback());
   storage_list_operation->Start();
 
@@ skipping 329 matching lines @@
   PrivetLocalPrintTest() {}
 
   virtual ~PrivetLocalPrintTest() {}
 
   virtual void SetUp() OVERRIDE {
     PrivetURLFetcher::ResetTokenMapForTests();
 
     local_print_operation_ = privet_client_->CreateLocalPrintOperation(
         &local_print_delegate_);
 
+    scoped_ptr<FakePWGRasterConverter> pwg_converter(
+        new FakePWGRasterConverter);
+    pwg_converter_ = pwg_converter.get();
     local_print_operation_->SetPWGRasterConverterForTesting(
-        scoped_ptr<PWGRasterConverter>(new FakePWGRasterConverter));
+        pwg_converter.PassAs<PWGRasterConverter>());
   }
 
   scoped_refptr<base::RefCountedBytes> RefCountedBytesFromString(
       std::string str) {
     std::vector<unsigned char> str_vec;
     str_vec.insert(str_vec.begin(), str.begin(), str.end());
     return scoped_refptr<base::RefCountedBytes>(
         base::RefCountedBytes::TakeVector(&str_vec));
   }
 
  protected:
   scoped_ptr<PrivetLocalPrintOperation> local_print_operation_;
   StrictMock<MockLocalPrintDelegate> local_print_delegate_;
+  FakePWGRasterConverter* pwg_converter_;
 };
 
 TEST_F(PrivetLocalPrintTest, SuccessfulLocalPrint) {
   local_print_operation_->SetUsername("sample@gmail.com");
   local_print_operation_->SetJobname("Sample job name");
   local_print_operation_->SetData(RefCountedBytesFromString(
       "Sample print data"));
   local_print_operation_->SetCapabilities(kSampleCapabilitiesResponse);
   local_print_operation_->Start();
 
@@ skipping 59 matching lines @@
 
   EXPECT_CALL(local_print_delegate_, OnPrivetPrintingDoneInternal());
 
   // TODO(noamsml): Is encoding spaces as pluses standard?
   EXPECT_TRUE(SuccessfulResponseToURLAndFilePath(
       GURL("http://10.0.0.8:6006/privet/printer/submitdoc?"
            "client_name=Chrome&user_name=sample%40gmail.com"
            "&job_name=Sample+job+name"),
       base::FilePath(FILE_PATH_LITERAL("path/to/test.pdf")),
       kSampleLocalPrintResponse));
+
+  EXPECT_EQ(printing::TRANSFORM_NORMAL,
+            pwg_converter_->bitmap_settings().odd_page_transform);
+  EXPECT_FALSE(pwg_converter_->bitmap_settings().rotate_all_pages);
+  EXPECT_FALSE(pwg_converter_->bitmap_settings().reverse_page_order);
+};
+
+TEST_F(PrivetLocalPrintTest, SuccessfulPWGLocalPrintDuplex) {
+  local_print_operation_->SetUsername("sample@gmail.com");
+  local_print_operation_->SetJobname("Sample job name");
+  local_print_operation_->SetData(RefCountedBytesFromString("path/to/"));
+  local_print_operation_->SetTicket(kSampleCJTDuplex);
+  local_print_operation_->SetCapabilities(
+      kSampleCapabilitiesResponsePWGSettings);
+  local_print_operation_->Start();
+
+  EXPECT_TRUE(SuccessfulResponseToURL(GURL("http://10.0.0.8:6006/privet/info"),
+                                      kSampleInfoResponseWithCreatejob));
+
+  EXPECT_TRUE(SuccessfulResponseToURL(GURL("http://10.0.0.8:6006/privet/info"),
+                                      kSampleInfoResponse));
+
+  EXPECT_TRUE(SuccessfulResponseToURLAndJSONData(
+      GURL("http://10.0.0.8:6006/privet/printer/createjob"),
+      kSampleCJTDuplexPWGSettings,
+      kSampleCreatejobResponse));
+
+  EXPECT_CALL(local_print_delegate_, OnPrivetPrintingDoneInternal());
+
+  // TODO(noamsml): Is encoding spaces as pluses standard?
+  EXPECT_TRUE(SuccessfulResponseToURLAndFilePath(
+      GURL(
+          "http://10.0.0.8:6006/privet/printer/submitdoc?"
+          "client_name=Chrome&user_name=sample%40gmail.com"
+          "&job_name=Sample+job+name&job_id=1234"),
+      base::FilePath(FILE_PATH_LITERAL("path/to/test.pdf")),
+      kSampleLocalPrintResponse));
+
+  EXPECT_EQ(printing::TRANSFORM_ROTATE_180,
+            pwg_converter_->bitmap_settings().odd_page_transform);
+  EXPECT_FALSE(pwg_converter_->bitmap_settings().rotate_all_pages);
+  EXPECT_TRUE(pwg_converter_->bitmap_settings().reverse_page_order);
 };
 
 TEST_F(PrivetLocalPrintTest, SuccessfulLocalPrintWithCreatejob) {
   local_print_operation_->SetUsername("sample@gmail.com");
   local_print_operation_->SetJobname("Sample job name");
   local_print_operation_->SetTicket(kSampleCJT);
   local_print_operation_->SetData(
       RefCountedBytesFromString("Sample print data"));
   local_print_operation_->SetCapabilities(kSampleCapabilitiesResponse);
   local_print_operation_->Start();
@@ skipping 126 matching lines @@
 
   EXPECT_TRUE(SuccessfulResponseToURL(
       GURL("http://10.0.0.8:6006/privet/printer/createjob"),
       kSampleCreatejobResponse));
 };
 
 
 }  // namespace
 
 }  // namespace local_discovery