Platform cleanup in chrome/browser/net.

chrome/browser/net/dns_master.cc

 // 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.
 
 // See header file for description of class
 
 #include "chrome/browser/net/dns_master.h"
 
 #include <sstream>
 
 #include "base/histogram.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "base/win_util.h"
 #include "chrome/browser/net/dns_slave.h"
 
 using base::TimeDelta;
 
 namespace chrome_browser_net {
 
 DnsMaster::DnsMaster(TimeDelta shutdown_wait_time)
-  : slave_count_(0),
+  : slaves_have_work_(&lock_),
+    slave_count_(0),
+    running_slave_count_(0),
     shutdown_(false),
-    running_slave_count_(0),
-    kShutdownWaitTime_(shutdown_wait_time),
-    slaves_have_work_(&lock_) {
-  for ( int i = 0; i < kSlaveCountMax; i++ ) {
+    kShutdownWaitTime_(shutdown_wait_time) {
+  for (size_t i = 0; i < kSlaveCountMax; i++) {
     thread_ids_[i] = 0;
     thread_handles_[i] = 0;
     slaves_[i] = NULL;
   }
 }
 
 // Overloaded Resolve() to take a vector of names.
 void DnsMaster::ResolveList(const NameList& hostnames,
                             DnsHostInfo::ResolutionMotivation motivation) {
   bool need_to_signal = false;
   {
     AutoLock auto_lock(lock_);
     if (shutdown_) return;
     if (slave_count_ < kSlaveCountMin) {
-      for (int target_count = std::min(static_cast<int>(hostnames.size()),
-                                       kSlaveCountMin);
+      for (int target_count = std::min(hostnames.size(), kSlaveCountMin);
            target_count > 0;
            target_count--)
         PreLockedCreateNewSlaveIfNeeded();
     } else {
       PreLockedCreateNewSlaveIfNeeded();  // Allocate one per list call.
     }
 
     for (NameList::const_iterator it = hostnames.begin();
       it < hostnames.end();
          it++) {
@@ skipping 52 matching lines @@
   }
 
   DnsBenefit benefit = prefetched_host_info.AccruePrefetchBenefits(
       navigation_info);
   switch (benefit) {
     case PREFETCH_NAME_FOUND:
     case PREFETCH_NAME_NONEXISTANT:
       // Remain under lock to push data.
       cache_hits_.push_back(*navigation_info);
       if (referrer_based_prefetch) {
-        std::string& motivating_referrer(
+        std::string motivating_referrer(
             prefetched_host_info.referring_hostname());
         if (!motivating_referrer.empty()) {
           referrers_[motivating_referrer].AccrueValue(
               navigation_info->benefits_remaining(), hostname);
         }
       }
       return true;
 
     case PREFETCH_CACHE_EVICTION:
       // Remain under lock to push data.
@@ skipping 35 matching lines @@
       if (queued_info) {
         need_to_signal = true;
         queued_info->SetReferringHostname(host_name);
       }
     }
   }
   if (need_to_signal)
     slaves_have_work_.Signal();
 }
 
-static char* PluralOptionalHostname(size_t count) {
-  if (count == 1)
-    return "hostname";
-  return "hostnames";
-}
-
 // Provide sort order so all .com's are together, etc.
 struct RightToLeftStringSorter {
   bool operator()(const std::string& left, const std::string& right) const {
     if (left == right) return true;
     size_t left_already_matched = left.size();
     size_t right_already_matched = right.size();
 
     // Ensure both strings have characters.
     if (!left_already_matched) return true;
     if (!right_already_matched) return false;
@@ skipping 214 matching lines @@
   AutoLock auto_lock(lock_);  // For map access (changing info values).
   DnsHostInfo* info = &results_[hostname];
   DCHECK(info->HasHostname(hostname));
   if (info->is_marked_to_delete())
     results_.erase(hostname);
   else
     info->SetNoSuchNameState();
 }
 
 bool DnsMaster::PreLockedCreateNewSlaveIfNeeded() {
-  // Don't create more then max.
+  // Don't create more than max.
   if (kSlaveCountMax <= slave_count_  || shutdown_)
     return false;
 
   DnsSlave* slave_instance = new DnsSlave(this, slave_count_);
   DWORD thread_id;
   size_t stack_size = 0;
   unsigned int flags = CREATE_SUSPENDED;
   if (win_util::GetWinVersion() >= win_util::WINVERSION_XP) {
     // 128kb stack size.
     stack_size = 128*1024;
@@ skipping 115 matching lines @@
   results_.clear();
   // Put back in the names being worked on by slaves.
   for (Results::iterator it = assignees.begin(); assignees.end() != it; ++it) {
     DCHECK(it->second.is_marked_to_delete());
     results_[it->first] = it->second;
   }
 }
 
 }  // namespace chrome_browser_net