Tunnel PWGRasterConfig capability to the ticket and to the utility process

chrome/browser/local_discovery/privet_http_impl.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 "chrome/browser/local_discovery/privet_http_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/local_discovery/privet_constants.h"
 #include "components/cloud_devices/printer_description.h"
 #include "net/base/url_util.h"
+#include "printing/pwg_raster_settings.h"
 #include "printing/units.h"
 #include "ui/gfx/text_elider.h"
 #include "url/gurl.h"
 
+using namespace cloud_devices::printer;
+
 namespace local_discovery {
 
 namespace {
 const char kUrlPlaceHolder[] = "http://host/";
 const char kPrivetRegisterActionArgName[] = "action";
 const char kPrivetRegisterUserArgName[] = "user";
 
 const char kPrivetURLKeyUserName[] = "user_name";
 const char kPrivetURLKeyClientName[] = "client_name";
 const char kPrivetURLKeyJobname[] = "job_name";
@@ skipping 473 matching lines @@
     }
 
     StartInitialRequest();
   } else {
     delegate_->OnPrivetPrintingError(this, -1);
   }
 }
 
 void PrivetLocalPrintOperationImpl::StartInitialRequest() {
   use_pdf_ = false;
-  cloud_devices::printer::ContentTypesCapability content_types;
+  ContentTypesCapability content_types;
   if (content_types.LoadFrom(capabilities_)) {
     use_pdf_ = content_types.Contains(kPrivetContentTypePDF) ||
                content_types.Contains(kPrivetContentTypeAny);
   }
 
   if (use_pdf_) {
     StartPrinting();
   } else {
-    cloud_devices::printer::DpiCapability dpis;
+    DpiCapability dpis;
     if (dpis.LoadFrom(capabilities_)) {
       dpi_ = std::max(dpis.GetDefault().horizontal, dpis.GetDefault().vertical);
     }
     StartConvertToPWG();
   }
 }
 
 void PrivetLocalPrintOperationImpl::DoCreatejob() {
   current_response_ = base::Bind(
       &PrivetLocalPrintOperationImpl::OnCreatejobResponse,
       base::Unretained(this));
 
+  // Add PWG raster settings to ticket if they are supplied by the printer.
+  PwgRasterConfigCapability raster_capability;
+  PwgRasterConfigTicketItem raster_ticket_item;
+  if (raster_capability.LoadFrom(capabilities_)) {
+    raster_ticket_item.set_value(raster_capability.value());
+    raster_ticket_item.SaveTo(&ticket_);
+  }
+
   url_fetcher_= privet_client_->CreateURLFetcher(
       CreatePrivetURL(kPrivetCreatejobPath), net::URLFetcher::POST, this);
   url_fetcher_->SetUploadData(kPrivetContentTypeCJT, ticket_.ToString());
 
   url_fetcher_->Start();
 }
 
 void PrivetLocalPrintOperationImpl::DoSubmitdoc() {
   current_response_ = base::Bind(
       &PrivetLocalPrintOperationImpl::OnSubmitdocResponse,
@@ skipping 50 matching lines @@
 }
 
 void PrivetLocalPrintOperationImpl::StartPrinting() {
   if (has_extended_workflow_ && jobid_.empty()) {
     DoCreatejob();
   } else {
     DoSubmitdoc();
   }
 }
 
+void PrivetLocalPrintOperationImpl::FillPwgRasterSettings(
+    printing::PwgRasterSettings* transform_settings) {
+  PwgRasterConfigCapability raster_capability;
+  // If the raster capability fails to load, raster_capability will contain
+  // the default value.
+  raster_capability.LoadFrom(capabilities_);
+
+  DuplexTicketItem duplex_item;
+  DuplexType duplex_value = NO_DUPLEX;
+
+  DocumentSheetBack document_sheet_back =
+      raster_capability.value().document_sheet_back;
+
+  if (duplex_item.LoadFrom(ticket_)) {
+    duplex_value = duplex_item.value();
+  }
+
+  transform_settings->odd_page_transform = printing::TRANSFORM_NORMAL;
+  switch (duplex_value) {
+    case NO_DUPLEX:
+      transform_settings->odd_page_transform = printing::TRANSFORM_NORMAL;
+      break;
+    case LONG_EDGE:
+      if (document_sheet_back == ROTATED) {
+        transform_settings->odd_page_transform = printing::TRANSFORM_ROTATE_180;
+      } else if (document_sheet_back == FLIPPED) {
+        transform_settings->odd_page_transform =
+            printing::TRANSFORM_FLIP_VERTICAL;
+      }
+      break;
+    case SHORT_EDGE:
+      if (document_sheet_back == MANUAL_TUMBLE) {
+        transform_settings->odd_page_transform = printing::TRANSFORM_ROTATE_180;
+      } else if (document_sheet_back == FLIPPED) {
+        transform_settings->odd_page_transform =
+            printing::TRANSFORM_FLIP_HORIZONTAL;
+      }
+  }
+
+  transform_settings->rotate_all_pages =
+      raster_capability.value().rotate_all_pages;
+
+  transform_settings->reverse_page_order =
+      raster_capability.value().reverse_order_streaming;
+}
+
 void PrivetLocalPrintOperationImpl::StartConvertToPWG() {
+  printing::PwgRasterSettings transform_settings;
+
+  FillPwgRasterSettings(&transform_settings);
+
   if (!pwg_raster_converter_)
     pwg_raster_converter_ = PWGRasterConverter::CreateDefault();
+
   double scale = dpi_;
   scale /= printing::kPointsPerInch;
   // Make vertical rectangle to optimize streaming to printer. Fix orientation
   // by autorotate.
   gfx::Rect area(std::min(page_size_.width(), page_size_.height()) * scale,
                  std::max(page_size_.width(), page_size_.height()) * scale);
   pwg_raster_converter_->Start(
-      data_, printing::PdfRenderSettings(area, dpi_, true),
+      data_,
+      printing::PdfRenderSettings(area, dpi_, true),
+      transform_settings,
       base::Bind(&PrivetLocalPrintOperationImpl::OnPWGRasterConverted,
                  base::Unretained(this)));
 }
 
 void PrivetLocalPrintOperationImpl::OnSubmitdocResponse(
     bool has_error,
     const base::DictionaryValue* value) {
   std::string error;
   // This error is only relevant in the case of extended workflow:
   // If the print job ID is invalid, retry createjob and submitdoc,
@@ skipping 231 matching lines @@
   TokenCallbackVector token_callbacks;
   token_callbacks_.swap(token_callbacks);
 
   for (TokenCallbackVector::iterator i = token_callbacks.begin();
        i != token_callbacks.end(); i++) {
     i->Run(token);
   }
 }
 
 }  // namespace local_discovery