- Invoke FinishDiscovery() if no network interfaces are detected.

chrome/browser/extensions/api/dial/dial_service_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 "base/memory/ref_counted.h"
+#include "base/message_loop.h"
 #include "chrome/browser/extensions/api/dial/dial_device_data.h"
 #include "chrome/browser/extensions/api/dial/dial_service.h"
 #include "net/base/capturing_net_log.h"
+#include "net/base/ip_endpoint.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
+using base::TimeDelta;
 using ::testing::A;
 using ::testing::AtLeast;
 using ::testing::Return;
 
 namespace {
 
 const char kValidResponse[] =
   "HTTP/1.1 OK\r\n"
   "LOCATION: http://127.0.0.1/dd.xml\r\n"
   "USN: some_id\r\n"
   "CACHE-CONTROL: max-age=1800\r\n"
   "CONFIGID.UPNP.ORG: 1\r\n\r\n";
 
 }  // namespace
 
 namespace extensions {
 
 class MockObserver : public DialService::Observer {
  public:
   MOCK_METHOD1(OnDiscoveryRequest, void(DialService*));
   MOCK_METHOD2(OnDeviceDiscovered, void(DialService*, const DialDeviceData&));
   MOCK_METHOD1(OnDiscoveryFinished, void(DialService*));
   MOCK_METHOD2(OnError, void(DialService*, const std::string&));
 };
 
 class DialServiceTest : public testing::Test {
  public:
   DialServiceTest() {
+    DCHECK(net::ParseIPLiteralToNumber("127.0.0.1", &localhost_ip_));
     dial_service_ = new DialServiceImpl(&capturing_net_log_);
     dial_service_->AddObserver(&mock_observer_);
   }
  protected:
   net::CapturingNetLog capturing_net_log_;
+  net::IPAddressNumber localhost_ip_;
   scoped_refptr<DialServiceImpl> dial_service_;
   MockObserver mock_observer_;
 };
 
+TEST_F(DialServiceTest, TestSendMultipleRequests) {
+  MessageLoop loop(MessageLoop::TYPE_IO);
+  // Setting the finish delay to zero disables the timer that invokes
+  // FinishDiscovery().
+  dial_service_->finish_delay_ = TimeDelta::FromSeconds(0);
+  dial_service_->request_interval_ = TimeDelta::FromSeconds(0);
+  dial_service_->max_requests_ = 4;
+  dial_service_->discovery_active_ = true;
+  EXPECT_CALL(mock_observer_, OnDiscoveryRequest(A<DialService*>())).Times(4);
+  EXPECT_CALL(mock_observer_, OnDiscoveryFinished(A<DialService*>())).Times(1);
+  dial_service_->BindSocketAndSendRequest(localhost_ip_);
+  loop.RunUntilIdle();
+  dial_service_->FinishDiscovery();
+}
+
 TEST_F(DialServiceTest, TestOnDiscoveryRequest) {
   dial_service_->discovery_active_ = true;
+  dial_service_->num_requests_sent_ = 1;
+  dial_service_->max_requests_ = 1;
   size_t num_bytes = dial_service_->send_buffer_->size();
-
   EXPECT_CALL(mock_observer_, OnDiscoveryRequest(A<DialService*>())).Times(1);
   dial_service_->OnSocketWrite(num_bytes);
 }
 
 TEST_F(DialServiceTest, TestOnDeviceDiscovered) {
   dial_service_->discovery_active_ = true;
   int response_size = arraysize(kValidResponse) - 1;
   dial_service_->recv_buffer_ = new net::IOBufferWithSize(response_size);
   strncpy(dial_service_->recv_buffer_->data(), kValidResponse, response_size);
+  dial_service_->recv_address_ = net::IPEndPoint(localhost_ip_, 12345);
 
   DialDeviceData expected_device;
   expected_device.set_device_id("some_id");
 
   EXPECT_CALL(mock_observer_,
               OnDeviceDiscovered(A<DialService*>(), expected_device))
     .Times(1);
   dial_service_->OnSocketRead(response_size);
 };
 
@@ skipping 57 matching lines @@
 
   // Empty USN
   EXPECT_FALSE(DialServiceImpl::ParseResponse(
     "HTTP/1.1 OK\r\n"
     "LOCATION: http://127.0.0.1/dd.xml\r\n"
     "USN:\r\n\r\n",
     now, &not_parsed));
 }
 
 }  // namespace extensions