Convert use of int ms to TimeDelta in chrome/service files.

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 31 matching lines @@
 
 // Print system config options.
 const char kCUPSPrintServerURLs[] = "print_server_urls";
 const char kCUPSUpdateTimeoutMs[] = "update_timeout_ms";
 const char kCUPSNotifyDelete[] = "notify_delete";
 
 // Default port for IPP print servers.
 const int kDefaultIPPServerPort = 631;
 
 // Time interval to check for printer's updates.
-const int kCheckForPrinterUpdatesMs = 5*60*1000;
+const int kCheckForPrinterUpdatesMinutes = 5;
 
 // Job update timeout
-const int kJobUpdateTimeoutMs = 5000;
+const int kJobUpdateTimeoutSeconds = 5;
 
 // 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 {
 
 struct PrintServerInfoCUPS {
@@ skipping 42 matching lines @@
   bool GetPrinterInfo(const std::string& printer_name,
                       printing::PrinterBasicInfo* info);
   bool ParsePrintTicket(const std::string& print_ticket,
                         std::map<std::string, std::string>* options);
 
   // Synchronous version of GetPrinterCapsAndDefaults.
   bool GetPrinterCapsAndDefaults(
       const std::string& printer_name,
       printing::PrinterCapsAndDefaults* printer_info);
 
-  int GetUpdateTimeoutMs() const {
+  base::TimeDelta GetUpdateTimeout() const {
     return update_timeout_;
   }
 
   bool NotifyDelete() const {
     // Notify about deleted printers only when we
     // fetched printers list without errors.
     return notify_delete_ && printer_enum_succeeded_;
   }
 
  private:
@@ skipping 23 matching lines @@
       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_;
+  base::TimeDelta 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 implementation.
   virtual bool StartWatching(
       PrintSystem::PrintServerWatcher::Delegate* delegate) OVERRIDE {
     delegate_ = delegate;
     printers_hash_ = GetPrintersHash();
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&PrintServerWatcherCUPS::CheckForUpdates, this),
-        print_system_->GetUpdateTimeoutMs());
+        print_system_->GetUpdateTimeout());
     return true;
   }
 
   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());
+        print_system_->GetUpdateTimeout());
   }
 
  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 33 matching lines @@
   virtual bool StartWatching(
       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);
+        base::TimeDelta::FromSeconds(kJobUpdateTimeoutSeconds));
     // 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());
+        print_system_->GetUpdateTimeout());
     return true;
   }
 
   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
     // 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,
         base::Bind(&PrinterWatcherCUPS::JobStatusUpdate, this),
-        kJobUpdateTimeoutMs);
+        base::TimeDelta::FromSeconds(kJobUpdateTimeoutSeconds));
   }
 
   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,
         base::Bind(&PrinterWatcherCUPS::PrinterUpdate, this),
-        print_system_->GetUpdateTimeoutMs());
+        print_system_->GetUpdateTimeout());
   }
 
  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 57 matching lines @@
       delegate->OnJobSpoolFailed();
   }
 
  private:
   scoped_refptr<PrintSystemCUPS> print_system_;
 
   DISALLOW_COPY_AND_ASSIGN(JobSpoolerCUPS);
 };
 
 PrintSystemCUPS::PrintSystemCUPS(const DictionaryValue* print_system_settings)
-    : update_timeout_(kCheckForPrinterUpdatesMs),
+    : update_timeout_(base::TimeDelta::FromMinutes(
+        kCheckForPrinterUpdatesMinutes)),
       initialized_(false),
       printer_enum_succeeded_(false),
       notify_delete_(true) {
   if (print_system_settings) {
     int timeout;
     if (print_system_settings->GetInteger(kCUPSUpdateTimeoutMs, &timeout))
-      update_timeout_ = timeout;
+      update_timeout_ = base::TimeDelta::FromMilliseconds(timeout);
 
     bool notify_delete = true;
     if (print_system_settings->GetBoolean(kCUPSNotifyDelete, &notify_delete))
       notify_delete_ = notify_delete;
   }
 
   InitPrintBackends(print_system_settings);
 }
 
 void PrintSystemCUPS::InitPrintBackends(
@@ skipping 51 matching lines @@
       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,
-      base::Bind(&PrintSystemCUPS::UpdatePrinters, this), GetUpdateTimeoutMs());
+      base::Bind(&PrintSystemCUPS::UpdatePrinters, this), GetUpdateTimeout());
 }
 
 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());
@@ skipping 334 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