Convert uses of int ms to TimeDelta in dbus.

dbus/bus.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.
 //
 // TODO(satorux):
 // - Handle "disconnected" signal.
 
 #include "dbus/bus.h"
 
 #include "base/bind.h"
@@ skipping 99 matching lines @@
   // Returns true if the timeout is ready to be monitored.
   bool IsReadyToBeMonitored() {
     return dbus_timeout_get_enabled(raw_timeout_);
   }
 
   // Starts monitoring the timeout.
   void StartMonitoring(dbus::Bus* bus) {
     bus->PostDelayedTaskToDBusThread(FROM_HERE,
                                      base::Bind(&Timeout::HandleTimeout,
                                                 this),
-                                     GetIntervalInMs());
+                                     GetInterval());
     monitoring_is_active_ = true;
   }
 
   // Stops monitoring the timeout.
   void StopMonitoring() {
     // We cannot take back the delayed task we posted in
     // StartMonitoring(), so we just mark the monitoring is inactive now.
     monitoring_is_active_ = false;
   }
 
-  // Returns the interval in milliseconds.
-  int GetIntervalInMs() {
-    return dbus_timeout_get_interval(raw_timeout_);
+  // Returns the interval.
+  base::TimeDelta GetInterval() {
+    return base::TimeDelta::FromMilliseconds(
+        dbus_timeout_get_interval(raw_timeout_));
   }
 
   // Cleans up the raw_timeout and marks that timeout is completed.
   // See the class comment above for why we are doing this.
   void Complete() {
     dbus_timeout_set_data(raw_timeout_, NULL, NULL);
     is_completed = true;
     Release();
   }
 
@@ skipping 460 matching lines @@
     DCHECK(origin_message_loop_proxy_.get());
     if (!origin_message_loop_proxy_->PostTask(from_here, task)) {
       LOG(WARNING) << "Failed to post a task to the origin message loop";
     }
   }
 }
 
 void Bus::PostDelayedTaskToDBusThread(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
-    int delay_ms) {
+    base::TimeDelta delay) {
   if (dbus_thread_message_loop_proxy_.get()) {
     if (!dbus_thread_message_loop_proxy_->PostDelayedTask(
-            from_here, task, delay_ms)) {
+            from_here, task, delay)) {
       LOG(WARNING) << "Failed to post a task to the D-Bus thread message loop";
     }
   } else {
     DCHECK(origin_message_loop_proxy_.get());
     if (!origin_message_loop_proxy_->PostDelayedTask(
-            from_here, task, delay_ms)) {
+            from_here, task, delay)) {
       LOG(WARNING) << "Failed to post a task to the origin message loop";
     }
   }
 }
 
 bool Bus::HasDBusThread() {
   return dbus_thread_message_loop_proxy_.get() != NULL;
 }
 
 void Bus::AssertOnOriginThread() {
@@ skipping 123 matching lines @@
 }
 
 void Bus::OnDispatchStatusChangedThunk(DBusConnection* connection,
                                        DBusDispatchStatus status,
                                        void* data) {
   Bus* self = static_cast<Bus*>(data);
   return self->OnDispatchStatusChanged(connection, status);
 }
 
 }  // namespace dbus