Isolates generic DnsClient from AsyncHostResolver.

net/dns/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_DNS_ASYNC_HOST_RESOLVER_H_
 #define NET_DNS_ASYNC_HOST_RESOLVER_H_
 #pragma once
 
 #include <list>
 #include <map>
+#include <string>
+#include <utility>
 
 #include "base/threading/non_thread_safe.h"
 #include "net/base/address_family.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"
-#include "net/dns/dns_transaction.h"
+#include "net/dns/dns_client.h"
 
 namespace net {
 
-class ClientSocketFactory;
-
 class NET_EXPORT AsyncHostResolver
     : public HostResolver,
-      public DnsTransaction::Delegate,
       NON_EXPORTED_BASE(public base::NonThreadSafe) {
  public:
-  AsyncHostResolver(const IPEndPoint& dns_server,
-                    size_t max_transactions,
+  AsyncHostResolver(size_t max_transactions,
                     size_t max_pending_requests_,

[mmenke, 2011/12/02 00:53:55]

Know this was already here, but while you're modifying this file anyways, could
you please remove the ending underscore?  Thanks.

[szym, 2011/12/05 23:06:28]

Done.

-                    const RandIntCallback& rand_int,
                     HostCache* cache,
-                    ClientSocketFactory* factory,
+                    DnsClient* client,
                     NetLog* net_log);
   virtual ~AsyncHostResolver();
 
   // HostResolver interface
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
                       const BoundNetLog& source_net_log) OVERRIDE;
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
                                const BoundNetLog& source_net_log) OVERRIDE;
   virtual void CancelRequest(RequestHandle req_handle) OVERRIDE;
   virtual void SetDefaultAddressFamily(AddressFamily address_family) OVERRIDE;
   virtual AddressFamily GetDefaultAddressFamily() const OVERRIDE;
   virtual HostCache* GetHostCache() OVERRIDE;
 
-  // DnsTransaction::Delegate interface
-  virtual void OnTransactionComplete(
-      int result,
-      const DnsTransaction* transaction,
-      const IPAddressList& ip_addresses) OVERRIDE;
+  virtual void OnRequestComplete(DnsClient::Request* request,
+                                 int result,
+                                 const DnsResponse* transaction);

[mmenke, 2011/12/02 00:53:55]

OVERRIDE

[szym, 2011/12/05 23:06:28]

DnsTransaction no longer defines a Delegate interface. This is just a
base::Callback, so no OVERRIDE.

[mmenke, 2011/12/06 18:08:39]

Ah, right.  Don't think it needs to be virtual, either, then, as nothing
inherits from AsyncHostResolver.

 
  private:
   FRIEND_TEST_ALL_PREFIXES(AsyncHostResolverTest, QueuedLookup);
   FRIEND_TEST_ALL_PREFIXES(AsyncHostResolverTest, CancelPendingLookup);
   FRIEND_TEST_ALL_PREFIXES(AsyncHostResolverTest,
                            ResolverDestructionCancelsLookups);
   FRIEND_TEST_ALL_PREFIXES(AsyncHostResolverTest,
                            OverflowQueueWithLowPriorityLookup);
   FRIEND_TEST_ALL_PREFIXES(AsyncHostResolverTest,
                            OverflowQueueWithHighPriorityLookup);
 
   class Request;
 
-  typedef DnsTransaction::Key Key;
+  typedef std::pair<std::string, uint16> Key;
   typedef std::list<Request*> RequestList;
-  typedef std::list<const DnsTransaction*> TransactionList;
+  typedef std::list<const DnsClient::Request*> TransactionList;
   typedef std::map<Key, RequestList> KeyRequestListMap;
 
   // Create a new request for the incoming Resolve() call.
   Request* CreateNewRequest(const RequestInfo& info,
                             const CompletionCallback& callback,
                             AddressList* addresses,
                             const BoundNetLog& source_net_log);
 
   // Called when a request has just been started.
   void OnStart(Request* request);
@@ skipping 27 matching lines @@
   Request* RemoveHighest();
 
   // Once a transaction has completed, called to start a new transaction if
   // there are pending requests.
   void ProcessPending();
 
   // Maximum number of concurrent transactions.
   size_t max_transactions_;
 
   // List of current transactions.
-  TransactionList transactions_;
+  TransactionList dns_requests_;

[mmenke, 2011/12/02 00:53:55]

I think overload requests to both mean requests to the AsyncHostResolver and
requests to the DnsClient is a bit confusing.  You might want to either find
another name for one or the other, or add an adjective or something.

Maybe dns_client_requests_?  I though transactions_ was ok, too, though if you
feel that name is inaccurate, you should probably rename TransactionList as
well.

 
   // A map from Key to a list of requests waiting for the Key to resolve.
   KeyRequestListMap requestlist_map_;
 
   // Maximum number of pending requests.
   size_t max_pending_requests_;
 
   // 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_;
+  DnsClient* client_;
 
   NetLog* net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncHostResolver);
 };
 
 }  // namespace net
 
 #endif  // NET_DNS_ASYNC_HOST_RESOLVER_H_