[net/dns] Reland of 218616 (Simultaneous A/AAAA queries).

net/dns/dns_test_util.h

 // Copyright (c) 2012 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_DNS_TEST_UTIL_H_
 #define NET_DNS_DNS_TEST_UTIL_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
+#include "net/dns/dns_client.h"
 #include "net/dns/dns_config_service.h"
 #include "net/dns/dns_protocol.h"
 
 namespace net {
 
 //-----------------------------------------------------------------------------
 // Query/response set for www.google.com, ID is fixed to 0.
 static const char kT0HostName[] = "www.google.com";
 static const uint16 kT0Qtype = dns_protocol::kTypeA;
 static const char kT0DnsName[] = {
@@ skipping 144 matching lines @@
 };
 static const char* const kT3IpAddresses[] = {
   "74.125.226.178", "74.125.226.179", "74.125.226.180",
   "74.125.226.176", "74.125.226.177"
 };
 static const char kT3CanonName[] = "www.l.google.com";
 static const int kT3TTL = 0x00000015;
 // +2 for the CNAME records, +1 for TXT record.
 static const unsigned kT3RecordCount = arraysize(kT3IpAddresses) + 3;
 
+class AddressSorter;
 class DnsClient;
+class MockTransactionFactory;
 
 struct MockDnsClientRule {
   enum Result {
     FAIL,     // Fail asynchronously with ERR_NAME_NOT_RESOLVED.
     TIMEOUT,  // Fail asynchronously with ERR_DNS_TIMEOUT.
     EMPTY,    // Return an empty response.
     OK,       // Return a response with loopback address.
   };
 
+  // If |delay| is true, matching transactions will be delayed until triggered
+  // by the consumer.
   MockDnsClientRule(const std::string& prefix_arg,
                     uint16 qtype_arg,
-                    Result result_arg)
-      : result(result_arg), prefix(prefix_arg), qtype(qtype_arg) { }
+                    Result result_arg,
+                    bool delay)
+      : result(result_arg), prefix(prefix_arg), qtype(qtype_arg),
+        delay(delay) {}
 
   Result result;
   std::string prefix;
   uint16 qtype;
+  bool delay;
 };
 
 typedef std::vector<MockDnsClientRule> MockDnsClientRuleList;
 
-// Creates mock DnsClient for testing HostResolverImpl.
-scoped_ptr<DnsClient> CreateMockDnsClient(const DnsConfig& config,
-                                          const MockDnsClientRuleList& rules);
+// MockDnsClient provides MockTransactionFactory.
+class MockDnsClient : public DnsClient {
+ public:
+  MockDnsClient(const DnsConfig& config, const MockDnsClientRuleList& rules);
+  virtual ~MockDnsClient();
+
+  // DnsClient interface:
+  virtual void SetConfig(const DnsConfig& config) OVERRIDE;
+  virtual const DnsConfig* GetConfig() const OVERRIDE;
+  virtual DnsTransactionFactory* GetTransactionFactory() OVERRIDE;
+  virtual AddressSorter* GetAddressSorter() OVERRIDE;
+
+  // Completes all DnsTransactions that were delayed by a rule.
+  void CompleteDelayedTransactions();
+
+ private:
+  DnsConfig config_;
+  scoped_ptr<MockTransactionFactory> factory_;
+  scoped_ptr<AddressSorter> address_sorter_;
+};
 
 }  // namespace net
 
 #endif  // NET_DNS_DNS_TEST_UTIL_H_