Add ability to specify list of supported mime types for Cloud Print connector in Service State file.

chrome/service/cloud_print/print_system_cups.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 <cups/cups.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <pthread.h>
@@ skipping 27 matching lines @@
 namespace {
 
 // CUPS specific options.
 const char kCUPSPrinterInfoOpt[] = "printer-info";
 const char kCUPSPrinterStateOpt[] = "printer-state";
 
 // Print system config options.
 const char kCUPSPrintServerURLs[] = "print_server_urls";
 const char kCUPSUpdateTimeoutMs[] = "update_timeout_ms";
 const char kCUPSNotifyDelete[] = "notify_delete";
+const char kCUPSSupportedMimeTipes[] = "supported_mime_types";
+
+// Default mime types supported by CUPS
+// http://www.cups.org/articles.php?L205+TFAQ+Q
+const char kCUPSDefaultSupportedTypes[] =
+    "application/pdf,application/postscript,image/jpeg,image/png,image/gif";
 
 // Default port for IPP print servers.
 const int kDefaultIPPServerPort = 631;
 
 // Time interval to check for printer's updates.
 const int kCheckForPrinterUpdatesMinutes = 5;
 
 // Job update timeout
 const int kJobUpdateTimeoutSeconds = 5;
 
@@ skipping 104 matching lines @@
   // PrintServerList contains information about all print servers and backends
   // this proxy is connected to.
   typedef std::list<PrintServerInfoCUPS> PrintServerList;
   PrintServerList print_servers_;
 
   base::TimeDelta update_timeout_;
   bool initialized_;
   bool printer_enum_succeeded_;
   bool notify_delete_;
   http_encryption_t cups_encryption_;
+  std::string supported_mime_types_;
 };
 
 class PrintServerWatcherCUPS
   : public PrintSystem::PrintServerWatcher {
  public:
   explicit PrintServerWatcherCUPS(PrintSystemCUPS* print_system)
       : print_system_(print_system),
         delegate_(NULL) {
   }
 
@@ skipping 224 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(JobSpoolerCUPS);
 };
 
 PrintSystemCUPS::PrintSystemCUPS(const DictionaryValue* print_system_settings)
     : update_timeout_(base::TimeDelta::FromMinutes(
         kCheckForPrinterUpdatesMinutes)),
       initialized_(false),
       printer_enum_succeeded_(false),
       notify_delete_(true),
-      cups_encryption_(HTTP_ENCRYPT_NEVER) {
+      cups_encryption_(HTTP_ENCRYPT_NEVER),
+      supported_mime_types_(kCUPSDefaultSupportedTypes) {
   if (print_system_settings) {
     int timeout;
     if (print_system_settings->GetInteger(kCUPSUpdateTimeoutMs, &timeout))
       update_timeout_ = base::TimeDelta::FromMilliseconds(timeout);
 
     int encryption;
     if (print_system_settings->GetInteger(kCUPSEncryption, &encryption))
       cups_encryption_ =
           static_cast<http_encryption_t>(encryption);
 
     bool notify_delete = true;
     if (print_system_settings->GetBoolean(kCUPSNotifyDelete, &notify_delete))
       notify_delete_ = notify_delete;
+
+    std::string types;
+    if (print_system_settings->GetString(kCUPSSupportedMimeTipes, &types))
+      supported_mime_types_ = types;
   }
 
   InitPrintBackends(print_system_settings);
 }
 
 void PrintSystemCUPS::InitPrintBackends(
     const DictionaryValue* print_system_settings) {
   const ListValue* url_list;
   if (print_system_settings &&
       print_system_settings->GetList(kCUPSPrintServerURLs, &url_list)) {
@@ skipping 265 matching lines @@
   DCHECK(!printer_name.empty());
   return new PrinterWatcherCUPS(this, printer_name);
 }
 
 PrintSystem::JobSpooler* PrintSystemCUPS::CreateJobSpooler() {
   DCHECK(initialized_);
   return new JobSpoolerCUPS(this);
 }
 
 std::string PrintSystemCUPS::GetSupportedMimeTypes() {
-  // Since we hand off the document to the CUPS server directly, list some types
-  // that we know CUPS supports (http://www.cups.org/articles.php?L205+TFAQ+Q)
-  // TODO(sanjeevr): Determine this dynamically (http://crbug.com/73240).
-  return
-      "application/pdf,application/postscript,image/jpeg,image/png,image/gif";
+  return supported_mime_types_;
 }
 
 std::string PrintSystem::GenerateProxyId() {
   // TODO(gene): This code should generate a unique id for proxy. ID should be
   // unique for this user. Rand may return the same number. We'll need to change
   // this in the future.
   std::string id("CP_PROXY_");
   id += base::Uint64ToString(base::RandUint64());
   return id;
 }
@@ skipping 135 matching lines @@
 
 void PrintSystemCUPS::RunCapsCallback(
     const PrinterCapsAndDefaultsCallback& callback,
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& printer_info) {
   callback.Run(succeeded, printer_name, printer_info);
 }
 
 }  // namespace cloud_print