Platform cleanup in chrome/browser/net.

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 20 matching lines @@
 namespace chrome_browser_net {
 
 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;
+  static const size_t kSlaveCountMax = 8;
 
   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.
@@ skipping 54 matching lines @@
     return results_[hostname].resolve_duration();
   }
 
   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() {
+  size_t running_slave_count() {
     AutoLock auto_lock(lock_);
     return running_slave_count_;
   }
 
   //----------------------------------------------------------------------------
   // Methods below this line should only be called by slave processes.
 
   // GetNextAssignment() gets the next hostname from queue for processing
   // It is not meant to be public, and should only be used by the slave.
   // GetNextAssignment() waits on a condition variable if there are no more
@@ skipping 37 matching lines @@
 
   // For each hostname that we might navigate to (that we've "learned about")
   // we have a Referrer list. Each Referrer list has all hostnames we need to
   // pre-resolve when there is a navigation to the orginial hostname.
   Referrers referrers_;
 
   // Signaling slaves to process elements in the queue, or to terminate,
   // is done using ConditionVariables.
   ConditionVariable slaves_have_work_;
 
-  int slave_count_;  // Count of slave processes started.
-  int running_slave_count_;  // Count of slaves process still running.
+  size_t slave_count_;  // Count of slave processes started.
+  size_t running_slave_count_;  // Count of slaves process still running.
 
   // The following arrays are only initialized as
   // 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 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_COPY_AND_ASSIGN(DnsMaster);
 };
 
 }  // namespace chrome_browser_net
 
 #endif  // CHROME_BROWSER_NET_DNS_MASTER_H_