[net] HostResolverImpl + DnsTransaction + DnsConfigService = Asynchronous DNS ready for experiments.

net/dns/dns_transaction_unittest.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_transaction.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/rand_util.h"
@@ skipping 129 matching lines @@
     }
 
     if (expected_answer_count_ >= 0) {
       EXPECT_EQ(OK, rv);
       EXPECT_EQ(expected_answer_count_, response->answer_count());
       EXPECT_EQ(qtype_, response->qtype());
 
       DnsRecordParser parser = response->Parser();
       DnsResourceRecord record;
       for (int i = 0; i < expected_answer_count_; ++i) {
-        EXPECT_TRUE(parser.ParseRecord(&record));
+        EXPECT_TRUE(parser.ReadRecord(&record));
       }
       EXPECT_TRUE(parser.AtEnd());
     } else {
       EXPECT_EQ(expected_answer_count_, rv);
       EXPECT_EQ(NULL, response);
     }
 
     if (quit_in_callback_)
       MessageLoop::current()->Quit();
   }
@@ skipping 44 matching lines @@
     }
     for (unsigned i = 0; i < num_servers; ++i) {
       dns_ip[3] = i;
       config_.nameservers.push_back(IPEndPoint(dns_ip,
                                                dns_protocol::kDefaultPort));
     }
   }
 
   // Called after fully configuring |config|.
   void ConfigureFactory() {
-    socket_factory_ = new TestSocketFactory();
+    socket_factory_.reset(new TestSocketFactory());
     session_ = new DnsSession(
         config_,
-        socket_factory_,
+        socket_factory_.get(),
         base::Bind(&DnsTransactionTest::GetNextId, base::Unretained(this)),
         NULL /* NetLog */);
     transaction_factory_ = DnsTransactionFactory::CreateFactory(session_.get());
   }
 
   // Each socket used by a DnsTransaction expects only one write and zero or one
   // reads.
 
   // Add expected query for |dotted_name| and |qtype| with |id| and response
   // taken verbatim from |data| of |data_length| bytes. The transaction id in
   // |data| should equal |id|, unless testing mismatched response.
   void AddResponse(const std::string& dotted_name,
                    uint16 qtype,
                    uint16 id,
                    const char* data,
                    size_t data_length) {
-    CHECK(socket_factory_);
+    CHECK(socket_factory_.get());
     DnsQuery* query = new DnsQuery(id, DomainFromDot(dotted_name), qtype);
     queries_.push_back(query);
 
     // The response is only used to hold the IOBuffer.
     DnsResponse* response = new DnsResponse(data, data_length, 0);
     responses_.push_back(response);
 
     writes_.push_back(MockWrite(true,
                                 query->io_buffer()->data(),
                                 query->io_buffer()->size()));
     reads_.push_back(MockRead(true,
                               response->io_buffer()->data(),
                               data_length));
 
     transaction_ids_.push_back(id);
   }
 
   // Add expected query of |dotted_name| and |qtype| and no response.
   void AddTimeout(const char* dotted_name, uint16 qtype) {
-    CHECK(socket_factory_);
+    CHECK(socket_factory_.get());
     uint16 id = base::RandInt(0, kuint16max);
     DnsQuery* query = new DnsQuery(id, DomainFromDot(dotted_name), qtype);
     queries_.push_back(query);
 
     writes_.push_back(MockWrite(true,
                                 query->io_buffer()->data(),
                                 query->io_buffer()->size()));
     // Empty MockRead indicates no data.
     reads_.push_back(MockRead());
     transaction_ids_.push_back(id);
   }
 
   // Add expected query of |dotted_name| and |qtype| and response with no answer
   // and rcode set to |rcode|.
   void AddRcode(const char* dotted_name, uint16 qtype, int rcode) {
-    CHECK(socket_factory_);
+    CHECK(socket_factory_.get());
     CHECK_NE(dns_protocol::kRcodeNOERROR, rcode);
     uint16 id = base::RandInt(0, kuint16max);
     DnsQuery* query = new DnsQuery(id, DomainFromDot(dotted_name), qtype);
     queries_.push_back(query);
 
     DnsResponse* response = new DnsResponse(query->io_buffer()->data(),
                                             query->io_buffer()->size(),
                                             0);
     dns_protocol::Header* header =
         reinterpret_cast<dns_protocol::Header*>(response->io_buffer()->data());
@@ skipping 71 matching lines @@
   ScopedVector<DnsResponse> responses_;
 
   // Holders for MockRead/MockWrites (SocketDataProvider does not own it).
   std::vector<MockRead> reads_;
   std::vector<MockWrite> writes_;
 
   // Holder for the socket data (MockClientSocketFactory does not own it).
   ScopedVector<DelayedSocketData> socket_data_;
 
   std::deque<int> transaction_ids_;
-  // Owned by |session_|.
-  TestSocketFactory* socket_factory_;
+  scoped_ptr<TestSocketFactory> socket_factory_;
   scoped_refptr<DnsSession> session_;
   scoped_ptr<DnsTransactionFactory> transaction_factory_;
 };
 
 TEST_F(DnsTransactionTest, Lookup) {
   AddResponse(kT0HostName,
               kT0Qtype,
               0 /* id */,
               reinterpret_cast<const char*>(kT0ResponseDatagram),
               arraysize(kT0ResponseDatagram));
@@ skipping 299 matching lines @@
   TransactionHelper helper2("x",
                             dns_protocol::kTypeA,
                             ERR_NAME_NOT_RESOLVED);
   EXPECT_TRUE(helper2.Run(transaction_factory_.get()));
 }
 
 }  // namespace
 
 }  // namespace net