Move Time, TimeDelta and TimeTicks into namespace base.

chrome/browser/net/dns_host_info.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.
 
 // A DnsHostInfo object is used to store status of a Dns lookup of a specific
 // hostname.
 // It includes progress, from placement in the DnsMaster's queue, to assignment
 // to a slave, to resolution by the (blocking) DNS service as either FOUND or
 // NO_SUCH_NAME.
 
@@ skipping 26 matching lines @@
       PENDING,       // Constructor has completed.
       QUEUED,        // In prefetch queue but not yet assigned to a slave.
       ASSIGNED,      // Currently being processed by a slave.
       ASSIGNED_BUT_MARKED,  // Needs to be deleted as soon as slave is done.
       FOUND,         // DNS prefetch search completed.
       NO_SUCH_NAME,  // DNS prefetch search completed.
       // When processed by the HTTP network stack, there are 3 states:
       STARTED,               // Resolution has begun.
       FINISHED,              // Resolution has completed.
       FINISHED_UNRESOLVED};  // No resolution found.
-  static const TimeDelta kMaxNonNetworkDnsLookupDuration;
+  static const base::TimeDelta kMaxNonNetworkDnsLookupDuration;
   // The number of OS cache entries we can guarantee(?) before cache eviction
   // might likely take place.
   static const int kMaxGuaranteedCacheSize = 50;
 
   typedef std::vector<DnsHostInfo> DnsInfoTable;
 
-  static const TimeDelta kNullDuration;
+  static const base::TimeDelta kNullDuration;
 
   // DnsHostInfo are usually made by the default constructor during
   // initializing of the DnsMaster's map (of info for Hostnames).
   DnsHostInfo()
       : state_(PENDING),
         resolve_duration_(kNullDuration),
         queue_duration_(kNullDuration),
         benefits_remaining_(),
         sequence_number_(0) {
   }
 
   ~DnsHostInfo() {}
 
   // NeedDnsUpdate decides, based on our internal info,
   // if it would be valuable to attempt to update (prefectch)
   // DNS data for hostname.  This decision is based
   // on how recently we've done DNS prefetching for hostname.
   bool NeedsDnsUpdate(const std::string& hostname);
 
-  static void set_cache_expiration(TimeDelta time);
+  static void set_cache_expiration(base::TimeDelta time);
 
   // The prefetching lifecycle.
   void SetQueuedState();
   void SetAssignedState();
   void SetPendingDeleteState();
   void SetFoundState();
   void SetNoSuchNameState();
   // The actual browsing resolution lifecycle.
   void SetStartedState();
   void SetFinishedState(bool was_resolved);
@@ skipping 10 matching lines @@
   bool is_assigned() const {
     return ASSIGNED == state_ || ASSIGNED_BUT_MARKED == state_;
   }
   bool is_marked_to_delete() const { return ASSIGNED_BUT_MARKED == state_; }
   const std::string hostname() const { return hostname_; }
 
   bool HasHostname(const std::string& hostname) const {
     return (hostname == hostname_);
   }
 
-  TimeDelta resolve_duration() const { return resolve_duration_;}
-  TimeDelta queue_duration() const { return queue_duration_;}
-  TimeDelta benefits_remaining() const { return benefits_remaining_; }
+  base::TimeDelta resolve_duration() const { return resolve_duration_;}
+  base::TimeDelta queue_duration() const { return queue_duration_;}
+  base::TimeDelta benefits_remaining() const { return benefits_remaining_; }
 
   DnsBenefit AcruePrefetchBenefits(DnsHostInfo* later_host_info);
 
   void DLogResultsStats(const char* message) const;
 
   static void GetHtmlTable(const DnsInfoTable host_infos,
                            const char* description,
                            const bool brief,
                            std::string* output);
 
  private:
   // The next declaration is non-const to facilitate testing.
-  static TimeDelta kCacheExpirationDuration;
+  static base::TimeDelta kCacheExpirationDuration;
 
   DnsProcessingState state_;
   std::string hostname_;  // Hostname for this info.
 
-  TimeTicks time_;  // When was last state changed (usually lookup completed).
-  TimeDelta resolve_duration_;  // Time needed for DNS to resolve.
-  TimeDelta queue_duration_;  // Time spent in queue.
-  TimeDelta benefits_remaining_;  // Unused potential benefits of a prefetch.
+  // When was last state changed (usually lookup completed).
+  base::TimeTicks time_;
+  // Time needed for DNS to resolve.
+  base::TimeDelta resolve_duration_;
+  // Time spent in queue.
+  base::TimeDelta queue_duration_;
+  // Unused potential benefits of a prefetch.
+  base::TimeDelta benefits_remaining_;
 
   int sequence_number_;  // Used to calculate potential of cache eviction.
   static int sequence_counter;  // Used to allocate sequence_number_'s.
 
-  TimeDelta GetDuration() {
-    TimeTicks old_time = time_;
-    time_ = TimeTicks::Now();
+  base::TimeDelta GetDuration() {
+    base::TimeTicks old_time = time_;
+    time_ = base::TimeTicks::Now();
     return time_ - old_time;
   }
 
   // IsStillCached() guesses if the DNS cache still has IP data.
   bool IsStillCached() const;
 
   // We put these objects into a std::map, and hence we
   // need some "evil" constructors.
   // DISALLOW_EVIL_CONSTRUCTORS(DnsHostInfo);
 };
 
 }  // namespace chrome_browser_net
 
 #endif  // CHROME_BROWSER_NET_DNS_HOST_INFO_H__
-