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

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 manages asynchronous resolution of DNS hostnames.
 // 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
 // cause the underlying DNS structure to lookup a hostname before
@@ skipping 15 matching lines @@
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
 namespace chrome_browser_net {
 
 typedef chrome_common_net::NameList NameList;
 typedef std::map<std::string, DnsHostInfo> Results;
 
 class DnsMaster {
  public:
   // Specify how many concurrent (paralell) prefetches will be performed.
-  explicit DnsMaster(size_t max_concurrent);
+  DnsMaster(size_t max_concurrent);
   ~DnsMaster();
 
   // Cancel pending requests and prevent new ones from being made.
   void Shutdown();
 
   // In some circumstances, for privacy reasons, all results should be
   // discarded.  This method gracefully handles that activity.
   // Destroy all our internal state, which shows what names we've looked up, and
   // how long each has taken, etc. etc.  We also destroy records of suggesses
   // (cache hits etc.).
@@ skipping 39 matching lines @@
   // list, as constructed by SerializeReferrers(), and add all the identified
   // values into the current referrer list.
   void DeserializeReferrers(const ListValue& referral_list);
 
  private:
   FRIEND_TEST(DnsMasterTest, BenefitLookupTest);
   FRIEND_TEST(DnsMasterTest, ShutdownWhenResolutionIsPendingTest);
   FRIEND_TEST(DnsMasterTest, SingleLookupTest);
   FRIEND_TEST(DnsMasterTest, ConcurrentLookupTest);
   FRIEND_TEST(DnsMasterTest, MassiveConcurrentLookupTest);
-  FRIEND_TEST(DnsMasterTest, PriorityQueuePushPopTest);
-  FRIEND_TEST(DnsMasterTest, PriorityQueueReorderTest);
   friend class WaitForResolutionHelper;  // For testing.
 
   class LookupRequest;
 
-  // A simple priority queue for handling host names.
-  // Some names that are queued up have |motivation| that requires very rapid
-  // handling.  For example, a sub-resource name lookup MUST be done before the
-  // actual sub-resource is fetched.  In contrast, a name that was speculatively
-  // noted in a page has to be resolved before the user "gets around to"
-  // clicking on a link.  By tagging (with a motivation) each push we make into
-  // this FIFO queue, the queue can re-order the more important names to service
-  // them sooner (relative to some low priority background resolutions).
-  class HostNameQueue {
-   public:
-    HostNameQueue();
-    ~HostNameQueue();
-    void Push(const std::string& hostname,
-              DnsHostInfo::ResolutionMotivation motivation);
-    bool IsEmpty() const;
-    std::string Pop();
-
-  private:
-    // The names in the queue that should be serviced (popped) ASAP.
-    std::queue<std::string> rush_queue_;
-    // The names in the queue that should only be serviced when rush_queue is
-    // empty.
-    std::queue<std::string> background_queue_;
-
-  DISALLOW_COPY_AND_ASSIGN(HostNameQueue);
-  };
-
   // A map that is keyed with the hostnames that we've learned were the cause
   // of loading additional hostnames.  The list of additional hostnames in held
   // in a Referrer instance, which is found in this type.
   typedef std::map<std::string, Referrer> Referrers;
 
   // Only for testing. Returns true if hostname has been successfully resolved
   // (name found).
   bool WasFound(const std::string& hostname) {
     AutoLock auto_lock(lock_);
     return (results_.find(hostname) != results_.end()) &&
@@ skipping 16 matching lines @@
   void OnLookupFinished(LookupRequest* request,
                         const std::string& hostname, bool found);
 
   // "PreLocked" means that the caller has already Acquired lock_ in the
   // following method names.
   // Queue hostname for resolution.  If queueing was done, return the pointer
   // to the queued instance, otherwise return NULL.
   DnsHostInfo* PreLockedResolve(const std::string& hostname,
                                 DnsHostInfo::ResolutionMotivation motivation);
 
-  // Check to see if too much queuing delay has been noted for the given info,
-  // which indicates that there is "congestion" or growing delay in handling the
-  // resolution of names.  Rather than letting this congestion potentially grow
-  // without bounds, we abandon our queued efforts at pre-resolutions in such a
-  // case.
-  // To do this, we will recycle |info|, as well as all queued items, back to
-  // the state they had before they were queued up.  We can't do anything about
-  // the resolutions we've already sent off for processing on another thread, so
-  // we just let them complete.  On a slow system, subject to congestion, this
-  // will greatly reduce the number of resolutions done, but it will assure that
-  // any resolutions that are done, are in a timely and hence potentially
-  // helpful manner.
-  bool PreLockedCongestionControlPerformed(DnsHostInfo* info);
-
-  // Take lookup requests from work_queue_ and tell HostResolver to look them up
-  // asynchronously, provided we don't exceed concurrent resolution limit.
+  // Take lookup requests from name_buffer_ and tell HostResolver
+  // to look them up asynchronously, provided we don't exceed
+  // concurrent resolution limit.
   void PreLockedScheduleLookups();
 
   // Synchronize access to variables listed below.
   Lock lock_;
 
-  // work_queue_ holds a list of names we need to look up.
-  HostNameQueue work_queue_;
+  // name_buffer_ holds a list of names we need to look up.
+  std::queue<std::string> name_buffer_;
 
   // results_ contains information for existing/prior prefetches.
   Results results_;
 
   // 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_;
 
   std::set<LookupRequest*> pending_lookups_;
@@ skipping 12 matching lines @@
 
   // The number of concurrent lookups currently allowed.
   const size_t max_concurrent_lookups_;
 
   DISALLOW_COPY_AND_ASSIGN(DnsMaster);
 };
 
 }  // namespace chrome_browser_net
 
 #endif  // CHROME_BROWSER_NET_DNS_MASTER_H_