Fix purify freeze. Revert "Use a priority queue to assure that subresources are resolved asap"

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.
 
 #include "chrome/browser/net/dns_master.h"
 
 #include <algorithm>
 #include <set>
 #include <sstream>
 
@@ skipping 342 matching lines @@
   // Currently we only add to the domain map :-/
 
   DCHECK(info->HasHostname(hostname));
 
   if (!info->NeedsDnsUpdate(hostname)) {
     info->DLogResultsStats("DNS PrefetchNotUpdated");
     return NULL;
   }
 
   info->SetQueuedState(motivation);
-  work_queue_.Push(hostname, motivation);
+  name_buffer_.push(hostname);
+
   PreLockedScheduleLookups();
+
   return info;
 }
 
 void DnsMaster::PreLockedScheduleLookups() {
-  while (!work_queue_.IsEmpty() &&
+  while (!name_buffer_.empty() &&
          pending_lookups_.size() < max_concurrent_lookups_) {
-    const std::string hostname(work_queue_.Pop());
+    const std::string hostname(name_buffer_.front());
+    name_buffer_.pop();
+
     DnsHostInfo* info = &results_[hostname];
     DCHECK(info->HasHostname(hostname));
     info->SetAssignedState();
 
-    if (PreLockedCongestionControlPerformed(info)) {
-      DCHECK(work_queue_.IsEmpty());
-      return;
-    }
-
     LookupRequest* request = new LookupRequest(this, hostname);
     if (request->Start()) {
       pending_lookups_.insert(request);
       peak_pending_lookups_ = std::max(peak_pending_lookups_,
                                        pending_lookups_.size());
     } else {
       NOTREACHED();
       delete request;
     }
   }
 }
 
-bool DnsMaster::PreLockedCongestionControlPerformed(DnsHostInfo* info) {
-  // Note: queue_duration is ONLY valid after we go to assigned state.
-  // TODO(jar): Tune selection of arbitrary 1 second constant.  Add plumbing so
-  // that this can be set as part of an A/B experiment.
-  if (info->queue_duration() < base::TimeDelta::FromSeconds(1))
-    return false;
-  // We need to discard all entries in our queue, as we're keeping them waiting
-  // too long.  By doing this, we'll have a chance to quickly service urgent
-  // resolutions, and not have a bogged down system.
-  while (true) {
-    info->RemoveFromQueue();
-    if (work_queue_.IsEmpty())
-      break;
-    info = &results_[work_queue_.Pop()];
-    info->SetAssignedState();
-  }
-  return true;
-}
-
 void DnsMaster::OnLookupFinished(LookupRequest* request,
                                  const std::string& hostname, bool found) {
   AutoLock auto_lock(lock_);  // For map access (changing info values).
   DnsHostInfo* info = &results_[hostname];
   DCHECK(info->HasHostname(hostname));
-  if (info->is_marked_to_delete()) {
+  if (info->is_marked_to_delete())
     results_.erase(hostname);
-  } else {
+  else {
     if (found)
       info->SetFoundState();
     else
       info->SetNoSuchNameState();
   }
 
   pending_lookups_.erase(request);
   delete request;
 
   PreLockedScheduleLookups();
 }
 
 void DnsMaster::DiscardAllResults() {
   AutoLock auto_lock(lock_);
   // Delete anything listed so far in this session that shows in about:dns.
   cache_eviction_map_.clear();
   cache_hits_.clear();
   referrers_.clear();
 
 
   // Try to delete anything in our work queue.
-  while (!work_queue_.IsEmpty()) {
+  while (!name_buffer_.empty()) {
     // Emulate processing cycle as though host was not found.
-    std::string hostname = work_queue_.Pop();
+    std::string hostname = name_buffer_.front();
+    name_buffer_.pop();
     DnsHostInfo* info = &results_[hostname];
     DCHECK(info->HasHostname(hostname));
     info->SetAssignedState();
     info->SetNoSuchNameState();
   }
   // Now every result_ is either resolved, or is being resolved
   // (see LookupRequest).
 
   // Step through result_, recording names of all hosts that can't be erased.
   // We can't erase anything being worked on.
@@ skipping 55 matching lines @@
       continue;
     Value* subresource_list;
     if (!motivating_host->Get(1, &subresource_list))
       continue;
     if (motivating_referrer.empty())
       continue;
     referrers_[motivating_referrer].Deserialize(*subresource_list);
   }
 }
 
-
-//------------------------------------------------------------------------------
-
-DnsMaster::HostNameQueue::HostNameQueue() {
-}
-
-DnsMaster::HostNameQueue::~HostNameQueue() {
-}
-
-void DnsMaster::HostNameQueue::Push(const std::string& hostname,
-    DnsHostInfo::ResolutionMotivation motivation) {
-  switch (motivation) {
-    case DnsHostInfo::STATIC_REFERAL_MOTIVATED:
-    case DnsHostInfo::LEARNED_REFERAL_MOTIVATED:
-    case DnsHostInfo::MOUSE_OVER_MOTIVATED:
-      rush_queue_.push(hostname);
-      break;
-
-    default:
-      background_queue_.push(hostname);
-      break;
-  }
-}
-
-bool DnsMaster::HostNameQueue::IsEmpty() const {
-  return rush_queue_.empty() && background_queue_.empty();
-}
-
-std::string DnsMaster::HostNameQueue::Pop() {
-  DCHECK(!IsEmpty());
-  if (!rush_queue_.empty()) {
-    std::string hostname(rush_queue_.front());
-    rush_queue_.pop();
-    return hostname;
-  }
-  std::string hostname(background_queue_.front());
-  background_queue_.pop();
-  return hostname;
-}
-
 }  // namespace chrome_browser_net