Fallback to CDD/CJT if connector can't initialize XPS API.

chrome/service/cloud_print/print_system_win.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/service/cloud_print/print_system.h"
 
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/object_watcher.h"
@@ skipping 59 matching lines @@
     hr = printing::XPSModule::ConvertPrintTicketToDevMode(provider,
                                                           pt_stream,
                                                           kUserDefaultDevmode,
                                                           kPTJobScope,
                                                           &size,
                                                           &dm,
                                                           NULL);
     if (SUCCEEDED(hr)) {
       // Correct DEVMODE using DocumentProperties. See documentation for
       // PTConvertPrintTicketToDevMode.
-      LONG buffer_size =
-          DocumentProperties(NULL, printer,
-                             const_cast<LPWSTR>(printer_name.c_str()), NULL, dm,
-                             DM_IN_BUFFER);
+      wchar_t* mutable_name = const_cast<wchar_t*>(printer_name.c_str());

[Noam Samuel, 2014/02/07 19:47:53]

Is it kosher to mutate a .c_str()? It looks like it worked for a while, but I'm
not 100% sure it will work for every implementation.

+      LONG buffer_size = DocumentProperties(NULL, printer, mutable_name, NULL,
+                                            dm, DM_IN_BUFFER);
       if (buffer_size <= 0)
         return scoped_ptr<DEVMODE[]>();
-
       scoped_dev_mode.reset(reinterpret_cast<DEVMODE*>(new uint8[buffer_size]));
-      if (DocumentProperties(NULL, printer,
-                             const_cast<LPWSTR>(printer_name.c_str()),
-                             scoped_dev_mode.get(), dm,
-                             DM_OUT_BUFFER | DM_IN_BUFFER) != IDOK) {
+      if (DocumentProperties(NULL, printer, mutable_name, scoped_dev_mode.get(),
+                             dm, DM_OUT_BUFFER | DM_IN_BUFFER) != IDOK) {
         scoped_dev_mode.reset();
       }
       printing::XPSModule::ReleaseMemory(dm);
     }
     printing::XPSModule::CloseProvider(provider);
   }
   return scoped_dev_mode.Pass();
 }
 
 class PrintSystemWatcherWin : public base::win::ObjectWatcher::Delegate {
@@ skipping 229 matching lines @@
                const std::string& job_title,
                JobSpooler::Delegate* delegate) {
       if (delegate_) {
         // We are already in the process of printing.
         NOTREACHED();
         return false;
       }
       last_page_printed_ = -1;
       // We only support PDF and XPS documents for now.
       if (print_data_mime_type == kContentTypePDF) {
-        DCHECK(print_ticket_mime_type == kContentTypeXML);
-        scoped_ptr<DEVMODE[]> dev_mode =
-            XpsTicketToDevMode(base::UTF8ToWide(printer_name), print_ticket);
+        scoped_ptr<DEVMODE[]> dev_mode;
+        if (print_ticket_mime_type == kContentTypeJSON) {
+          dev_mode = CjtToDevMode(base::UTF8ToWide(printer_name), print_ticket);
+        } else {
+          DCHECK(print_ticket_mime_type == kContentTypeXML);
+          dev_mode = XpsTicketToDevMode(base::UTF8ToWide(printer_name),
+                                        print_ticket);
+        }
 
         if (!dev_mode) {
           NOTREACHED();
           return false;
         }
 
         HDC dc = CreateDC(L"WINSPOOL", base::UTF8ToWide(printer_name).c_str(),
                           NULL, dev_mode.get());
         if (!dc) {
           NOTREACHED();
           return false;
         }
         DOCINFO di = {0};
         di.cbSize = sizeof(DOCINFO);
         base::string16 doc_name = base::UTF8ToUTF16(job_title);
         DCHECK(printing::SimplifyDocumentTitle(doc_name) == doc_name);
         di.lpszDocName = doc_name.c_str();
         job_id_ = StartDoc(dc, &di);
         if (job_id_ <= 0)
           return false;
 
         printer_dc_.Set(dc);
         saved_dc_ = SaveDC(printer_dc_.Get());
         print_data_file_path_ = print_data_file_path;
         delegate_ = delegate;
         RenderNextPDFPages();
       } else if (print_data_mime_type == kContentTypeXPS) {
+        DCHECK(print_ticket_mime_type == kContentTypeXML);
         bool ret = PrintXPSDocument(printer_name,
                                     job_title,
                                     print_data_file_path,
                                     print_ticket);
         if (ret)
           delegate_ = delegate;
         return ret;
       } else {
         NOTREACHED();
         return false;
@@ skipping 239 matching lines @@
     callback_.Reset();
     Release();
   }
 
   virtual void OnGetPrinterSemanticCapsAndDefaults(
       bool succeeded,
       const std::string& printer_name,
       const printing::PrinterSemanticCapsAndDefaults& semantic_info) OVERRIDE {
     printing::PrinterCapsAndDefaults printer_info;
     if (succeeded) {
-      printer_info.caps_mime_type = kContentTypeCDD;
+      printer_info.caps_mime_type = kContentTypeJSON;
       printer_info.printer_capabilities = CapabilitiesToCdd(semantic_info);
     }
     callback_.Run(succeeded, printer_name, printer_info);
     callback_.Reset();
     Release();
   }
 
   void StartGetPrinterCapsAndDefaults() {
     g_service_process->io_thread()->message_loop_proxy()->PostTask(
         FROM_HERE,
@@ skipping 63 matching lines @@
       const std::string& printer_name,
       const std::string& print_ticket_data,
       const std::string& print_ticket_data_mime_type) OVERRIDE;
   virtual bool GetJobDetails(const std::string& printer_name,
                              PlatformJobId job_id,
                              PrintJobDetails *job_details) OVERRIDE;
   virtual PrintSystem::PrintServerWatcher* CreatePrintServerWatcher() OVERRIDE;
   virtual PrintSystem::PrinterWatcher* CreatePrinterWatcher(
       const std::string& printer_name) OVERRIDE;
   virtual PrintSystem::JobSpooler* CreateJobSpooler() OVERRIDE;
+  virtual bool UseCddAndCjt() OVERRIDE;
   virtual std::string GetSupportedMimeTypes() OVERRIDE;
 
  private:
   std::string PrintSystemWin::GetPrinterDriverInfo(
       const std::string& printer_name) const;
 
   scoped_refptr<printing::PrintBackend> print_backend_;
-  bool use_xps_;
+  bool use_cdd_;
   DISALLOW_COPY_AND_ASSIGN(PrintSystemWin);
 };
 
-PrintSystemWin::PrintSystemWin() : use_xps_(false) {
+PrintSystemWin::PrintSystemWin() : use_cdd_(false) {
   print_backend_ = printing::PrintBackend::CreateInstance(NULL);
 }
 
 PrintSystem::PrintSystemResult PrintSystemWin::Init() {
-  use_xps_ = printing::XPSModule::Init();
-  if (!use_xps_) {
-    std::string message = l10n_util::GetStringFUTF8(
-        IDS_CLOUD_PRINT_XPS_UNAVAILABLE,
-        l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT));
-    return PrintSystemResult(false, message);
-  }
+  use_cdd_ = !printing::XPSModule::Init();
   return PrintSystemResult(true, std::string());
 }
 
 PrintSystem::PrintSystemResult PrintSystemWin::EnumeratePrinters(
     printing::PrinterList* printer_list) {
   bool ret = print_backend_->EnumeratePrinters(printer_list);
   return PrintSystemResult(ret, std::string());
 }
 
 void PrintSystemWin::GetPrinterCapsAndDefaults(
     const std::string& printer_name,
     const PrinterCapsAndDefaultsCallback& callback) {
   // Launch as child process to retrieve the capabilities and defaults because
   // this involves invoking a printer driver DLL and crashes have been known to
   // occur.
   PrinterCapsHandler* handler =
       new PrinterCapsHandler(printer_name, callback);
   handler->AddRef();
-  handler->StartGetPrinterCapsAndDefaults();
+  if (use_cdd_)
+    handler->StartGetPrinterSemanticCapsAndDefaults();
+  else
+    handler->StartGetPrinterCapsAndDefaults();
 }
 
 bool PrintSystemWin::IsValidPrinter(const std::string& printer_name) {
   return print_backend_->IsValidPrinter(printer_name);
 }
 
 bool PrintSystemWin::ValidatePrintTicket(
     const std::string& printer_name,
     const std::string& print_ticket_data,
     const std::string& print_ticket_data_mime_type) {
   crash_keys::ScopedPrinterInfo crash_key(GetPrinterDriverInfo(printer_name));
+
+  if (use_cdd_) {
+    return print_ticket_data_mime_type == kContentTypeJSON &&
+           IsValidCjt(print_ticket_data);
+  }
   DCHECK(print_ticket_data_mime_type == kContentTypeXML);
 
   printing::ScopedXPSInitializer xps_initializer;
   if (!xps_initializer.initialized()) {
     // TODO(sanjeevr): Handle legacy proxy case (with no prntvpt.dll)
     return false;
   }
   bool ret = false;
   HPTPROVIDER provider = NULL;
   printing::XPSModule::OpenProvider(base::UTF8ToWide(printer_name.c_str()),
@@ skipping 78 matching lines @@
 PrintSystem::PrinterWatcher* PrintSystemWin::CreatePrinterWatcher(
     const std::string& printer_name) {
   DCHECK(!printer_name.empty());
   return new PrinterWatcherWin(printer_name);
 }
 
 PrintSystem::JobSpooler* PrintSystemWin::CreateJobSpooler() {
   return new JobSpoolerWin();
 }
 
+bool PrintSystemWin::UseCddAndCjt() {
+  return use_cdd_;
+}
+
 std::string PrintSystemWin::GetSupportedMimeTypes() {
   std::string result;
-  if (use_xps_) {
+  if (!use_cdd_) {
     result = kContentTypeXPS;
     result += ",";
   }
   result = kContentTypePDF;
   return result;
 }
 
 std::string PrintSystemWin::GetPrinterDriverInfo(
     const std::string& printer_name) const {
   return print_backend_->GetPrinterDriverInfo(printer_name);
 }
 
 }  // namespace
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const base::DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print