Move Time, TimeDelta and TimeTicks into namespace base.

base/timer.h

 // Copyright (c) 2006-2008 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.
 
 // OneShotTimer and RepeatingTimer provide a simple timer API.  As the names
 // suggest, OneShotTimer calls you back once after a time delay expires.
 // RepeatingTimer on the other hand calls you back periodically with the
 // prescribed time interval.
 //
 // OneShotTimer and RepeatingTimer both cancel the timer when they go out of
@@ skipping 50 matching lines @@
     OrphanDelayedTask();
   }
 
   // Returns true if the timer is running (i.e., not stopped).
   bool IsRunning() const {
     return delayed_task_ != NULL;
   }
 
   // Returns the current delay for this timer.  May only call this method when
   // the timer is running!
-  TimeDelta GetCurrentDelay() const {
+  base::TimeDelta GetCurrentDelay() const {
     DCHECK(IsRunning());
     return delayed_task_->delay_;
   }
 
  protected:
   BaseTimer_Helper() : delayed_task_(NULL) {}
 
   // We have access to the timer_ member so we can orphan this task.
   class TimerTask : public Task {
    public:
-    TimerTask(TimeDelta delay) : delay_(delay) {
+    TimerTask(base::TimeDelta delay) : delay_(delay) {
       // timer_ is set in InitiateDelayedTask.
     }
     BaseTimer_Helper* timer_;
-    TimeDelta delay_;
+    base::TimeDelta delay_;
   };
 
   // Used to orphan delayed_task_ so that when it runs it does nothing.
   void OrphanDelayedTask();
   
   // Used to initiated a new delayed task.  This has the side-effect of
   // orphaning delayed_task_ if it is non-null.
   void InitiateDelayedTask(TimerTask* timer_task);
 
   TimerTask* delayed_task_;
 
   DISALLOW_COPY_AND_ASSIGN(BaseTimer_Helper);
 };
 
 //-----------------------------------------------------------------------------
 // This class is an implementation detail of OneShotTimer and RepeatingTimer.
 // Please do not use this class directly.
 template <class Receiver, bool kIsRepeating>
 class BaseTimer : public BaseTimer_Helper {
  public:
   typedef void (Receiver::*ReceiverMethod)();
 
   // Call this method to start the timer.  It is an error to call this method
   // while the timer is already running.
-  void Start(TimeDelta delay, Receiver* receiver, ReceiverMethod method) {
+  void Start(base::TimeDelta delay, Receiver* receiver, ReceiverMethod method) {
     DCHECK(!IsRunning());
     InitiateDelayedTask(new TimerTask(delay, receiver, method));
   }
 
   // Call this method to stop the timer.  It is a no-op if the timer is not
   // running.
   void Stop() {
     OrphanDelayedTask();
   }
 
   // Call this method to reset the timer delay of an already running timer.
   void Reset() {
     DCHECK(IsRunning());
     InitiateDelayedTask(static_cast<TimerTask*>(delayed_task_)->Clone());
   }
 
  private:
   typedef BaseTimer<Receiver, kIsRepeating> SelfType;
   
   class TimerTask : public BaseTimer_Helper::TimerTask {
    public:
-    TimerTask(TimeDelta delay, Receiver* receiver, ReceiverMethod method)
+    TimerTask(base::TimeDelta delay, Receiver* receiver, ReceiverMethod method)
         : BaseTimer_Helper::TimerTask(delay),
           receiver_(receiver),
           method_(method) {
     }
     virtual void Run() {
       if (!timer_)  // timer_ is null if we were orphaned.
         return;
       SelfType* self = static_cast<SelfType*>(timer_);
       if (kIsRepeating) {
         self->Reset();
@@ skipping 17 matching lines @@
 class OneShotTimer : public BaseTimer<Receiver, false> {};
 
 //-----------------------------------------------------------------------------
 // A simple, repeating timer.  See usage notes at the top of the file.
 template <class Receiver>
 class RepeatingTimer : public BaseTimer<Receiver, true> {};
 
 }  // namespace base
 
 #endif  // BASE_TIMER_H_