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 1006 matching lines @@
 // This is a simplifying assumption based on the way the code works now.
 
 class SimpleMockSocketFactory
     : public MDnsConnection::SocketFactory {
  public:
   SimpleMockSocketFactory() {
   }
   virtual ~SimpleMockSocketFactory() {
   }
 
-  virtual scoped_ptr<DatagramServerSocket> CreateSocket() OVERRIDE {
-    MockMDnsDatagramServerSocket* socket = sockets_.back();
-    sockets_.weak_erase(sockets_.end() - 1);
-    return scoped_ptr<DatagramServerSocket>(socket);
+  virtual void CreateSockets(
+      ScopedVector<MDnsConnection::Socket>* sockets) OVERRIDE {
+    sockets->swap(sockets_);
   }

[szym, 2013/11/27 07:37:44]

To avoid weird bugs, either sockets->clear() or DCHECK(sockets->empty()) at the
beginning of the function.

[Vitaly Buka (NO REVIEWS), 2013/11/27 08:45:37]

Done.

 
-  void PushSocket(MockMDnsDatagramServerSocket* socket) {
+  void PushSocket(MDnsConnection::Socket* socket) {
     sockets_.push_back(socket);
   }
 
  private:
-  ScopedVector<MockMDnsDatagramServerSocket> sockets_;
+  ScopedVector<MDnsConnection::Socket> 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;
     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 42 matching lines @@
       new IOBufferWithSize(sizeof kSamplePacket1));
   memcpy(buf->data(), kSamplePacket1, sizeof(kSamplePacket1));
 
   EXPECT_CALL(*socket_ipv4_, RecvFrom(_, _, _, _))
       .WillOnce(Return(ERR_IO_PENDING));
   EXPECT_CALL(*socket_ipv6_, RecvFrom(_, _, _, _))
       .WillOnce(Return(ERR_IO_PENDING));
 
   ASSERT_TRUE(InitConnection());
 
-  EXPECT_CALL(*socket_ipv4_,
-              SendToInternal(sample_packet, "224.0.0.251:5353", _));
-  EXPECT_CALL(*socket_ipv6_,
-              SendToInternal(sample_packet, "[ff02::fb]:5353", _));
+  EXPECT_CALL(*socket_ipv4_, SendToInternal(sample_packet, _));
+  EXPECT_CALL(*socket_ipv6_, SendToInternal(sample_packet, _));
 
   connection_.Send(buf, buf->size());
 }
 
 TEST_F(MDnsConnectionTest, Error) {
   CompletionCallback callback;
 
   EXPECT_CALL(*socket_ipv4_, RecvFrom(_, _, _, _))
       .WillOnce(Return(ERR_IO_PENDING));
   EXPECT_CALL(*socket_ipv6_, RecvFrom(_, _, _, _))
       .WillOnce(DoAll(SaveArg<3>(&callback),  Return(ERR_IO_PENDING)));
 
   ASSERT_TRUE(InitConnection());
 
   EXPECT_CALL(delegate_, OnConnectionError(ERR_SOCKET_NOT_CONNECTED));
   callback.Run(ERR_SOCKET_NOT_CONNECTED);
 }
 
 }  // namespace
 
 }  // namespace net