Refactored to make MDnsSocketFactory return array of sockets.

net/dns/mdns_client_unittest.cc

 // Copyright 2013 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 <queue>
 
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/rand_callback.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 354 matching lines @@
 
  private:
   bool set_;
   std::string name_;
   std::string ptrdomain_;
   int ttl_;
 };
 
 class MDnsTest : public ::testing::Test {
  public:
-  MDnsTest();
-  virtual ~MDnsTest();
   virtual void SetUp() OVERRIDE;
-  virtual void TearDown() OVERRIDE;
   void DeleteTransaction();
   void DeleteBothListeners();
   void RunFor(base::TimeDelta time_period);
   void Stop();
 
   MOCK_METHOD2(MockableRecordCallback, void(MDnsTransaction::Result result,
                                             const RecordParsed* record));
 
   MOCK_METHOD2(MockableRecordCallback2, void(MDnsTransaction::Result result,
                                              const RecordParsed* record));
 
 
  protected:
   void ExpectPacket(const uint8* packet, unsigned size);
   void SimulatePacketReceive(const uint8* packet, unsigned size);
 
-  scoped_ptr<MDnsClientImpl> test_client_;
+  MDnsClientImpl test_client_;
   IPEndPoint mdns_ipv4_endpoint_;
-  StrictMock<MockMDnsSocketFactory>* socket_factory_;
+  StrictMock<MockMDnsSocketFactory> socket_factory_;
 
   // Transactions and listeners that can be deleted by class methods for
   // reentrancy tests.
   scoped_ptr<MDnsTransaction> transaction_;
   scoped_ptr<MDnsListener> listener1_;
   scoped_ptr<MDnsListener> listener2_;
 };
 
 class MockListenerDelegate : public MDnsListener::Delegate {
  public:
   MOCK_METHOD2(OnRecordUpdate,
                void(MDnsListener::UpdateType update,
                     const RecordParsed* records));
   MOCK_METHOD2(OnNsecRecord, void(const std::string&, unsigned));
   MOCK_METHOD0(OnCachePurged, void());
 };
 
-MDnsTest::MDnsTest() {
-  socket_factory_ = new StrictMock<MockMDnsSocketFactory>();
-  test_client_.reset(new MDnsClientImpl(
-      scoped_ptr<MDnsConnection::SocketFactory>(socket_factory_)));
-}
-
-MDnsTest::~MDnsTest() {
-}
-
 void MDnsTest::SetUp() {
-  test_client_->StartListening();
-}
-
-void MDnsTest::TearDown() {
+  test_client_.StartListening(&socket_factory_);
 }
 
 void MDnsTest::SimulatePacketReceive(const uint8* packet, unsigned size) {
-  socket_factory_->SimulateReceive(packet, size);
+  socket_factory_.SimulateReceive(packet, size);
 }
 
 void MDnsTest::ExpectPacket(const uint8* packet, unsigned size) {
-  EXPECT_CALL(*socket_factory_, OnSendTo(MakeString(packet, size)))
+  EXPECT_CALL(socket_factory_, OnSendTo(MakeString(packet, size)))
       .Times(2);
 }
 
 void MDnsTest::DeleteTransaction() {
   transaction_.reset();
 }
 
 void MDnsTest::DeleteBothListeners() {
   listener1_.reset();
   listener2_.reset();
@@ skipping 13 matching lines @@
   base::MessageLoop::current()->Quit();
 }
 
 TEST_F(MDnsTest, PassiveListeners) {
   StrictMock<MockListenerDelegate> delegate_privet;
   StrictMock<MockListenerDelegate> delegate_printer;
 
   PtrRecordCopyContainer record_privet;
   PtrRecordCopyContainer record_printer;
 
-  scoped_ptr<MDnsListener> listener_privet = test_client_->CreateListener(
-      dns_protocol::kTypePTR, "_privet._tcp.local", &delegate_privet);
-  scoped_ptr<MDnsListener> listener_printer = test_client_->CreateListener(
-      dns_protocol::kTypePTR, "_printer._tcp.local", &delegate_printer);
+  scoped_ptr<MDnsListener> listener_privet =
+      test_client_.CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
+                                  &delegate_privet);
+  scoped_ptr<MDnsListener> listener_printer =
+      test_client_.CreateListener(dns_protocol::kTypePTR, "_printer._tcp.local",
+                                  &delegate_printer);
 
   ASSERT_TRUE(listener_privet->Start());
   ASSERT_TRUE(listener_printer->Start());
 
   // Send the same packet twice to ensure no records are double-counted.
 
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1))
       .WillOnce(Invoke(
           &record_privet,
@@ skipping 18 matching lines @@
   listener_privet.reset();
   listener_printer.reset();
 }
 
 TEST_F(MDnsTest, PassiveListenersCacheCleanup) {
   StrictMock<MockListenerDelegate> delegate_privet;
 
   PtrRecordCopyContainer record_privet;
   PtrRecordCopyContainer record_privet2;
 
-  scoped_ptr<MDnsListener> listener_privet = test_client_->CreateListener(
-      dns_protocol::kTypePTR, "_privet._tcp.local", &delegate_privet);
+  scoped_ptr<MDnsListener> listener_privet =
+      test_client_.CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
+                                  &delegate_privet);
 
   ASSERT_TRUE(listener_privet->Start());
 
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1))
       .WillOnce(Invoke(
           &record_privet,
           &PtrRecordCopyContainer::SaveWithDummyArg));
 
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
@@ skipping 12 matching lines @@
 
   EXPECT_TRUE(record_privet2.IsRecordWith("_privet._tcp.local",
                                           "hello._privet._tcp.local"));
 }
 
 TEST_F(MDnsTest, MalformedPacket) {
   StrictMock<MockListenerDelegate> delegate_printer;
 
   PtrRecordCopyContainer record_printer;
 
-  scoped_ptr<MDnsListener> listener_printer = test_client_->CreateListener(
-      dns_protocol::kTypePTR, "_printer._tcp.local", &delegate_printer);
+  scoped_ptr<MDnsListener> listener_printer =
+      test_client_.CreateListener(dns_protocol::kTypePTR, "_printer._tcp.local",
+                                  &delegate_printer);
 
   ASSERT_TRUE(listener_printer->Start());
 
   EXPECT_CALL(delegate_printer, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1))
       .WillOnce(Invoke(
           &record_printer,
           &PtrRecordCopyContainer::SaveWithDummyArg));
 
   // First, send unsalvagable packet to ensure we can deal with it.
   SimulatePacketReceive(kCorruptedPacketUnsalvagable,
                         sizeof(kCorruptedPacketUnsalvagable));
 
   // Regression test: send a packet where the question cannot be read.
   SimulatePacketReceive(kCorruptedPacketBadQuestion,
                         sizeof(kCorruptedPacketBadQuestion));
 
   // Then send salvagable packet to ensure we can extract useful records.
   SimulatePacketReceive(kCorruptedPacketSalvagable,
                         sizeof(kCorruptedPacketSalvagable));
 
   EXPECT_TRUE(record_printer.IsRecordWith("_printer._tcp.local",
                                           "hello._printer._tcp.local"));
 }
 
 TEST_F(MDnsTest, TransactionWithEmptyCache) {
   ExpectPacket(kQueryPacketPrivet, sizeof(kQueryPacketPrivet));
 
   scoped_ptr<MDnsTransaction> transaction_privet =
-      test_client_->CreateTransaction(
+      test_client_.CreateTransaction(
           dns_protocol::kTypePTR, "_privet._tcp.local",
           MDnsTransaction::QUERY_NETWORK |
           MDnsTransaction::QUERY_CACHE |
           MDnsTransaction::SINGLE_RESULT,
           base::Bind(&MDnsTest::MockableRecordCallback,
                      base::Unretained(this)));
 
   ASSERT_TRUE(transaction_privet->Start());
 
   PtrRecordCopyContainer record_privet;
 
   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD, _))
       .Times(Exactly(1))
       .WillOnce(Invoke(&record_privet,
                        &PtrRecordCopyContainer::SaveWithDummyArg));
 
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 
   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
                                          "hello._privet._tcp.local"));
 }
 
 TEST_F(MDnsTest, TransactionCacheOnlyNoResult) {
   scoped_ptr<MDnsTransaction> transaction_privet =
-      test_client_->CreateTransaction(
+      test_client_.CreateTransaction(
           dns_protocol::kTypePTR, "_privet._tcp.local",
           MDnsTransaction::QUERY_CACHE |
           MDnsTransaction::SINGLE_RESULT,
           base::Bind(&MDnsTest::MockableRecordCallback,
                      base::Unretained(this)));
 
   EXPECT_CALL(*this,
               MockableRecordCallback(MDnsTransaction::RESULT_NO_RESULTS, _))
       .Times(Exactly(1));
 
   ASSERT_TRUE(transaction_privet->Start());
 }
 
 TEST_F(MDnsTest, TransactionWithCache) {
   // Listener to force the client to listen
   StrictMock<MockListenerDelegate> delegate_irrelevant;
-  scoped_ptr<MDnsListener> listener_irrelevant = test_client_->CreateListener(
-      dns_protocol::kTypeA, "codereview.chromium.local",
-      &delegate_irrelevant);
+  scoped_ptr<MDnsListener> listener_irrelevant =
+      test_client_.CreateListener(dns_protocol::kTypeA,
+                                  "codereview.chromium.local",
+                                  &delegate_irrelevant);
 
   ASSERT_TRUE(listener_irrelevant->Start());
 
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 
 
   PtrRecordCopyContainer record_privet;
 
   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD, _))
       .WillOnce(Invoke(&record_privet,
                        &PtrRecordCopyContainer::SaveWithDummyArg));
 
   scoped_ptr<MDnsTransaction> transaction_privet =
-      test_client_->CreateTransaction(
+      test_client_.CreateTransaction(
           dns_protocol::kTypePTR, "_privet._tcp.local",
           MDnsTransaction::QUERY_NETWORK |
           MDnsTransaction::QUERY_CACHE |
           MDnsTransaction::SINGLE_RESULT,
           base::Bind(&MDnsTest::MockableRecordCallback,
                      base::Unretained(this)));
 
   ASSERT_TRUE(transaction_privet->Start());
 
   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
                                          "hello._privet._tcp.local"));
 }
 
 TEST_F(MDnsTest, AdditionalRecords) {
   StrictMock<MockListenerDelegate> delegate_privet;
 
   PtrRecordCopyContainer record_privet;
 
-  scoped_ptr<MDnsListener> listener_privet = test_client_->CreateListener(
-      dns_protocol::kTypePTR, "_privet._tcp.local",
-      &delegate_privet);
+  scoped_ptr<MDnsListener> listener_privet =
+      test_client_.CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
+                                  &delegate_privet);
 
   ASSERT_TRUE(listener_privet->Start());
 
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1))
       .WillOnce(Invoke(
           &record_privet,
           &PtrRecordCopyContainer::SaveWithDummyArg));
 
   SimulatePacketReceive(kSamplePacketAdditionalOnly,
                         sizeof(kSamplePacketAdditionalOnly));
 
   EXPECT_TRUE(record_privet.IsRecordWith("_privet._tcp.local",
                                          "hello._privet._tcp.local"));
 }
 
 TEST_F(MDnsTest, TransactionTimeout) {
   ExpectPacket(kQueryPacketPrivet, sizeof(kQueryPacketPrivet));
 
   scoped_ptr<MDnsTransaction> transaction_privet =
-      test_client_->CreateTransaction(
+      test_client_.CreateTransaction(
           dns_protocol::kTypePTR, "_privet._tcp.local",
           MDnsTransaction::QUERY_NETWORK |
           MDnsTransaction::QUERY_CACHE |
           MDnsTransaction::SINGLE_RESULT,
           base::Bind(&MDnsTest::MockableRecordCallback,
                      base::Unretained(this)));
 
   ASSERT_TRUE(transaction_privet->Start());
 
   EXPECT_CALL(*this,
               MockableRecordCallback(MDnsTransaction::RESULT_NO_RESULTS, NULL))
       .Times(Exactly(1))
       .WillOnce(InvokeWithoutArgs(this, &MDnsTest::Stop));
 
   RunFor(base::TimeDelta::FromSeconds(4));
 }
 
 TEST_F(MDnsTest, TransactionMultipleRecords) {
   ExpectPacket(kQueryPacketPrivet, sizeof(kQueryPacketPrivet));
 
   scoped_ptr<MDnsTransaction> transaction_privet =
-      test_client_->CreateTransaction(
+      test_client_.CreateTransaction(
           dns_protocol::kTypePTR, "_privet._tcp.local",
           MDnsTransaction::QUERY_NETWORK |
           MDnsTransaction::QUERY_CACHE ,
           base::Bind(&MDnsTest::MockableRecordCallback,
                      base::Unretained(this)));
 
   ASSERT_TRUE(transaction_privet->Start());
 
   PtrRecordCopyContainer record_privet;
   PtrRecordCopyContainer record_privet2;
@@ skipping 16 matching lines @@
 
   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_DONE, NULL))
       .WillOnce(InvokeWithoutArgs(this, &MDnsTest::Stop));
 
   RunFor(base::TimeDelta::FromSeconds(4));
 }
 
 TEST_F(MDnsTest, TransactionReentrantDelete) {
   ExpectPacket(kQueryPacketPrivet, sizeof(kQueryPacketPrivet));
 
-  transaction_ = test_client_->CreateTransaction(
+  transaction_ = test_client_.CreateTransaction(
       dns_protocol::kTypePTR, "_privet._tcp.local",
       MDnsTransaction::QUERY_NETWORK |
       MDnsTransaction::QUERY_CACHE |
       MDnsTransaction::SINGLE_RESULT,
       base::Bind(&MDnsTest::MockableRecordCallback,
                  base::Unretained(this)));
 
   ASSERT_TRUE(transaction_->Start());
 
   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_NO_RESULTS,
                                             NULL))
       .Times(Exactly(1))
       .WillOnce(DoAll(InvokeWithoutArgs(this, &MDnsTest::DeleteTransaction),
                       InvokeWithoutArgs(this, &MDnsTest::Stop)));
 
   RunFor(base::TimeDelta::FromSeconds(4));
 
   EXPECT_EQ(NULL, transaction_.get());
 }
 
 TEST_F(MDnsTest, TransactionReentrantDeleteFromCache) {
   StrictMock<MockListenerDelegate> delegate_irrelevant;
-  scoped_ptr<MDnsListener> listener_irrelevant = test_client_->CreateListener(
+  scoped_ptr<MDnsListener> listener_irrelevant = test_client_.CreateListener(
       dns_protocol::kTypeA, "codereview.chromium.local",
       &delegate_irrelevant);
   ASSERT_TRUE(listener_irrelevant->Start());
 
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 
-  transaction_ = test_client_->CreateTransaction(
+  transaction_ = test_client_.CreateTransaction(
       dns_protocol::kTypePTR, "_privet._tcp.local",
       MDnsTransaction::QUERY_NETWORK |
       MDnsTransaction::QUERY_CACHE,
       base::Bind(&MDnsTest::MockableRecordCallback,
                  base::Unretained(this)));
 
   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD, _))
       .Times(Exactly(1))
       .WillOnce(InvokeWithoutArgs(this, &MDnsTest::DeleteTransaction));
 
   ASSERT_TRUE(transaction_->Start());
 
   EXPECT_EQ(NULL, transaction_.get());
 }
 
 TEST_F(MDnsTest, TransactionReentrantCacheLookupStart) {
   ExpectPacket(kQueryPacketPrivet, sizeof(kQueryPacketPrivet));
 
-  scoped_ptr<MDnsTransaction> transaction1 = test_client_->CreateTransaction(
-      dns_protocol::kTypePTR, "_privet._tcp.local",
-      MDnsTransaction::QUERY_NETWORK |
-      MDnsTransaction::QUERY_CACHE |
-      MDnsTransaction::SINGLE_RESULT,
-      base::Bind(&MDnsTest::MockableRecordCallback,
-                 base::Unretained(this)));
+  scoped_ptr<MDnsTransaction> transaction1 =
+      test_client_.CreateTransaction(
+          dns_protocol::kTypePTR, "_privet._tcp.local",
+          MDnsTransaction::QUERY_NETWORK |
+          MDnsTransaction::QUERY_CACHE |
+          MDnsTransaction::SINGLE_RESULT,
+          base::Bind(&MDnsTest::MockableRecordCallback,
+                     base::Unretained(this)));
 
-  scoped_ptr<MDnsTransaction> transaction2 = test_client_->CreateTransaction(
-      dns_protocol::kTypePTR, "_printer._tcp.local",
-      MDnsTransaction::QUERY_CACHE |
-      MDnsTransaction::SINGLE_RESULT,
-      base::Bind(&MDnsTest::MockableRecordCallback2,
-                 base::Unretained(this)));
+  scoped_ptr<MDnsTransaction> transaction2 =
+      test_client_.CreateTransaction(
+          dns_protocol::kTypePTR, "_printer._tcp.local",
+          MDnsTransaction::QUERY_CACHE |
+          MDnsTransaction::SINGLE_RESULT,
+          base::Bind(&MDnsTest::MockableRecordCallback2,
+                     base::Unretained(this)));
 
   EXPECT_CALL(*this, MockableRecordCallback2(MDnsTransaction::RESULT_RECORD,
                                              _))
       .Times(Exactly(1));
 
   EXPECT_CALL(*this, MockableRecordCallback(MDnsTransaction::RESULT_RECORD,
                                             _))
       .Times(Exactly(1))
       .WillOnce(IgnoreResult(InvokeWithoutArgs(transaction2.get(),
                                                &MDnsTransaction::Start)));
 
   ASSERT_TRUE(transaction1->Start());
 
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 }
 
 TEST_F(MDnsTest, GoodbyePacketNotification) {
   StrictMock<MockListenerDelegate> delegate_privet;
 
-  scoped_ptr<MDnsListener> listener_privet = test_client_->CreateListener(
+  scoped_ptr<MDnsListener> listener_privet = test_client_.CreateListener(
       dns_protocol::kTypePTR, "_privet._tcp.local", &delegate_privet);
   ASSERT_TRUE(listener_privet->Start());
 
   SimulatePacketReceive(kSamplePacketGoodbye, sizeof(kSamplePacketGoodbye));
 
   RunFor(base::TimeDelta::FromSeconds(2));
 }
 
 TEST_F(MDnsTest, GoodbyePacketRemoval) {
   StrictMock<MockListenerDelegate> delegate_privet;
 
-  scoped_ptr<MDnsListener> listener_privet = test_client_->CreateListener(
-      dns_protocol::kTypePTR, "_privet._tcp.local", &delegate_privet);
+  scoped_ptr<MDnsListener> listener_privet =
+      test_client_.CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
+                                  &delegate_privet);
   ASSERT_TRUE(listener_privet->Start());
 
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1));
 
   SimulatePacketReceive(kSamplePacket2, sizeof(kSamplePacket2));
 
   SimulatePacketReceive(kSamplePacketGoodbye, sizeof(kSamplePacketGoodbye));
 
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_REMOVED, _))
       .Times(Exactly(1));
 
   RunFor(base::TimeDelta::FromSeconds(2));
 }
 
 // In order to reliably test reentrant listener deletes, we create two listeners
 // and have each of them delete both, so we're guaranteed to try and deliver a
 // callback to at least one deleted listener.
 
 TEST_F(MDnsTest, ListenerReentrantDelete) {
   StrictMock<MockListenerDelegate> delegate_privet;
 
-  listener1_ = test_client_->CreateListener(
-      dns_protocol::kTypePTR, "_privet._tcp.local",
-      &delegate_privet);
+  listener1_ = test_client_.CreateListener(dns_protocol::kTypePTR,
+                                           "_privet._tcp.local",
+                                           &delegate_privet);
 
-  listener2_ = test_client_->CreateListener(
-      dns_protocol::kTypePTR, "_privet._tcp.local",
-      &delegate_privet);
+  listener2_ = test_client_.CreateListener(dns_protocol::kTypePTR,
+                                           "_privet._tcp.local",
+                                           &delegate_privet);
 
   ASSERT_TRUE(listener1_->Start());
 
   ASSERT_TRUE(listener2_->Start());
 
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1))
       .WillOnce(InvokeWithoutArgs(this, &MDnsTest::DeleteBothListeners));
 
   SimulatePacketReceive(kSamplePacket1, sizeof(kSamplePacket1));
 
   EXPECT_EQ(NULL, listener1_.get());
   EXPECT_EQ(NULL, listener2_.get());
 }
 
 ACTION_P(SaveIPAddress, ip_container) {
   ::testing::StaticAssertTypeEq<const RecordParsed*, arg1_type>();
   ::testing::StaticAssertTypeEq<IPAddressNumber*, ip_container_type>();
 
   *ip_container = arg1->template rdata<ARecordRdata>()->address();
 }
 
 TEST_F(MDnsTest, DoubleRecordDisagreeing) {
   IPAddressNumber address;
   StrictMock<MockListenerDelegate> delegate_privet;
 
-  scoped_ptr<MDnsListener> listener_privet = test_client_->CreateListener(
-      dns_protocol::kTypeA, "privet.local", &delegate_privet);
+  scoped_ptr<MDnsListener> listener_privet =
+      test_client_.CreateListener(dns_protocol::kTypeA, "privet.local",
+                                  &delegate_privet);
 
   ASSERT_TRUE(listener_privet->Start());
 
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .Times(Exactly(1))
       .WillOnce(SaveIPAddress(&address));
 
   SimulatePacketReceive(kCorruptedPacketDoubleRecord,
                         sizeof(kCorruptedPacketDoubleRecord));
 
   EXPECT_EQ("2.3.4.5", IPAddressToString(address));
 }
 
 TEST_F(MDnsTest, NsecWithListener) {
   StrictMock<MockListenerDelegate> delegate_privet;
-  scoped_ptr<MDnsListener> listener_privet = test_client_->CreateListener(
-      dns_protocol::kTypeA, "_privet._tcp.local", &delegate_privet);
+  scoped_ptr<MDnsListener> listener_privet =
+      test_client_.CreateListener(dns_protocol::kTypeA, "_privet._tcp.local",
+                                  &delegate_privet);
 
   // Test to make sure nsec callback is NOT called for PTR
   // (which is marked as existing).
   StrictMock<MockListenerDelegate> delegate_privet2;
-  scoped_ptr<MDnsListener> listener_privet2 = test_client_->CreateListener(
-      dns_protocol::kTypePTR, "_privet._tcp.local", &delegate_privet2);
+  scoped_ptr<MDnsListener> listener_privet2 =
+      test_client_.CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
+                                  &delegate_privet2);
 
   ASSERT_TRUE(listener_privet->Start());
 
   EXPECT_CALL(delegate_privet,
               OnNsecRecord("_privet._tcp.local", dns_protocol::kTypeA));
 
   SimulatePacketReceive(kSamplePacketNsec,
                         sizeof(kSamplePacketNsec));
 }
 
 TEST_F(MDnsTest, NsecWithTransactionFromNetwork) {
   scoped_ptr<MDnsTransaction> transaction_privet =
-      test_client_->CreateTransaction(
+      test_client_.CreateTransaction(
           dns_protocol::kTypeA, "_privet._tcp.local",
           MDnsTransaction::QUERY_NETWORK |
           MDnsTransaction::QUERY_CACHE |
           MDnsTransaction::SINGLE_RESULT,
           base::Bind(&MDnsTest::MockableRecordCallback,
                      base::Unretained(this)));
 
-  EXPECT_CALL(*socket_factory_, OnSendTo(_))
-      .Times(2);
+  EXPECT_CALL(socket_factory_, OnSendTo(_)).Times(2);
 
   ASSERT_TRUE(transaction_privet->Start());
 
   EXPECT_CALL(*this,
               MockableRecordCallback(MDnsTransaction::RESULT_NSEC, NULL));
 
   SimulatePacketReceive(kSamplePacketNsec,
                         sizeof(kSamplePacketNsec));
 }
 
 TEST_F(MDnsTest, NsecWithTransactionFromCache) {
   // Force mDNS to listen.
   StrictMock<MockListenerDelegate> delegate_irrelevant;
   scoped_ptr<MDnsListener> listener_irrelevant =
-      test_client_->CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
-                                   &delegate_irrelevant);
+      test_client_.CreateListener(dns_protocol::kTypePTR, "_privet._tcp.local",
+                                  &delegate_irrelevant);
   listener_irrelevant->Start();
 
   SimulatePacketReceive(kSamplePacketNsec,
                         sizeof(kSamplePacketNsec));
 
   EXPECT_CALL(*this,
               MockableRecordCallback(MDnsTransaction::RESULT_NSEC, NULL));
 
   scoped_ptr<MDnsTransaction> transaction_privet_a =
-      test_client_->CreateTransaction(
+      test_client_.CreateTransaction(
           dns_protocol::kTypeA, "_privet._tcp.local",
           MDnsTransaction::QUERY_NETWORK |
           MDnsTransaction::QUERY_CACHE |
           MDnsTransaction::SINGLE_RESULT,
           base::Bind(&MDnsTest::MockableRecordCallback,
                      base::Unretained(this)));
 
   ASSERT_TRUE(transaction_privet_a->Start());
 
   // Test that a PTR transaction does NOT consider the same NSEC record to be a
   // valid answer to the query
 
   scoped_ptr<MDnsTransaction> transaction_privet_ptr =
-      test_client_->CreateTransaction(
+      test_client_.CreateTransaction(
           dns_protocol::kTypePTR, "_privet._tcp.local",
           MDnsTransaction::QUERY_NETWORK |
           MDnsTransaction::QUERY_CACHE |
           MDnsTransaction::SINGLE_RESULT,
           base::Bind(&MDnsTest::MockableRecordCallback,
                      base::Unretained(this)));
 
-  EXPECT_CALL(*socket_factory_, OnSendTo(_))
-      .Times(2);
+  EXPECT_CALL(socket_factory_, OnSendTo(_)).Times(2);
 
   ASSERT_TRUE(transaction_privet_ptr->Start());
 }
 
 TEST_F(MDnsTest, NsecConflictRemoval) {
   StrictMock<MockListenerDelegate> delegate_privet;
-  scoped_ptr<MDnsListener> listener_privet = test_client_->CreateListener(
-      dns_protocol::kTypeA, "_privet._tcp.local", &delegate_privet);
+  scoped_ptr<MDnsListener> listener_privet =
+      test_client_.CreateListener(dns_protocol::kTypeA, "_privet._tcp.local",
+                                  &delegate_privet);
 
   ASSERT_TRUE(listener_privet->Start());
 
   const RecordParsed* record1;
   const RecordParsed* record2;
 
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_ADDED, _))
       .WillOnce(SaveArg<1>(&record1));
 
   SimulatePacketReceive(kSamplePacketAPrivet,
                         sizeof(kSamplePacketAPrivet));
 
   EXPECT_CALL(delegate_privet, OnRecordUpdate(MDnsListener::RECORD_REMOVED, _))
       .WillOnce(SaveArg<1>(&record2));
 
   EXPECT_CALL(delegate_privet,
               OnNsecRecord("_privet._tcp.local", dns_protocol::kTypeA));
 
   SimulatePacketReceive(kSamplePacketNsec,
                         sizeof(kSamplePacketNsec));
 
   EXPECT_EQ(record1, record2);
 }
 
 
 // Note: These tests assume that the ipv4 socket will always be created first.
 // This is a simplifying assumption based on the way the code works now.
-
-class SimpleMockSocketFactory
-    : public MDnsConnection::SocketFactory {
+class SimpleMockSocketFactory : public MDnsSocketFactory {
  public:
-  SimpleMockSocketFactory() {
-  }
-  virtual ~SimpleMockSocketFactory() {
+  virtual void CreateSockets(
+      ScopedVector<DatagramServerSocket>* sockets) OVERRIDE {
+    sockets->clear();
+    sockets->swap(sockets_);
   }
 
-  virtual scoped_ptr<DatagramServerSocket> CreateSocket() OVERRIDE {
-    MockMDnsDatagramServerSocket* socket = sockets_.back();
-    sockets_.weak_erase(sockets_.end() - 1);
-    return scoped_ptr<DatagramServerSocket>(socket);
-  }
-
-  void PushSocket(MockMDnsDatagramServerSocket* socket) {
+  void PushSocket(DatagramServerSocket* socket) {
     sockets_.push_back(socket);
   }
 
  private:
-  ScopedVector<MockMDnsDatagramServerSocket> sockets_;
+  ScopedVector<DatagramServerSocket> sockets_;
 };
 
 class MockMDnsConnectionDelegate : public MDnsConnection::Delegate {
  public:
   virtual void HandlePacket(DnsResponse* response, int size) {
     HandlePacketInternal(std::string(response->io_buffer()->data(), size));
   }
 
   MOCK_METHOD1(HandlePacketInternal, void(std::string packet));
 
   MOCK_METHOD1(OnConnectionError, void(int error));
 };
 
 class MDnsConnectionTest : public ::testing::Test {
  public:
   MDnsConnectionTest() : connection_(&delegate_) {
   }
 
  protected:
   // Follow successful connection initialization.
   virtual void SetUp() OVERRIDE {
-    socket_ipv4_ = new MockMDnsDatagramServerSocket;
-    socket_ipv6_ = new MockMDnsDatagramServerSocket;
+    socket_ipv4_ = new MockMDnsDatagramServerSocket(ADDRESS_FAMILY_IPV4);
+    socket_ipv6_ = new MockMDnsDatagramServerSocket(ADDRESS_FAMILY_IPV6);
     factory_.PushSocket(socket_ipv6_);
     factory_.PushSocket(socket_ipv4_);
   }
 
   bool InitConnection() {
-    EXPECT_CALL(*socket_ipv4_, AllowAddressReuse());
-    EXPECT_CALL(*socket_ipv6_, AllowAddressReuse());
-
-    EXPECT_CALL(*socket_ipv4_, SetMulticastLoopbackMode(false));
-    EXPECT_CALL(*socket_ipv6_, SetMulticastLoopbackMode(false));
-
-    EXPECT_CALL(*socket_ipv4_, ListenInternal("0.0.0.0:5353"))
-        .WillOnce(Return(OK));
-    EXPECT_CALL(*socket_ipv6_, ListenInternal("[::]:5353"))
-        .WillOnce(Return(OK));
-
-    EXPECT_CALL(*socket_ipv4_, JoinGroupInternal("224.0.0.251"))
-        .WillOnce(Return(OK));
-    EXPECT_CALL(*socket_ipv6_, JoinGroupInternal("ff02::fb"))
-        .WillOnce(Return(OK));
-
     return connection_.Init(&factory_);
   }
 
   StrictMock<MockMDnsConnectionDelegate> delegate_;
 
   MockMDnsDatagramServerSocket* socket_ipv4_;
   MockMDnsDatagramServerSocket* socket_ipv6_;
   SimpleMockSocketFactory factory_;
   MDnsConnection connection_;
   TestCompletionCallback callback_;
@@ skipping 67 matching lines @@
 
   ASSERT_TRUE(InitConnection());
 
   EXPECT_CALL(delegate_, OnConnectionError(ERR_SOCKET_NOT_CONNECTED));
   callback.Run(ERR_SOCKET_NOT_CONNECTED);
 }
 
 }  // namespace
 
 }  // namespace net