Move Time, TimeDelta and TimeTicks into namespace base.

chrome/browser/net/dns_master.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 DnsMaster object is instantiated once in the browser
 // process, and delivers DNS prefetch assignments (hostnames)
 // to any of several DnsSlave objects.
 // Most hostname lists are sent out by renderer processes, and
 // involve lists of hostnames that *might* be used in the near
 // future by the browsing user.  The goal of this class is to
@@ skipping 21 matching lines @@
 class DnsSlave;
 
 typedef chrome_common_net::NameList NameList;
 typedef std::map<std::string, DnsHostInfo> Results;
 
 class DnsMaster {
  public:
   // The number of slave processes that will do DNS prefetching
   static const int kSlaveCountMax = 8;
 
-  explicit DnsMaster(TimeDelta shutdown_wait_time);
+  explicit DnsMaster(base::TimeDelta shutdown_wait_time);
 
   ~DnsMaster() {
     if (!shutdown_)
       ShutdownSlaves();  // Ensure we did our cleanup.
   }
 
   // ShutdownSlaves() gets all spawned threads to terminate, closes
   // their handles, and deletes their DnsSlave instances.
   // Return value of true means all operations succeeded.
   // Return value of false means that the threads wouldn't terminate,
@@ skipping 22 matching lines @@
   // Currently testing only provides a crude measure of success.
   bool WasFound(const std::string& hostname) {
     AutoLock auto_lock(lock_);
     return (results_.find(hostname) != results_.end()) &&
             results_[hostname].was_found();
   }
 
   // Accessor methods, used mostly for testing.
   // Both functions return DnsHostInfo::kNullDuration if name was not yet
   // processed enough.
-  TimeDelta GetResolutionDuration(const std::string hostname) {
+  base::TimeDelta GetResolutionDuration(const std::string hostname) {
     AutoLock auto_lock(lock_);
     if (results_.find(hostname) == results_.end())
       return DnsHostInfo::kNullDuration;
     return results_[hostname].resolve_duration();
   }
 
-  TimeDelta GetQueueDuration(const std::string hostname) {
+  base::TimeDelta GetQueueDuration(const std::string hostname) {
     AutoLock auto_lock(lock_);
     if (results_.find(hostname) == results_.end())
       return DnsHostInfo::kNullDuration;
     return results_[hostname].queue_duration();
   }
 
   int running_slave_count() {
     AutoLock auto_lock(lock_);
     return running_slave_count_;
   }
@@ skipping 47 matching lines @@
   // slave_count_ grows (up to the indicated max).
   DWORD thread_ids_[kSlaveCountMax];
   HANDLE thread_handles_[kSlaveCountMax];
   DnsSlave* slaves_[kSlaveCountMax];
 
   // shutdown_ is set to tell the slaves to terminate.
   bool shutdown_;
 
   // The following is the maximum time the ShutdownSlaves method
   // will wait for all the slave processes to terminate.
-  const TimeDelta kShutdownWaitTime_;
+  const base::TimeDelta kShutdownWaitTime_;
 
   // A list of successful events resulting from pre-fetching.
   DnsHostInfo::DnsInfoTable cache_hits_;
   // A map of hosts that were evicted from our cache (after we prefetched them)
   // and before the HTTP stack tried to look them up.
   Results cache_eviction_map_;
 
   DISALLOW_EVIL_CONSTRUCTORS(DnsMaster);
 };
 
 }  // namespace chrome_browser_net
 
 #endif  // CHROME_BROWSER_NET_DNS_MASTER_H__