Tunnel the CDD from the Print Preview javascript to the privet operation

chrome/browser/ui/webui/print_preview/print_preview_handler.cc

 // Copyright (c) 2012 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/ui/webui/print_preview/print_preview_handler.h"
 
 #include <ctype.h>
 
 #include <string>
 
@@ skipping 704 matching lines @@
     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintToPDF", page_count);
     ReportUserActionHistogram(PRINT_TO_PDF);
     PrintToPdf();
     return;
   }
 
 #if defined(ENABLE_MDNS)
   if (print_with_privet && PrivetPrintingEnabled()) {
     std::string printer_name;
     std::string print_ticket;
+    std::string capabilities;
     UMA_HISTOGRAM_COUNTS("PrintPreview.PageCount.PrintWithPrivet", page_count);
     ReportUserActionHistogram(PRINT_WITH_PRIVET);
 
     int width = 0;
     int height = 0;
     if (!settings->GetString(printing::kSettingDeviceName, &printer_name) ||
         !settings->GetString(printing::kSettingTicket, &print_ticket) ||
+        !settings->GetString(printing::kSettingCapabilities, &capabilities) ||
         !settings->GetInteger(printing::kSettingPageWidth, &width) ||
         !settings->GetInteger(printing::kSettingPageHeight, &height) ||
-        width <= 0 || height <=0) {
+        width <= 0 || height <= 0) {
       NOTREACHED();
       base::FundamentalValue http_code_value(-1);
       web_ui()->CallJavascriptFunction("onPrivetPrintFailed", http_code_value);
       return;
     }
 
-    PrintToPrivetPrinter(printer_name, print_ticket, gfx::Size(width, height));
+    PrintToPrivetPrinter(
+        printer_name, print_ticket, capabilities, gfx::Size(width, height));
     return;
   }
 #endif
 
   scoped_refptr<base::RefCountedBytes> data;
   base::string16 title;
   if (!GetPreviewDataAndTitle(&data, &title)) {
     // Nothing to print, no preview available.
     return;
   }
@@ skipping 644 matching lines @@
   privet_capabilities_operation_.reset();
   privet_http_client_ = http_client.Pass();
 
   privet_http_resolution_.reset();
 
   return true;
 }
 
 void PrintPreviewHandler::PrivetLocalPrintUpdateClient(
     std::string print_ticket,
+    std::string capabilities,
     gfx::Size page_size,
     scoped_ptr<local_discovery::PrivetHTTPClient> http_client) {
   if (!PrivetUpdateClient(http_client.Pass()))
     return;
 
-  StartPrivetLocalPrint(print_ticket, page_size);
+  StartPrivetLocalPrint(print_ticket, capabilities, page_size);
 }
 
-void PrintPreviewHandler::StartPrivetLocalPrint(
-    const std::string& print_ticket,
-    const gfx::Size& page_size) {
+void PrintPreviewHandler::StartPrivetLocalPrint(const std::string& print_ticket,
+                                                const std::string& capabilities,
+                                                const gfx::Size& page_size) {
   privet_local_print_operation_ =
       privet_http_client_->CreateLocalPrintOperation(this);
 
   privet_local_print_operation_->SetTicket(print_ticket);
+  privet_local_print_operation_->SetCapabilities(capabilities);
 
   scoped_refptr<base::RefCountedBytes> data;
   base::string16 title;
 
   if (!GetPreviewDataAndTitle(&data, &title)) {
     base::FundamentalValue http_code_value(-1);
     web_ui()->CallJavascriptFunction("onPrivetPrintFailed", http_code_value);
     return;
   }
 
@@ skipping 43 matching lines @@
 }
 
 void PrintPreviewHandler::SendPrivetCapabilitiesError(
     const std::string& device_name) {
   base::StringValue name_value(device_name);
   web_ui()->CallJavascriptFunction(
       "failedToGetPrivetPrinterCapabilities",
       name_value);
 }
 
-void PrintPreviewHandler::PrintToPrivetPrinter(
-    const std::string& device_name,
-    const std::string& ticket,
-    const gfx::Size& page_size) {
+void PrintPreviewHandler::PrintToPrivetPrinter(const std::string& device_name,
+                                               const std::string& ticket,
+                                               const std::string& capabilities,
+                                               const gfx::Size& page_size) {
   CreatePrivetHTTP(
       device_name,
       base::Bind(&PrintPreviewHandler::PrivetLocalPrintUpdateClient,
-                 base::Unretained(this), ticket, page_size));
+                 base::Unretained(this),
+                 ticket,
+                 capabilities,
+                 page_size));
 }
 
 bool PrintPreviewHandler::CreatePrivetHTTP(
     const std::string& name,
     const local_discovery::PrivetHTTPAsynchronousFactory::ResultCallback&
     callback) {
   const local_discovery::DeviceDescription* device_description =
       printer_lister_->GetDeviceDescription(name);
 
   if (!device_description) {
@@ skipping 37 matching lines @@
   printer_value->SetString("name", description.name);
   printer_value->SetBoolean("hasLocalPrinting", has_local_printing);
   printer_value->SetBoolean(
       "isUnregistered",
       description.id.empty() &&
       command_line->HasSwitch(switches::kEnablePrintPreviewRegisterPromos));
   printer_value->SetString("cloudID", description.id);
 }
 
 #endif