base::Bind: Convert chrome/service/cloud_print.

chrome/service/cloud_print/print_system_cups.cc

 // Copyright (c) 2011 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 60 matching lines @@
   // the number of requests.
   typedef std::map<std::string, printing::PrinterCapsAndDefaults> CapsMap;
   CapsMap caps_cache;
 };
 
 class PrintSystemCUPS : public PrintSystem {
  public:
   explicit PrintSystemCUPS(const DictionaryValue* print_system_settings);
 
   // PrintSystem implementation.
-  virtual PrintSystemResult Init();
-
+  virtual PrintSystemResult Init() OVERRIDE;
   virtual PrintSystem::PrintSystemResult EnumeratePrinters(
-      printing::PrinterList* printer_list);
-
+      printing::PrinterList* printer_list) OVERRIDE;
   virtual void GetPrinterCapsAndDefaults(
       const std::string& printer_name,
-      PrinterCapsAndDefaultsCallback* callback);
-
-  virtual bool IsValidPrinter(const std::string& printer_name);
-
-  virtual bool ValidatePrintTicket(const std::string& printer_name,
-                                   const std::string& print_ticket_data);
-
+      const PrinterCapsAndDefaultsCallback& callback) OVERRIDE;
+  virtual bool IsValidPrinter(const std::string& printer_name) OVERRIDE;
+  virtual bool ValidatePrintTicket(
+      const std::string& printer_name,
+      const std::string& print_ticket_data) OVERRIDE;
   virtual bool GetJobDetails(const std::string& printer_name,
                              PlatformJobId job_id,
-                             PrintJobDetails *job_details);
-
-  virtual PrintSystem::PrintServerWatcher* CreatePrintServerWatcher();
+                             PrintJobDetails *job_details) OVERRIDE;
+  virtual PrintSystem::PrintServerWatcher* CreatePrintServerWatcher() OVERRIDE;
   virtual PrintSystem::PrinterWatcher* CreatePrinterWatcher(
-      const std::string& printer_name);
-  virtual PrintSystem::JobSpooler* CreateJobSpooler();
-  virtual std::string GetSupportedMimeTypes();
+      const std::string& printer_name) OVERRIDE;
+  virtual PrintSystem::JobSpooler* CreateJobSpooler() OVERRIDE;
+  virtual std::string GetSupportedMimeTypes() OVERRIDE;
 
   // 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::vector<std::string>& tags,
                               bool* dry_run);
   bool GetPrinterInfo(const std::string& printer_name,
@@ skipping 33 matching lines @@
 
   // Full name contains print server url:port and printer name. Short name
   // is the name of the printer in the CUPS server.
   std::string MakeFullPrinterName(const GURL& url,
                                   const std::string& short_printer_name);
   PrintServerInfoCUPS* FindServerByFullName(
       const std::string& full_printer_name, std::string* short_printer_name);
 
   // Helper method to invoke a PrinterCapsAndDefaultsCallback.
   static void RunCapsCallback(
-      PrinterCapsAndDefaultsCallback* callback,
+      const PrinterCapsAndDefaultsCallback& callback,
       bool succeeded,
       const std::string& printer_name,
       const printing::PrinterCapsAndDefaults& printer_info);
 
   // PrintServerList contains information about all print servers and backends
   // this proxy is connected to.
   typedef std::list<PrintServerInfoCUPS> PrintServerList;
   PrintServerList print_servers_;
 
   int update_timeout_;
   bool initialized_;
   bool printer_enum_succeeded_;
   bool notify_delete_;
 };
 
 class PrintServerWatcherCUPS
   : public PrintSystem::PrintServerWatcher {
  public:
   explicit PrintServerWatcherCUPS(PrintSystemCUPS* print_system)
       : print_system_(print_system),
         delegate_(NULL) {
   }
   ~PrintServerWatcherCUPS() {
     StopWatching();
   }
 
-  // PrintSystem::PrintServerWatcher interface
+  // PrintSystem::PrintServerWatcher implementation.
   virtual bool StartWatching(
-      PrintSystem::PrintServerWatcher::Delegate* delegate) {
+      PrintSystem::PrintServerWatcher::Delegate* delegate) OVERRIDE {
     delegate_ = delegate;
     printers_hash_ = GetPrintersHash();
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrintServerWatcherCUPS::CheckForUpdates, this),
         print_system_->GetUpdateTimeoutMs());
     return true;
   }
-  virtual bool StopWatching() {
+
+  virtual bool StopWatching() OVERRIDE {
     delegate_ = NULL;
     return true;
   }
 
   void CheckForUpdates() {
     if (delegate_ == NULL)
       return;  // Orphan call. We have been stopped already.
     VLOG(1) << "CP_CUPS: Checking for new printers";
     std::string new_hash = GetPrintersHash();
     if (printers_hash_ != new_hash) {
       printers_hash_ = new_hash;
       delegate_->OnPrinterAdded();
     }
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrintServerWatcherCUPS::CheckForUpdates, this),
         print_system_->GetUpdateTimeoutMs());
   }
+
  private:
   std::string GetPrintersHash() {
     printing::PrinterList printer_list;
     print_system_->EnumeratePrinters(&printer_list);
 
     // Sort printer names.
     std::vector<std::string> printers;
     printing::PrinterList::iterator it;
     for (it = printer_list.begin(); it != printer_list.end(); ++it)
       printers.push_back(it->printer_name);
     std::sort(printers.begin(), printers.end());
 
     std::string to_hash;
     for (size_t i = 0; i < printers.size(); i++)
       to_hash += printers[i];
 
     return base::MD5String(to_hash);
   }
 
   scoped_refptr<PrintSystemCUPS> print_system_;
   PrintSystem::PrintServerWatcher::Delegate* delegate_;
   std::string printers_hash_;
+
   DISALLOW_COPY_AND_ASSIGN(PrintServerWatcherCUPS);
 };
 
 class PrinterWatcherCUPS
     : public PrintSystem::PrinterWatcher {
  public:
   PrinterWatcherCUPS(PrintSystemCUPS* print_system,
                      const std::string& printer_name)
       : printer_name_(printer_name),
     delegate_(NULL),
     print_system_(print_system) {
   }
+
   ~PrinterWatcherCUPS() {
     StopWatching();
   }
 
-  // PrintSystem::PrinterWatcher interface
+  // PrintSystem::PrinterWatcher implementation.
   virtual bool StartWatching(
-      PrintSystem::PrinterWatcher::Delegate* delegate) {
+      PrintSystem::PrinterWatcher::Delegate* delegate) OVERRIDE{
     if (delegate_ != NULL)
       StopWatching();
     delegate_ = delegate;
     settings_hash_ = GetSettingsHash();
     // Schedule next job status update.
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrinterWatcherCUPS::JobStatusUpdate, this),
         kJobUpdateTimeoutMs);
     // Schedule next printer check.
     // TODO(gene): Randomize time for the next printer update.
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrinterWatcherCUPS::PrinterUpdate, this),
         print_system_->GetUpdateTimeoutMs());
     return true;
   }
-  virtual bool StopWatching() {
+
+  virtual bool StopWatching() OVERRIDE{
     delegate_ = NULL;
     return true;
   }
+
   bool GetCurrentPrinterInfo(printing::PrinterBasicInfo* printer_info) {
     DCHECK(printer_info);
     return print_system_->GetPrinterInfo(printer_name_, printer_info);
   }
 
   void JobStatusUpdate() {
     if (delegate_ == NULL)
       return;  // Orphan call. We have been stopped already.
     // For CUPS proxy, we are going to fire OnJobChanged notification
     // periodically. Higher level will check if there are any outstanding
@@ skipping 20 matching lines @@
         settings_hash_ = new_hash;
         delegate_->OnPrinterChanged();
         VLOG(1) << "CP_CUPS: Printer update detected for: " << printer_name_;
       }
     }
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrinterWatcherCUPS::PrinterUpdate, this),
         print_system_->GetUpdateTimeoutMs());
   }
+
  private:
   std::string GetSettingsHash() {
     printing::PrinterBasicInfo info;
     if (!print_system_->GetPrinterInfo(printer_name_, &info))
       return std::string();
 
     printing::PrinterCapsAndDefaults caps;
     if (!print_system_->GetPrinterCapsAndDefaults(printer_name_, &caps))
       return std::string();
 
@@ skipping 10 matching lines @@
     to_hash += caps.printer_defaults;
     to_hash += caps.defaults_mime_type;
 
     return base::MD5String(to_hash);
   }
 
   std::string printer_name_;
   PrintSystem::PrinterWatcher::Delegate* delegate_;
   scoped_refptr<PrintSystemCUPS> print_system_;
   std::string settings_hash_;
+
   DISALLOW_COPY_AND_ASSIGN(PrinterWatcherCUPS);
 };
 
 class JobSpoolerCUPS : public PrintSystem::JobSpooler {
  public:
   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) {
+                     JobSpooler::Delegate* delegate) OVERRIDE{
     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, tags, &dry_run);
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&JobSpoolerCUPS::NotifyDelegate, delegate, job_id, dry_run));
     return true;
   }
 
   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)
     : update_timeout_(kCheckForPrinterUpdatesMs),
       initialized_(false),
       printer_enum_succeeded_(false),
       notify_delete_(true) {
   if (print_system_settings) {
     int timeout;
@@ skipping 83 matching lines @@
         it->printers.begin(), it->printers.end());
   }
   VLOG(1) << "CUPS: Total " << printer_list->size() << " printers enumerated.";
   // TODO(sanjeevr): Maybe some day we want to report the actual server names
   // for which the enumeration failed.
   return PrintSystemResult(printer_enum_succeeded_, std::string());
 }
 
 void PrintSystemCUPS::GetPrinterCapsAndDefaults(
     const std::string& printer_name,
-    PrinterCapsAndDefaultsCallback* callback) {
+    const PrinterCapsAndDefaultsCallback& callback) {
   printing::PrinterCapsAndDefaults printer_info;
   bool succeeded = GetPrinterCapsAndDefaults(printer_name, &printer_info);
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PrintSystemCUPS::RunCapsCallback, callback, succeeded,
                  printer_name, printer_info));
 }
 
 bool PrintSystemCUPS::IsValidPrinter(const std::string& printer_name) {
   return GetPrinterInfo(printer_name, NULL);
@@ skipping 306 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;
 }
 
 void PrintSystemCUPS::RunCapsCallback(
-    PrinterCapsAndDefaultsCallback* callback,
+    const PrinterCapsAndDefaultsCallback& callback,
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& printer_info) {
-  callback->Run(succeeded, printer_name, printer_info);
-  delete callback;
+  callback.Run(succeeded, printer_name, printer_info);
 }
 
 }  // namespace cloud_print