Enable the cups backend when --enable-native-cups is specified.

printing/backend/print_backend_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 "printing/backend/print_backend.h"
+#include "printing/backend/print_backend_cups.h"
 
 #include <dlfcn.h>
 #include <errno.h>
 #include <pthread.h>
+#include <string>

[Lei Zhang, 2016/06/28 22:27:35]

Chromium code separates C headers from C++ headers. (google3 prefers the other
way)

[skau, 2016/06/28 23:58:19]

Done.

 
 #include "base/debug/leak_annotations.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/values.h"
 #include "printing/backend/cups_helper.h"
 #include "printing/backend/print_backend_consts.h"
@@ skipping 41 matching lines @@
   // Store printer options.
   for (int opt_index = 0; opt_index < printer.num_options; ++opt_index) {
     printer_info->options[printer.options[opt_index].name] =
         printer.options[opt_index].value;
   }
   return true;
 }
 
 }  // namespace
 
-class PrintBackendCUPS : public PrintBackend {
- public:
-  PrintBackendCUPS(const GURL& print_server_url,
-                   http_encryption_t encryption, bool blocking);
-
- private:
-  ~PrintBackendCUPS() override {}
-
-  // PrintBackend implementation.
-  bool EnumeratePrinters(PrinterList* printer_list) override;
-  std::string GetDefaultPrinterName() override;
-  bool GetPrinterBasicInfo(const std::string& printer_name,
-                           PrinterBasicInfo* printer_info) override;
-  bool GetPrinterSemanticCapsAndDefaults(
-      const std::string& printer_name,
-      PrinterSemanticCapsAndDefaults* printer_info) override;
-  bool GetPrinterCapsAndDefaults(const std::string& printer_name,
-                                 PrinterCapsAndDefaults* printer_info) override;
-  std::string GetPrinterDriverInfo(const std::string& printer_name) override;
-  bool IsValidPrinter(const std::string& printer_name) override;
-
-  // The following functions are wrappers around corresponding CUPS functions.
-  // <functions>2() are called when print server is specified, and plain version
-  // in another case. There is an issue specifying CUPS_HTTP_DEFAULT in the
-  // functions>2(), it does not work in CUPS prior to 1.4.
-  int GetDests(cups_dest_t** dests);
-  base::FilePath GetPPD(const char* name);
-
-  // Wrapper around cupsGetNamedDest(). Returned result should be freed with
-  // cupsFreeDests().
-  cups_dest_t* GetNamedDest(const std::string& printer_name);
-
-  GURL print_server_url_;
-  http_encryption_t cups_encryption_;
-  bool blocking_;
-};
-
 PrintBackendCUPS::PrintBackendCUPS(const GURL& print_server_url,
                                    http_encryption_t encryption,
                                    bool blocking)
     : print_server_url_(print_server_url),
       cups_encryption_(encryption),
       blocking_(blocking) {
 }
 
 bool PrintBackendCUPS::EnumeratePrinters(PrinterList* printer_list) {
   DCHECK(printer_list);
@@ skipping 105 matching lines @@
 
 bool PrintBackendCUPS::IsValidPrinter(const std::string& printer_name) {
   cups_dest_t* dest = GetNamedDest(printer_name);
   if (!dest)
     return false;
 
   cupsFreeDests(1, dest);
   return true;
 }
 
+#if !defined(OS_CHROMEOS)
 scoped_refptr<PrintBackend> PrintBackend::CreateInstance(
     const base::DictionaryValue* print_backend_settings) {
   std::string print_server_url_str, cups_blocking;
   int encryption = HTTP_ENCRYPT_NEVER;
   if (print_backend_settings) {
     print_backend_settings->GetString(kCUPSPrintServerURL,
                                       &print_server_url_str);
 
     print_backend_settings->GetString(kCUPSBlocking,
                                       &cups_blocking);
 
     print_backend_settings->GetInteger(kCUPSEncryption, &encryption);
   }
   GURL print_server_url(print_server_url_str.c_str());
   return new PrintBackendCUPS(print_server_url,
                               static_cast<http_encryption_t>(encryption),
                               cups_blocking == kValueTrue);
 }
+#endif  // !defined(OS_CHROMEOS)
 
 int PrintBackendCUPS::GetDests(cups_dest_t** dests) {
   if (print_server_url_.is_empty()) {  // Use default (local) print server.
     // GnuTLS has a genuine small memory leak that is easier to annotate
     // than suppress. See http://crbug.com/176888#c7
     // In theory any CUPS function can trigger this leak, but in
     // PrintBackendCUPS, this is the most likely spot.
     // TODO(eugenis): remove this once the leak is fixed.
     ANNOTATE_SCOPED_MEMORY_LEAK;
     return cupsGetDests(dests);
@@ skipping 57 matching lines @@
   // Use default (local) print server.
   if (print_server_url_.is_empty())
     return cupsGetNamedDest(CUPS_HTTP_DEFAULT, printer_name.c_str(), nullptr);
 
   HttpConnectionCUPS http(print_server_url_, cups_encryption_);
   http.SetBlocking(blocking_);
   return cupsGetNamedDest(http.http(), printer_name.c_str(), nullptr);
 }
 
 }  // namespace printing