Refactored to make MDnsSocketFactory return array of sockets.

chrome/utility/local_discovery/service_discovery_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 "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "chrome/utility/local_discovery/service_discovery_client_impl.h"
 #include "net/base/net_errors.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/mdns_client_impl.h"
@@ skipping 165 matching lines @@
 
   ServiceWatcher::UpdatedCallback GetCallback() {
     return base::Bind(&MockServiceWatcherClient::OnServiceUpdated,
                       base::Unretained(this));
   }
 };
 
 class ServiceDiscoveryTest : public ::testing::Test {
  public:
   ServiceDiscoveryTest()
-      : socket_factory_(new net::MockMDnsSocketFactory),
-        mdns_client_(
-            scoped_ptr<net::MDnsConnection::SocketFactory>(
-                socket_factory_)),
-        service_discovery_client_(&mdns_client_) {
-    mdns_client_.StartListening();
+      : service_discovery_client_(&mdns_client_) {
+    mdns_client_.StartListening(&socket_factory_);
   }
 
   virtual ~ServiceDiscoveryTest() {
   }
 
  protected:
   void RunFor(base::TimeDelta time_period) {
     base::CancelableCallback<void()> callback(base::Bind(
         &ServiceDiscoveryTest::Stop, base::Unretained(this)));
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, callback.callback(), time_period);
 
     base::MessageLoop::current()->Run();
     callback.Cancel();
   }
 
   void Stop() {
     base::MessageLoop::current()->Quit();
   }
 
-  net::MockMDnsSocketFactory* socket_factory_;
+  net::MockMDnsSocketFactory socket_factory_;
   net::MDnsClientImpl mdns_client_;
   ServiceDiscoveryClientImpl service_discovery_client_;
   base::MessageLoop loop_;
 };
 
 TEST_F(ServiceDiscoveryTest, AddRemoveService) {
   StrictMock<MockServiceWatcherClient> delegate;
 
   scoped_ptr<ServiceWatcher> watcher(
       service_discovery_client_.CreateServiceWatcher(
           "_privet._tcp.local", delegate.GetCallback()));
 
   watcher->Start();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_ADDED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
-  socket_factory_->SimulateReceive(
-      kSamplePacketPTR, sizeof(kSamplePacketPTR));
+  socket_factory_.SimulateReceive(kSamplePacketPTR, sizeof(kSamplePacketPTR));
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_REMOVED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
   RunFor(base::TimeDelta::FromSeconds(2));
 };
 
 TEST_F(ServiceDiscoveryTest, DiscoverNewServices) {
   StrictMock<MockServiceWatcherClient> delegate;
 
   scoped_ptr<ServiceWatcher> watcher(
       service_discovery_client_.CreateServiceWatcher(
           "_privet._tcp.local", delegate.GetCallback()));
 
   watcher->Start();
 
-  EXPECT_CALL(*socket_factory_, OnSendTo(_))
-      .Times(2);
+  EXPECT_CALL(socket_factory_, OnSendTo(_)).Times(2);
 
   watcher->DiscoverNewServices(false);
 };
 
 TEST_F(ServiceDiscoveryTest, ReadCachedServices) {
-  socket_factory_->SimulateReceive(
-      kSamplePacketPTR, sizeof(kSamplePacketPTR));
+  socket_factory_.SimulateReceive(kSamplePacketPTR, sizeof(kSamplePacketPTR));
 
   StrictMock<MockServiceWatcherClient> delegate;
 
   scoped_ptr<ServiceWatcher> watcher(
       service_discovery_client_.CreateServiceWatcher(
           "_privet._tcp.local", delegate.GetCallback()));
 
   watcher->Start();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_ADDED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
   base::MessageLoop::current()->RunUntilIdle();
 };
 
 
 TEST_F(ServiceDiscoveryTest, ReadCachedServicesMultiple) {
-  socket_factory_->SimulateReceive(
-      kSamplePacketPTR2, sizeof(kSamplePacketPTR2));
+  socket_factory_.SimulateReceive(kSamplePacketPTR2, sizeof(kSamplePacketPTR2));
 
   StrictMock<MockServiceWatcherClient> delegate;
   scoped_ptr<ServiceWatcher> watcher =
       service_discovery_client_.CreateServiceWatcher(
           "_privet._tcp.local", delegate.GetCallback());
 
   watcher->Start();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_ADDED,
                                          "hello._privet._tcp.local"))
@@ skipping 12 matching lines @@
   scoped_ptr<ServiceWatcher> watcher(
       service_discovery_client_.CreateServiceWatcher(
           "_privet._tcp.local", delegate.GetCallback()));
 
   watcher->Start();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_ADDED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
-  socket_factory_->SimulateReceive(
-      kSamplePacketPTR, sizeof(kSamplePacketPTR));
+  socket_factory_.SimulateReceive(kSamplePacketPTR, sizeof(kSamplePacketPTR));
 
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_CHANGED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
-  socket_factory_->SimulateReceive(
-      kSamplePacketSRV, sizeof(kSamplePacketSRV));
+  socket_factory_.SimulateReceive(kSamplePacketSRV, sizeof(kSamplePacketSRV));
 
-  socket_factory_->SimulateReceive(
-      kSamplePacketTXT, sizeof(kSamplePacketTXT));
+  socket_factory_.SimulateReceive(kSamplePacketTXT, sizeof(kSamplePacketTXT));
 
   base::MessageLoop::current()->RunUntilIdle();
 };
 
 TEST_F(ServiceDiscoveryTest, SinglePacket) {
   StrictMock<MockServiceWatcherClient> delegate;
   scoped_ptr<ServiceWatcher> watcher(
       service_discovery_client_.CreateServiceWatcher(
           "_privet._tcp.local", delegate.GetCallback()));
 
   watcher->Start();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_ADDED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
-  socket_factory_->SimulateReceive(
-      kSamplePacketPTR, sizeof(kSamplePacketPTR));
+  socket_factory_.SimulateReceive(kSamplePacketPTR, sizeof(kSamplePacketPTR));
 
   // Reset the "already updated" flag.
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_CALL(delegate, OnServiceUpdated(ServiceWatcher::UPDATE_CHANGED,
                                          "hello._privet._tcp.local"))
       .Times(Exactly(1));
 
-  socket_factory_->SimulateReceive(
-      kSamplePacketSRV, sizeof(kSamplePacketSRV));
+  socket_factory_.SimulateReceive(kSamplePacketSRV, sizeof(kSamplePacketSRV));
 
-  socket_factory_->SimulateReceive(
-      kSamplePacketTXT, sizeof(kSamplePacketTXT));
+  socket_factory_.SimulateReceive(kSamplePacketTXT, sizeof(kSamplePacketTXT));
 
   base::MessageLoop::current()->RunUntilIdle();
 };
 
 class ServiceResolverTest : public ServiceDiscoveryTest {
  public:
   ServiceResolverTest() {
     metadata_expected_.push_back("hello");
     address_expected_ = net::HostPortPair("myhello.local", 8888);
     ip_address_expected_.push_back(1);
@@ skipping 28 matching lines @@
 
  protected:
   scoped_ptr<ServiceResolver> resolver_;
   net::IPAddressNumber ip_address_;
   net::HostPortPair address_expected_;
   std::vector<std::string> metadata_expected_;
   net::IPAddressNumber ip_address_expected_;
 };
 
 TEST_F(ServiceResolverTest, TxtAndSrvButNoA) {
-  EXPECT_CALL(*socket_factory_, OnSendTo(_))
-      .Times(4);
+  EXPECT_CALL(socket_factory_, OnSendTo(_)).Times(4);
 
   resolver_->StartResolving();
 
-  socket_factory_->SimulateReceive(
-      kSamplePacketSRV, sizeof(kSamplePacketSRV));
+  socket_factory_.SimulateReceive(kSamplePacketSRV, sizeof(kSamplePacketSRV));
 
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_CALL(*this,
               OnFinishedResolvingInternal(ServiceResolver::STATUS_SUCCESS,
                                           address_expected_.ToString(),
                                           metadata_expected_,
                                           net::IPAddressNumber()));
 
-  socket_factory_->SimulateReceive(
-      kSamplePacketTXT, sizeof(kSamplePacketTXT));
+  socket_factory_.SimulateReceive(kSamplePacketTXT, sizeof(kSamplePacketTXT));
 };
 
 TEST_F(ServiceResolverTest, TxtSrvAndA) {
-  EXPECT_CALL(*socket_factory_, OnSendTo(_))
-      .Times(4);
+  EXPECT_CALL(socket_factory_, OnSendTo(_)).Times(4);
 
   resolver_->StartResolving();
 
   EXPECT_CALL(*this,
               OnFinishedResolvingInternal(ServiceResolver::STATUS_SUCCESS,
                                           address_expected_.ToString(),
                                           metadata_expected_,
                                           ip_address_expected_));
 
-  socket_factory_->SimulateReceive(
-      kSamplePacketTXT, sizeof(kSamplePacketTXT));
+  socket_factory_.SimulateReceive(kSamplePacketTXT, sizeof(kSamplePacketTXT));
 
-  socket_factory_->SimulateReceive(
-      kSamplePacketSRVA, sizeof(kSamplePacketSRVA));
+  socket_factory_.SimulateReceive(kSamplePacketSRVA, sizeof(kSamplePacketSRVA));
 };
 
 TEST_F(ServiceResolverTest, JustSrv) {
-  EXPECT_CALL(*socket_factory_, OnSendTo(_))
-      .Times(4);
+  EXPECT_CALL(socket_factory_, OnSendTo(_)).Times(4);
 
   resolver_->StartResolving();
 
   EXPECT_CALL(*this,
               OnFinishedResolvingInternal(ServiceResolver::STATUS_SUCCESS,
                                           address_expected_.ToString(),
                                           std::vector<std::string>(),
                                           ip_address_expected_));
 
-  socket_factory_->SimulateReceive(
-      kSamplePacketSRVA, sizeof(kSamplePacketSRVA));
+  socket_factory_.SimulateReceive(kSamplePacketSRVA, sizeof(kSamplePacketSRVA));
 
   // TODO(noamsml): When NSEC record support is added, change this to use an
   // NSEC record.
   RunFor(base::TimeDelta::FromSeconds(4));
 };
 
 TEST_F(ServiceResolverTest, WithNothing) {
-  EXPECT_CALL(*socket_factory_, OnSendTo(_))
-      .Times(4);
+  EXPECT_CALL(socket_factory_, OnSendTo(_)).Times(4);
 
   resolver_->StartResolving();
 
   EXPECT_CALL(*this, OnFinishedResolvingInternal(
-                        ServiceResolver::STATUS_REQUEST_TIMEOUT, _, _, _));
+                         ServiceResolver::STATUS_REQUEST_TIMEOUT, _, _, _));
 
   // TODO(noamsml): When NSEC record support is added, change this to use an
   // NSEC record.
   RunFor(base::TimeDelta::FromSeconds(4));
 };
 
 }  // namespace
 
 }  // namespace local_discovery