Added 'dry run' tag to the print job, to test proxy health without wasting pa...

chrome/service/cloud_print/print_system_cups.cc

 // Copyright (c) 2010 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 <cups/cups.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <pthread.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
 
 #include "base/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/lock.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/values.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/service/cloud_print/cloud_print_consts.h"
+#include "chrome/service/cloud_print/cloud_print_helpers.h"
 #include "googleurl/src/gurl.h"
 #include "printing/backend/cups_helper.h"
 #include "printing/backend/print_backend.h"
 
 namespace {
 static const char kCUPSPrinterInfoOpt[] = "printer-info";
 static const char kCUPSPrinterStateOpt[] = "printer-state";
 static const char kCUPSPrintServerURLs[] = "print_server_urls";
 static const char kCUPSUpdateTimeoutMs[] = "update_timeout_ms";
 static const char kCUPSPrintBackendServerURL[] = "print_server_url";
 
 // Default port for IPP print servers.
 static const int kDefaultIPPServerPort = 631;
 
 // Time interval to check for printer's updates.
 const int kCheckForPrinterUpdatesMs = 6*60*60*1000;
 
 // Job update timeput
 const int kJobUpdateTimeoutMs = 5000;
 
+// Job id for dry run (it should not affect CUPS job ids, since 0 job-id is
+// invalid in CUPS.
+const int kDryRunJobId = 0;
+
 }  // namespace
 
 namespace cloud_print {
 
 struct PrintServerInfoCUPS {
   GURL url;
   scoped_refptr<printing::PrintBackend> backend;
   printing::PrinterList printers;
   // CapsMap cache PPD until the next update and give a fast access to it by
   // printer name. PPD request is relatively expensive and this should minimize
@@ skipping 27 matching lines @@
   virtual PrintSystem::PrintServerWatcher* CreatePrintServerWatcher();
   virtual PrintSystem::PrinterWatcher* CreatePrinterWatcher(
       const std::string& printer_name);
   virtual PrintSystem::JobSpooler* CreateJobSpooler();
 
   // Helper functions.
   PlatformJobId SpoolPrintJob(const std::string& print_ticket,
                               const FilePath& print_data_file_path,
                               const std::string& print_data_mime_type,
                               const std::string& printer_name,
-                              const std::string& job_title);
+                              const std::string& job_title,
+                              const std::vector<std::string>& tags,
+                              bool* dry_run);
   bool GetPrinterInfo(const std::string& printer_name,
                       printing::PrinterBasicInfo* info);
   bool ParsePrintTicket(const std::string& print_ticket,
                         std::map<std::string, std::string>* options);
 
   int GetUpdateTimeoutMs() const {
     return update_timeout_;
   }
 
  private:
@@ skipping 196 matching lines @@
   explicit JobSpoolerCUPS(PrintSystemCUPS* print_system)
       : print_system_(print_system) {
     DCHECK(print_system_.get());
   }
   // PrintSystem::JobSpooler implementation.
   virtual bool Spool(const std::string& print_ticket,
                      const FilePath& print_data_file_path,
                      const std::string& print_data_mime_type,
                      const std::string& printer_name,
                      const std::string& job_title,
+                     const std::vector<std::string>& tags,
                      JobSpooler::Delegate* delegate) {
     DCHECK(delegate);
+    bool dry_run = false;
     int job_id = print_system_->SpoolPrintJob(
         print_ticket, print_data_file_path, print_data_mime_type,
-        printer_name, job_title);
+        printer_name, job_title, tags, &dry_run);
     MessageLoop::current()->PostTask(FROM_HERE,
                                      NewRunnableFunction(
                                          &JobSpoolerCUPS::NotifyDelegate,
                                          delegate,
-                                         job_id));
+                                         job_id,
+                                         dry_run));
     return true;
   }
 
-  static void NotifyDelegate(JobSpooler::Delegate* delegate, int job_id) {
-    if (job_id)
+  static void NotifyDelegate(JobSpooler::Delegate* delegate,
+                             int job_id, bool dry_run) {
+    if (dry_run || job_id)
       delegate->OnJobSpoolSucceeded(job_id);
     else
       delegate->OnJobSpoolFailed();
   }
  private:
   scoped_refptr<PrintSystemCUPS> print_system_;
   DISALLOW_COPY_AND_ASSIGN(JobSpoolerCUPS);
 };
 
 PrintSystemCUPS::PrintSystemCUPS(const DictionaryValue* print_system_settings)
@@ skipping 148 matching lines @@
   std::string short_printer_name;
   PrintServerInfoCUPS* server_info =
       FindServerByFullName(printer_name, &short_printer_name);
   if (!server_info)
     return false;
 
   cups_job_t* jobs = NULL;
   int num_jobs = GetJobs(&jobs, server_info->url,
                          short_printer_name.c_str(), 1, -1);
 
+
+  // Check if the request is for dummy dry run job.
+  // We check this after calling GetJobs API to see if this printer is actually
+  // accessible through CUPS.
+  if (job_id == kDryRunJobId) {
+    if (num_jobs >= 0) {
+      job_details->status = PRINT_JOB_STATUS_COMPLETED;
+      VLOG(1) << "CP_CUPS: Dry run job succeeded for: " << printer_name;
+    } else {
+      job_details->status = PRINT_JOB_STATUS_ERROR;
+      VLOG(1) << "CP_CUPS: Dry run job faield for: " << printer_name;
+    }
+    return true;
+  }
+
   bool found = false;
   for (int i = 0; i < num_jobs; i++) {
     if (jobs[i].id == job_id) {
       found = true;
       switch (jobs[i].state) {
         case IPP_JOB_PENDING :
         case IPP_JOB_HELD :
         case IPP_JOB_PROCESSING :
           job_details->status = PRINT_JOB_STATUS_IN_PROGRESS;
           break;
@@ skipping 102 matching lines @@
     printing::HttpConnectionCUPS http(url);
     return cupsGetJobs2(http.http(), jobs, name, myjobs, whichjobs);
   }
 }
 
 PlatformJobId PrintSystemCUPS::SpoolPrintJob(
     const std::string& print_ticket,
     const FilePath& print_data_file_path,
     const std::string& print_data_mime_type,
     const std::string& printer_name,
-    const std::string& job_title) {
+    const std::string& job_title,
+    const std::vector<std::string>& tags,
+    bool* dry_run) {
   DCHECK(initialized_);
   VLOG(1) << "CP_CUPS: Spooling print job for: " << printer_name;
 
   std::string short_printer_name;
   PrintServerInfoCUPS* server_info =
       FindServerByFullName(printer_name, &short_printer_name);
   if (!server_info)
     return false;
 
   // We need to store options as char* string for the duration of the
   // cupsPrintFile2 call. We'll use map here to store options, since
   // Dictionary value from JSON parser returns wchat_t.
   std::map<std::string, std::string> options;
   bool res = ParsePrintTicket(print_ticket, &options);
   DCHECK(res);  // If print ticket is invalid we still print using defaults.
 
+  // Check if this is a dry run (test) job.
+  *dry_run = CloudPrintHelpers::IsDryRunJob(tags);
+  if (*dry_run) {
+    VLOG(1) << "CP_CUPS: Dry run job spooled.";
+    return kDryRunJobId;
+  }
+
   std::vector<cups_option_t> cups_options;
   std::map<std::string, std::string>::iterator it;
+
   for (it = options.begin(); it != options.end(); ++it) {
     cups_option_t opt;
     opt.name = const_cast<char*>(it->first.c_str());
     opt.value = const_cast<char*>(it->second.c_str());
     cups_options.push_back(opt);
   }
 
   int job_id = PrintFile(server_info->url,
                          short_printer_name.c_str(),
                          print_data_file_path.value().c_str(),
@@ skipping 42 matching lines @@
       *short_printer_name = full_printer_name.substr(separator + 1);
       return &(*it);
     }
   }
 
   LOG(WARNING) << "Server not found for printer: " << full_printer_name;
   return NULL;
 }
 
 }  // namespace cloud_print