AsyncHostResolver: integrated HostCache, temporarily, until we have RR cache.

net/base/async_host_resolver.h

 // Copyright (c) 2011 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.
 
 #ifndef NET_BASE_ASYNC_HOST_RESOLVER_H_
 #define NET_BASE_ASYNC_HOST_RESOLVER_H_
 #pragma once
 
 #include <list>
 #include <map>
 #include <vector>
 
 #include "base/observer_list.h"
 #include "base/threading/non_thread_safe.h"
 #include "net/base/address_family.h"
 #include "net/base/dns_transaction.h"
+#include "net/base/host_cache.h"
 #include "net/base/host_resolver.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_log.h"
 #include "net/base/rand_callback.h"
 
 namespace net {
 
 class AddressesList;
 class ClientSocketFactory;
 
 class NET_API AsyncHostResolver
     : public HostResolver,
       public DnsTransaction::Delegate,
       NON_EXPORTED_BASE(public base::NonThreadSafe) {
  public:
   AsyncHostResolver(const IPEndPoint& dns_server,
                     size_t max_transactions,
                     size_t max_pending_requests_,
                     const RandIntCallback& rand_int,
+                    HostCache* cache,
                     ClientSocketFactory* factory,
                     NetLog* net_log);
   virtual ~AsyncHostResolver();
 
   // HostResolver interface
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
                       CompletionCallback* callback,
                       RequestHandle* out_req,
                       const BoundNetLog& source_net_log) OVERRIDE;
@@ skipping 36 matching lines @@
 
   // Called when a request has just been started.
   void OnStart(Request* request);
 
   // Called when a request has just completed (before its callback is run).
   void OnFinish(Request* request, int result);
 
   // Called when a request has been cancelled.
   void OnCancel(Request* request);
 
+  // Tries to serve request from cache.
+  bool ServeFromCache(Request* request) const;
+
   // If there is an in-progress transaction for Request->key(), this will
   // attach |request| to the respective list.
   bool AttachToRequestList(Request* request);
 
   // Will start a new transaction for |request|, will insert a new key in
   // |requestlist_map_| and append |request| to the respective list.
   int StartNewTransactionFor(Request* request);
 
   // Will enqueue |request| in |pending_requests_|.
   int Enqueue(Request* request);
 
   // A helper used by Enqueue to insert |request| into |pending_requests_|.
   Request* Insert(Request* request);
 
   // Returns the number of pending requests.
-  size_t GetNumPending();
+  size_t GetNumPending() const;
 
   // Removes and returns a pointer to the lowest/highest priority request
   // from |pending_requests_|.
   Request* RemoveLowest();
   Request* RemoveHighest();
 
   // Once a transaction has completed, called to start a new transaction if
   // there are pending requests.
   void ProcessPending();
 
@@ skipping 11 matching lines @@
 
   // Queues based on priority for putting pending requests.
   RequestList pending_requests_[NUM_PRIORITIES];
 
   // DNS server to which queries will be setn.
   IPEndPoint dns_server_;
 
   // Callback to be passed to DnsTransaction for generating DNS query ids.
   RandIntCallback rand_int_cb_;
 
+  // Cache of host resolution results.
+  scoped_ptr<HostCache> cache_;
+
   // Also passed to DnsTransaction; it's a dependency injection to aid
   // testing, outside of unit tests, its value is always NULL.
   ClientSocketFactory* factory_;
 
   // The observers to notify when a request starts/ends.
   ObserverList<HostResolver::Observer> observers_;
 
   // Monotonically increasing ID number to assign to the next request.
   // Observers are the only consumers of this ID number.
   int next_request_id_;
 
   NetLog* net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncHostResolver);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_ASYNC_HOST_RESOLVER_H_