Create a new print backend for the updated CUPS APIs

printing/backend/cups_connection.cc

Index: printing/backend/cups_connection.cc
diff --git a/printing/backend/cups_connection.cc b/printing/backend/cups_connection.cc
new file mode 100644
index 0000000000000000000000000000000000000000..02751ebc5a7c8d9243fc1bc35437de0437e228ba
--- /dev/null
+++ b/printing/backend/cups_connection.cc
@@ -0,0 +1,163 @@
+// Copyright 2016 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/cups_connection.h"
+
+#include <string>
+
+#include "base/logging.h"
+#include "base/strings/stringprintf.h"
+
+namespace {
+
+static const int kTimeoutMs = 3000;
+
+class DestinationEnumerator {
+ public:
+  ~DestinationEnumerator() {
+    for (cups_dest_t* dest : dests_) {
+      cupsFreeDests(1, dest);

[Lei Zhang, 2016/07/13 01:08:42]

Can |dests_| be: std::vector<std::unique_ptr<cups_dest_t*, DestinationDeleter>>
? Then you can just clear |dests_| and be done... and that happens automatically
in the dtor when the enumerator gets destroyed.

[skau, 2016/07/14 20:43:05]

I didn't think of that.  Thanks!

+    }
+
+    dests_.clear();
+  }
+
+  static int cups_callback(void* user_data, unsigned flags, cups_dest_t* dest) {
+    cups_dest_t* copied_dest;
+    cupsCopyDest(dest, 0, &copied_dest);
+    reinterpret_cast<DestinationEnumerator*>(user_data)->store_dest(
+        copied_dest);
+
+    //  keep going
+    return 1;
+  }
+
+  void store_dest(cups_dest_t* dest) { dests_.push_back(dest); }
+
+  // Returns the collected destinations.  Remove desired destinations from the
+  // vector or they will be cleaned up when this object is destroyed.
+  std::vector<cups_dest_t*>& get_dests() { return dests_; }
+
+ private:
+  std::vector<cups_dest_t*> dests_;
+};
+
+}  // namespace
+
+namespace printing {
+
+void HttpDeleter::operator()(http_t* http) const {
+  httpClose(http);
+}
+
+CupsConnection::Impl::Impl(http_t* http)
+    : cups_http_(http), http_factory_(http) {}
+
+CupsConnection::Impl::~Impl() {
+  http_factory_.InvalidateWeakPtrs();
+}
+
+base::WeakPtr<http_t> CupsConnection::Impl::GetHttp() {
+  return http_factory_.GetWeakPtr();
+}
+
+CupsConnection::CupsConnection(const GURL& print_server_url,
+                               http_encryption_t encryption,
+                               bool blocking)
+    : print_server_url_(print_server_url),
+      cups_encryption_(encryption),
+      blocking_(blocking),
+      impl_(nullptr),
+      cups_http_(nullptr) {}
+
+CupsConnection::CupsConnection(CupsConnection&& connection)
+    : print_server_url_(connection.print_server_url_),
+      cups_encryption_(connection.cups_encryption_),
+      blocking_(connection.blocking_),
+      impl_(std::move(connection.impl_)),
+      cups_http_(std::move(connection.cups_http_)) {}
+
+CupsConnection::~CupsConnection() {}
+
+bool CupsConnection::Connect() {
+  if (cups_http_)
+    return true;  // we're already connected
+
+  std::string host_string;

[Lei Zhang, 2016/07/13 01:08:42]

Only used inside the if block below - move it there.

[skau, 2016/07/14 20:43:05]

I needed the c_str buffer to stay in scope.  I switched it to a string instead
since that should be more efficient than copying it.

+  const char* host;
+  int port;
+
+  if (!print_server_url_.is_empty()) {
+    host_string = print_server_url_.host();
+    host = host_string.c_str();
+    port = print_server_url_.IntPort();
+  } else {
+    host = cupsServer();
+    port = ippPort();
+  }
+
+  http_t* connection =
+      httpConnect2(host, port, NULL, AF_UNSPEC, cups_encryption_,

[Lei Zhang, 2016/07/13 01:08:42]

nullptr all around

[skau, 2016/07/14 20:43:05]

Done.

+                   blocking_ ? 1 : 0, kTimeoutMs, NULL);
+
+  if (!connection)
+    return false;
+
+  impl_ = std::unique_ptr<Impl>(new Impl(connection));

[Lei Zhang, 2016/07/13 01:08:42]

Use base::MakeUnique<Impl>(connection) ?

[skau, 2016/07/14 20:43:05]

Done.

+  cups_http_ = impl_->GetHttp();
+  return true;
+}
+
+std::vector<CupsPrinter> CupsConnection::GetDests() {
+  if (!Connect()) {
+    LOG(WARNING) << "CUPS connection failed";
+    return std::vector<CupsPrinter>();
+  }
+
+  DestinationEnumerator enumerator;
+  int success =
+      cupsEnumDests(CUPS_DEST_FLAGS_NONE, kTimeoutMs,
+                    NULL,                  // no cancel signal
+                    0,                     // all the printers
+                    CUPS_PRINTER_SCANNER,  // except the scanners
+                    &DestinationEnumerator::cups_callback, &enumerator);
+
+  if (!success) {
+    LOG(WARNING) << "Enumerating printers failed";
+    return std::vector<CupsPrinter>();
+  }
+
+  std::vector<CupsPrinter> printers;
+  std::vector<cups_dest_t*>& dests = enumerator.get_dests();
+  for (cups_dest_t* dest : dests) {
+    CupsPrinter printer(impl_->GetHttp(), dest, nullptr);
+    printers.push_back(std::move(printer));
+  }
+
+  dests.clear();  // CupsPrinter takes ownership of all the cups_dest_t objects
+
+  return printers;
+}
+
+CupsPrinter* CupsConnection::GetPrinter(const std::string& name) {
+  if (!Connect())
+    return nullptr;
+
+  cups_dest_t* dest = cupsGetNamedDest(cups_http_.get(), name.c_str(), NULL);
+  if (!dest)
+    return nullptr;
+
+  cups_dinfo_t* info = cupsCopyDestInfo(cups_http_.get(), dest);
+  return new CupsPrinter(impl_->GetHttp(), dest, info);
+}
+
+std::string CupsConnection::server_name() const {
+  return print_server_url_.host();
+}
+
+int CupsConnection::last_error() const {
+  return cupsLastError();
+}
+
+}  // namespace printing