Revert 218616 "[net/dns] Perform A/AAAA queries for AF_UNSPEC re..."

trunk/src/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 {
 
-class MockAddressSorter : public AddressSorter {
- public:
-  virtual ~MockAddressSorter() {}
-  virtual void Sort(const AddressList& list,
-                    const CallbackType& callback) const OVERRIDE {
-    // Do nothing.
-    callback.Run(true, list);
-  }
-};
-
 // 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),
-        delayed_(false) {
+        started_(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;
-    if (delayed_)
-      return;
     // 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_;
 };
 
-}  // 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 {
-    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();
-    }
+    return scoped_ptr<DnsTransaction>(
+        new MockTransaction(rules_, hostname, qtype, callback));
   }
 
  private:
-  typedef std::vector<base::WeakPtr<MockTransaction> > DelayedTransactionList;
-
   MockDnsClientRuleList rules_;
-  DelayedTransactionList delayed_transactions_;
 };
 
-MockDnsClient::MockDnsClient(const DnsConfig& config,
-                             const MockDnsClientRuleList& rules)
-      : config_(config),
-        factory_(new MockTransactionFactory(rules)),
-        address_sorter_(new MockAddressSorter()) {
-}
+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() {}
+// MockDnsClient provides MockTransactionFactory.
+class MockDnsClient : public DnsClient {
+ public:
+  MockDnsClient(const DnsConfig& config,
+                const MockDnsClientRuleList& rules)
+      : config_(config), factory_(rules) {}
+  virtual ~MockDnsClient() {}
 
-void MockDnsClient::SetConfig(const DnsConfig& config) {
-  config_ = config;
-}
+  virtual void SetConfig(const DnsConfig& config) OVERRIDE {
+    config_ = config;
+  }
 
-const DnsConfig* MockDnsClient::GetConfig() const {
-  return config_.IsValid() ? &config_ : NULL;
-}
+  virtual const DnsConfig* GetConfig() const OVERRIDE {
+    return config_.IsValid() ? &config_ : NULL;
+  }
 
-DnsTransactionFactory* MockDnsClient::GetTransactionFactory() {
-  return config_.IsValid() ? factory_.get() : NULL;
-}
+  virtual DnsTransactionFactory* GetTransactionFactory() OVERRIDE {
+    return config_.IsValid() ? &factory_ : NULL;
+  }
 
-AddressSorter* MockDnsClient::GetAddressSorter() {
-  return address_sorter_.get();
-}
+  virtual AddressSorter* GetAddressSorter() OVERRIDE {
+    return &address_sorter_;
+  }
 
-void MockDnsClient::CompleteDelayedTransactions() {
-  factory_->CompleteDelayedTransactions();
+ 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));
 }
 
 }  // namespace net