base::Bind: Convert chrome/service.

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>
 
 #include <algorithm>
 #include <list>
 #include <map>
 
+#include "base/bind.h"
 #include "base/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/task.h"
@@ skipping 17 matching lines @@
 static const char kCUPSPrintServerURLs[] = "print_server_urls";
 static const char kCUPSUpdateTimeoutMs[] = "update_timeout_ms";
 static const char kCUPSNotifyDelete[] = "notify_delete";
 
 // Default port for IPP print servers.
 static const int kDefaultIPPServerPort = 631;
 
 // Time interval to check for printer's updates.
 const int kCheckForPrinterUpdatesMs = 5*60*1000;
 
-// Job update timeput
+// Job update timeout
 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 {
 
@@ skipping 114 matching lines @@
   }
   ~PrintServerWatcherCUPS() {
     StopWatching();
   }
 
   // PrintSystem::PrintServerWatcher interface
   virtual bool StartWatching(
       PrintSystem::PrintServerWatcher::Delegate* delegate) {
     delegate_ = delegate;
     printers_hash_ = GetPrintersHash();
-    MessageLoop::current()->PostDelayedTask(FROM_HERE,
-        NewRunnableMethod(this, &PrintServerWatcherCUPS::CheckForUpdates),
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&PrintServerWatcherCUPS::CheckForUpdates, this),
         print_system_->GetUpdateTimeoutMs());
     return true;
   }
   virtual bool StopWatching() {
     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,
-        NewRunnableMethod(this, &PrintServerWatcherCUPS::CheckForUpdates),
+    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;
@@ skipping 28 matching lines @@
   }
 
   // PrintSystem::PrinterWatcher interface
   virtual bool StartWatching(
       PrintSystem::PrinterWatcher::Delegate* delegate) {
     if (delegate_ != NULL)
       StopWatching();
     delegate_ = delegate;
     settings_hash_ = GetSettingsHash();
     // Schedule next job status update.
-    MessageLoop::current()->PostDelayedTask(FROM_HERE,
-        NewRunnableMethod(this, &PrinterWatcherCUPS::JobStatusUpdate),
+    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,
-        NewRunnableMethod(this, &PrinterWatcherCUPS::PrinterUpdate),
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&PrinterWatcherCUPS::PrinterUpdate, this),
         print_system_->GetUpdateTimeoutMs());
     return true;
   }
   virtual bool StopWatching() {
     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
     // jobs for this printer and check their status. If printer has no
     // outstanding jobs, OnJobChanged() will do nothing.
     delegate_->OnJobChanged();
-    MessageLoop::current()->PostDelayedTask(FROM_HERE,
-        NewRunnableMethod(this, &PrinterWatcherCUPS::JobStatusUpdate),
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&PrinterWatcherCUPS::JobStatusUpdate, this),
         kJobUpdateTimeoutMs);
   }
 
   void PrinterUpdate() {
     if (delegate_ == NULL)
       return;  // Orphan call. We have been stopped already.
     VLOG(1) << "CP_CUPS: Checking for printer updates: " << printer_name_;
     if (print_system_->NotifyDelete() &&
         !print_system_->IsValidPrinter(printer_name_)) {
       delegate_->OnPrinterDeleted();
       VLOG(1) << "CP_CUPS: Printer deleted: " << printer_name_;
     } else {
       std::string new_hash = GetSettingsHash();
       if (settings_hash_ != new_hash) {
         settings_hash_ = new_hash;
         delegate_->OnPrinterChanged();
         VLOG(1) << "CP_CUPS: Printer update detected for: " << printer_name_;
       }
     }
-    MessageLoop::current()->PostDelayedTask(FROM_HERE,
-        NewRunnableMethod(this, &PrinterWatcherCUPS::PrinterUpdate),
+    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))
@@ skipping 34 matching lines @@
                      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, tags, &dry_run);
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     NewRunnableFunction(
-                                         &JobSpoolerCUPS::NotifyDelegate,
-                                         delegate,
-                                         job_id,
-                                         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();
   }
@@ skipping 73 matching lines @@
     for (printer_it = it->printers.begin();
         printer_it != it->printers.end(); ++printer_it) {
       printer_it->printer_name = MakeFullPrinterName(it->url,
                                                      printer_it->printer_name);
     }
     VLOG(1) << "CUPS: Updated printer list for url: " << it->url
             << " Number of printers: " << it->printers.size();
   }
 
   // Schedule next update.
-  MessageLoop::current()->PostDelayedTask(FROM_HERE,
-      NewRunnableMethod(this, &PrintSystemCUPS::UpdatePrinters),
-      GetUpdateTimeoutMs());
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&PrintSystemCUPS::UpdatePrinters, this), GetUpdateTimeoutMs());
 }
 
 PrintSystem::PrintSystemResult PrintSystemCUPS::EnumeratePrinters(
     printing::PrinterList* printer_list) {
   DCHECK(initialized_);
   printer_list->clear();
   PrintServerList::iterator it;
   for (it = print_servers_.begin(); it != print_servers_.end(); ++it) {
     printer_list->insert(printer_list->end(),
         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) {
   printing::PrinterCapsAndDefaults printer_info;
   bool succeeded = GetPrinterCapsAndDefaults(printer_name, &printer_info);
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      NewRunnableFunction(&PrintSystemCUPS::RunCapsCallback,
-                          callback,
-                          succeeded,
-                          printer_name,
-                          printer_info));
+      base::Bind(&PrintSystemCUPS::RunCapsCallback, callback, succeeded,
+                 printer_name, printer_info));
 }
 
 bool PrintSystemCUPS::IsValidPrinter(const std::string& printer_name) {
   return GetPrinterInfo(printer_name, NULL);
 }
 
 bool PrintSystemCUPS::ValidatePrintTicket(const std::string& printer_name,
                                         const std::string& print_ticket_data) {
   DCHECK(initialized_);
   scoped_ptr<Value> ticket_value(base::JSONReader::Read(print_ticket_data,
@@ skipping 309 matching lines @@
 void PrintSystemCUPS::RunCapsCallback(
     PrinterCapsAndDefaultsCallback* callback,
     bool succeeded,
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& printer_info) {
   callback->Run(succeeded, printer_name, printer_info);
   delete callback;
 }
 
 }  // namespace cloud_print