[net/dns] Perform A/AAAA queries for AF_UNSPEC resolutions in parallel.

net/dns/dns_test_util.cc

 // 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.
 
 #include "net/dns/dns_test_util.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sys_byteorder.h"
 #include "net/base/big_endian.h"
 #include "net/base/dns_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/dns/address_sorter.h"
-#include "net/dns/dns_client.h"
-#include "net/dns/dns_config_service.h"
-#include "net/dns/dns_protocol.h"
 #include "net/dns/dns_query.h"
 #include "net/dns/dns_response.h"
 #include "net/dns/dns_transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
 // A DnsTransaction which uses MockDnsClientRuleList to determine the response.
 class MockTransaction : public DnsTransaction,
                         public base::SupportsWeakPtr<MockTransaction> {
  public:
   MockTransaction(const MockDnsClientRuleList& rules,
                   const std::string& hostname,
                   uint16 qtype,
                   const DnsTransactionFactory::CallbackType& callback)
       : result_(MockDnsClientRule::FAIL),
         hostname_(hostname),
         qtype_(qtype),
         callback_(callback),
-        started_(false) {
+        started_(false),
+        delayed_(false) {
     // Find the relevant rule which matches |qtype| and prefix of |hostname|.
     for (size_t i = 0; i < rules.size(); ++i) {
       const std::string& prefix = rules[i].prefix;
       if ((rules[i].qtype == qtype) &&
           (hostname.size() >= prefix.size()) &&
           (hostname.compare(0, prefix.size(), prefix) == 0)) {
         result_ = rules[i].result;
+        delayed_ = rules[i].delay;
         break;
       }
     }
   }
 
   virtual const std::string& GetHostname() const OVERRIDE {
     return hostname_;
   }
 
   virtual uint16 GetType() const OVERRIDE {
     return qtype_;
   }
 
   virtual void Start() OVERRIDE {
     EXPECT_FALSE(started_);
     started_ = true;
-    // Using WeakPtr to cleanly cancel when transaction is destroyed.
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&MockTransaction::Finish, AsWeakPtr()));
+    if (!delayed_) {
+      // Using WeakPtr to cleanly cancel when transaction is destroyed.
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(&MockTransaction::Finish, AsWeakPtr()));
+    }
   }
 
+  void FinishDelayedTransaction() {
+    EXPECT_TRUE(delayed_);
+    delayed_ = false;
+    Finish();
+  }
+
+  bool delayed() const { return delayed_; }
+
  private:
   void Finish() {
     switch (result_) {
       case MockDnsClientRule::EMPTY:
       case MockDnsClientRule::OK: {
         std::string qname;
         DNSDomainFromDot(hostname_, &qname);
         DnsQuery query(0, qname, qtype_);
 
         DnsResponse response;
@@ skipping 49 matching lines @@
         NOTREACHED();
         break;
     }
   }
 
   MockDnsClientRule::Result result_;
   const std::string hostname_;
   const uint16 qtype_;
   DnsTransactionFactory::CallbackType callback_;
   bool started_;
+  bool delayed_;
 };
 
+class MockAddressSorter : public AddressSorter {
+ public:
+  virtual ~MockAddressSorter() {}
+  virtual void Sort(const AddressList& list,
+                    const CallbackType& callback) const OVERRIDE {
+    // Do nothing.
+    callback.Run(true, list);
+  }
+};
+
+}  // namespace
 
 // A DnsTransactionFactory which creates MockTransaction.
 class MockTransactionFactory : public DnsTransactionFactory {
  public:
   explicit MockTransactionFactory(const MockDnsClientRuleList& rules)
       : rules_(rules) {}
+
   virtual ~MockTransactionFactory() {}
 
   virtual scoped_ptr<DnsTransaction> CreateTransaction(
       const std::string& hostname,
       uint16 qtype,
       const DnsTransactionFactory::CallbackType& callback,
       const BoundNetLog&) OVERRIDE {
-    return scoped_ptr<DnsTransaction>(
-        new MockTransaction(rules_, hostname, qtype, callback));
+    MockTransaction* transaction =
+        new MockTransaction(rules_, hostname, qtype, callback);
+    if (transaction->delayed())
+      delayed_transactions_.push_back(transaction->AsWeakPtr());
+    return scoped_ptr<DnsTransaction>(transaction);
+  }
+
+  void CompleteDelayedTransactions() {
+    DelayedTransactionList old_delayed_transactions;
+    old_delayed_transactions.swap(delayed_transactions_);
+    for (DelayedTransactionList::iterator it = old_delayed_transactions.begin();
+         it != old_delayed_transactions.end(); ++it) {
+      if (it->get())
+        (*it)->FinishDelayedTransaction();
+    }
   }
 
  private:
+  typedef std::vector<base::WeakPtr<MockTransaction> > DelayedTransactionList;
+
   MockDnsClientRuleList rules_;
+  DelayedTransactionList delayed_transactions_;
 };
 
-class MockAddressSorter : public AddressSorter {
- public:
-  virtual ~MockAddressSorter() {}
-  virtual void Sort(const AddressList& list,
-                    const CallbackType& callback) const OVERRIDE {
-    // Do nothing.
-    callback.Run(true, list);
-  }
-};
+MockDnsClient::MockDnsClient(const DnsConfig& config,
+                             const MockDnsClientRuleList& rules)
+      : config_(config),
+        factory_(new MockTransactionFactory(rules)),
+        address_sorter_(new MockAddressSorter()) {
+}
 
-// MockDnsClient provides MockTransactionFactory.
-class MockDnsClient : public DnsClient {
- public:
-  MockDnsClient(const DnsConfig& config,
-                const MockDnsClientRuleList& rules)
-      : config_(config), factory_(rules) {}
-  virtual ~MockDnsClient() {}
+MockDnsClient::~MockDnsClient() {}
 
-  virtual void SetConfig(const DnsConfig& config) OVERRIDE {
-    config_ = config;
-  }
+void MockDnsClient::SetConfig(const DnsConfig& config) {
+  config_ = config;
+}
 
-  virtual const DnsConfig* GetConfig() const OVERRIDE {
-    return config_.IsValid() ? &config_ : NULL;
-  }
+const DnsConfig* MockDnsClient::GetConfig() const {
+  return config_.IsValid() ? &config_ : NULL;
+}
 
-  virtual DnsTransactionFactory* GetTransactionFactory() OVERRIDE {
-    return config_.IsValid() ? &factory_ : NULL;
-  }
+DnsTransactionFactory* MockDnsClient::GetTransactionFactory() {
+  return config_.IsValid() ? factory_.get() : NULL;
+}
 
-  virtual AddressSorter* GetAddressSorter() OVERRIDE {
-    return &address_sorter_;
-  }
+AddressSorter* MockDnsClient::GetAddressSorter() {
+  return address_sorter_.get();
+}
 
- private:
-  DnsConfig config_;
-  MockTransactionFactory factory_;
-  MockAddressSorter address_sorter_;
-};
-
-}  // namespace
-
-// static
-scoped_ptr<DnsClient> CreateMockDnsClient(const DnsConfig& config,
-                                          const MockDnsClientRuleList& rules) {
-  return scoped_ptr<DnsClient>(new MockDnsClient(config, rules));
+void MockDnsClient::CompleteDelayedTransactions() {
+  factory_->CompleteDelayedTransactions();
 }
 
 }  // namespace net