"Privet" Printing reads DPI for PWG raster conversion from device capabilities.

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 "chrome/browser/local_discovery/privet_constants.h"
+#include "components/cloud_devices/printer_description.h"
 #include "net/base/url_util.h"
+#include "printing/units.h"
 #include "url/gurl.h"
 
 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";
 const char kPrivetURLKeyOffline[] = "offline";
 const char kPrivetURLValueOffline[] = "1";
 const char kPrivetURLValueClientName[] = "Chrome";
 
 const char kPrivetContentTypePDF[] = "application/pdf";
 const char kPrivetContentTypePWGRaster[] = "image/pwg-raster";
 const char kPrivetContentTypeAny[] = "*/*";
 const char kPrivetContentTypeCJT[] = "application/json";
 
 const char kPrivetStorageListPath[] = "/privet/storage/list";
 const char kPrivetStorageParamPathFormat[] = "path=%s";
 
-const char kPrivetCDDKeySupportedContentTypes[] =
-    "printer.supported_content_type";
-
-const char kPrivetCDDKeyContentType[] = "content_type";
-
 const char kPrivetKeyJobID[] = "job_id";
 
 const int kPrivetCancelationTimeoutSeconds = 3;
 
 const int kPrivetLocalPrintMaxRetries = 2;
 
 const int kPrivetLocalPrintDefaultTimeout = 5;
 
 GURL CreatePrivetURL(const std::string& path) {
   GURL url(kUrlPlaceHolder);
@@ skipping 320 matching lines @@
 
 void PrivetJSONOperationImpl::OnNeedPrivetToken(
     PrivetURLFetcher* fetcher,
     const PrivetURLFetcher::TokenCallback& callback) {
   privet_client_->RefreshPrivetToken(callback);
 }
 
 PrivetLocalPrintOperationImpl::PrivetLocalPrintOperationImpl(
     PrivetHTTPClientImpl* privet_client,
     PrivetLocalPrintOperation::Delegate* delegate)
-    : privet_client_(privet_client), delegate_(delegate),
-      use_pdf_(false), has_capabilities_(false), has_extended_workflow_(false),
-      started_(false), offline_(false), invalid_job_retries_(0),
+    : privet_client_(privet_client),
+      delegate_(delegate),
+      use_pdf_(false),
+      has_capabilities_(false),
+      has_extended_workflow_(false),
+      started_(false),
+      offline_(false),
+      dpi_(printing::kDefaultPdfDpi),
+      invalid_job_retries_(0),
       weak_factory_(this) {
 }
 
 PrivetLocalPrintOperationImpl::~PrivetLocalPrintOperationImpl() {
 }
 
 void PrivetLocalPrintOperationImpl::Start() {
   DCHECK(!started_);
 
   // We need to get the /info response so we can know which APIs are available.
@@ skipping 36 matching lines @@
     StartInitialRequest();
   } else {
     delegate_->OnPrivetPrintingError(this, -1);
   }
 }
 
 void PrivetLocalPrintOperationImpl::StartInitialRequest() {
   if (has_capabilities_) {
     GetCapabilities();
   } else {
-    // Since we have no capabiltties, the only reasonable format we can
+    // Since we have no capabilities, the only reasonable format we can
     // request is PWG Raster.
     use_pdf_ = false;
     StartConvertToPWG();
   }
 }
 
 void PrivetLocalPrintOperationImpl::GetCapabilities() {
   current_response_ = base::Bind(
       &PrivetLocalPrintOperationImpl::OnCapabilitiesResponse,
       base::Unretained(this));
@@ skipping 71 matching lines @@
   if (has_extended_workflow_ && !ticket_.empty() && jobid_.empty()) {
     DoCreatejob();
   } else {
     DoSubmitdoc();
   }
 }
 
 void PrivetLocalPrintOperationImpl::StartConvertToPWG() {
   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_,
-      conversion_settings_,
+      data_, printing::PdfRenderSettings(area, dpi_, true),
       base::Bind(&PrivetLocalPrintOperationImpl::OnPWGRasterConverted,
                  base::Unretained(this)));
 }
 
 void PrivetLocalPrintOperationImpl::OnCapabilitiesResponse(
     bool has_error,
     const base::DictionaryValue* value) {
   if (has_error) {
     delegate_->OnPrivetPrintingError(this, 200);
     return;
   }
 
-  const base::ListValue* supported_content_types;
+  cloud_devices::CloudDeviceDescription description;
+  if (!description.InitFromDictionary(make_scoped_ptr(value->DeepCopy()))) {
+    delegate_->OnPrivetPrintingError(this, 200);
+    return;
+  }
+
   use_pdf_ = false;
-
-  if (value->GetList(kPrivetCDDKeySupportedContentTypes,
-                     &supported_content_types)) {
-    for (size_t i = 0; i < supported_content_types->GetSize(); i++) {
-      const base::DictionaryValue* content_type_value;
-      std::string content_type;
-
-      if (supported_content_types->GetDictionary(i, &content_type_value) &&
-          content_type_value->GetString(kPrivetCDDKeyContentType,
-                                        &content_type) &&
-          (content_type == kPrivetContentTypePDF ||
-           content_type == kPrivetContentTypeAny) ) {
-        use_pdf_ = true;
-      }
-    }
+  cloud_devices::printer::ContentTypesCapability content_types;
+  if (content_types.LoadFrom(description)) {
+    use_pdf_ = content_types.Contains(kPrivetContentTypePDF) ||
+               content_types.Contains(kPrivetContentTypeAny);
   }
 
   if (use_pdf_) {
     StartPrinting();
   } else {
+    cloud_devices::printer::DpiCapability dpis;
+    if (dpis.LoadFrom(description)) {
+      dpi_ = std::max(dpis.GetDefault().horizontal, dpis.GetDefault().vertical);
+    }
     StartConvertToPWG();
   }
 }
 
 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 104 matching lines @@
 void PrivetLocalPrintOperationImpl::SetJobname(const std::string& jobname) {
   DCHECK(!started_);
   jobname_ = jobname;
 }
 
 void PrivetLocalPrintOperationImpl::SetOffline(bool offline) {
   DCHECK(!started_);
   offline_ = offline;
 }
 
-void PrivetLocalPrintOperationImpl::SetConversionSettings(
-    const printing::PdfRenderSettings& conversion_settings) {
+void PrivetLocalPrintOperationImpl::SetPageSize(const gfx::Size& page_size) {
   DCHECK(!started_);
-  conversion_settings_ = conversion_settings;
+  page_size_ = page_size;
 }
 
 void PrivetLocalPrintOperationImpl::SetPWGRasterConverterForTesting(
     scoped_ptr<PWGRasterConverter> pwg_raster_converter) {
   pwg_raster_converter_ = pwg_raster_converter.Pass();
 }
 
 PrivetHTTPClientImpl::PrivetHTTPClientImpl(
     const std::string& name,
     const net::HostPortPair& host_port,
@@ skipping 102 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