Switch to using TimeTicks rather than Time in message loops

remoting/jingle_glue/jingle_thread.cc

 // Copyright (c) 2010 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 "remoting/jingle_glue/jingle_thread.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_pump.h"
 #include "base/time.h"
 #include "third_party/libjingle/source/talk/base/ssladapter.h"
 
 namespace remoting {
 
 const uint32 kRunTasksMessageId = 1;
 const uint32 kStopMessageId = 2;
 
 class JingleThread::JingleMessagePump : public base::MessagePump,
                                         public talk_base::MessageHandler {
  public:
   JingleMessagePump(JingleThread* thread) : thread_(thread) { }
 
   virtual void Run(Delegate* delegate) { NOTIMPLEMENTED(); }
   virtual void Quit() { NOTIMPLEMENTED(); }
   virtual void ScheduleWork() {
     thread_->Post(this, kRunTasksMessageId);
   }
-  virtual void ScheduleDelayedWork(const base::Time& time) {
+  virtual void ScheduleDelayedWork(const base::TimeTicks& time) {
     delayed_work_time_ = time;
     ScheduleNextDelayedTask();
   }
 
   void OnMessage(talk_base::Message* msg) {
     DCHECK(msg->message_id == kRunTasksMessageId);
 
     // Clear currently pending messages in case there were delayed tasks.
     // Will schedule it again from ScheduleNextDelayedTask() if neccessary.
     thread_->Clear(this, kRunTasksMessageId);
@@ skipping 20 matching lines @@
 
     ScheduleNextDelayedTask();
   }
 
  private:
 
   void ScheduleNextDelayedTask() {
     DCHECK_EQ(thread_->message_loop(), MessageLoop::current());
 
     if (!delayed_work_time_.is_null()) {
-      base::Time now = base::Time::Now();
+      base::TimeTicks now = base::TimeTicks::Now();
       int delay = static_cast<int>((delayed_work_time_ - now).InMilliseconds());
       if (delay > 0) {
         thread_->PostDelayed(delay, this, kRunTasksMessageId);
       } else {
         thread_->Post(this, kRunTasksMessageId);
       }
     }
   }
 
   JingleThread* thread_;
-  base::Time delayed_work_time_;
+  base::TimeTicks delayed_work_time_;
 };
 
 class JingleThread::JingleMessageLoop : public MessageLoop {
  public:
   JingleMessageLoop(JingleThread* thread)
       : MessageLoop(MessageLoop::TYPE_IO) {
     pump_ = new JingleMessagePump(thread);
   }
 };
 
@@ skipping 69 matching lines @@
   // Stop the thread only if there are no more messages left in the queue,
   // otherwise post another task to try again later.
   if (msgq_.size() > 0 || fPeekKeep_) {
     Post(this, kStopMessageId);
   } else {
     MessageQueue::Quit();
   }
 }
 
 }  // namespace remoting