[Device Discovery] Make DialRegistry a Singleton

chrome/browser/media/router/discovery/dial/dial_registry_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 <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/media/router/discovery/dial/dial_device_data.h"
 #include "chrome/browser/media/router/discovery/dial/dial_registry.h"
 #include "chrome/browser/media/router/discovery/dial/dial_service.h"
@@ skipping 26 matching lines @@
   ~MockDialService() override {}
 
   MOCK_METHOD0(Discover, bool());
   MOCK_METHOD1(AddObserver, void(DialService::Observer*));
   MOCK_METHOD1(RemoveObserver, void(DialService::Observer*));
   MOCK_CONST_METHOD1(HasObserver, bool(const DialService::Observer*));
 };
 
 class MockDialRegistry : public DialRegistry {
  public:
-  MockDialRegistry(const base::TimeDelta& refresh_interval,
-                   const base::TimeDelta& expiration,
-                   const size_t max_devices)
-      : DialRegistry(refresh_interval, expiration, max_devices),
-        time_(Time::Now()) {}
+  MockDialRegistry() : DialRegistry(), time_(Time::Now()) {}
 
   ~MockDialRegistry() override {
     // Don't let the DialRegistry delete this.
     DialService* tmp = dial_.release();
     if (tmp)
       CHECK_EQ(&mock_service_, tmp);
   }
 
   // Returns the mock Dial service.
   MockDialService& mock_service() { return mock_service_; }
@@ skipping 19 matching lines @@
   Time time_;
 };
 
 class DialRegistryTest : public testing::Test {
  public:
   DialRegistryTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         first_device_("first", GURL("http://127.0.0.1/dd.xml"), Time::Now()),
         second_device_("second", GURL("http://127.0.0.2/dd.xml"), Time::Now()),
         third_device_("third", GURL("http://127.0.0.3/dd.xml"), Time::Now()) {
-    registry_ = base::MakeUnique<MockDialRegistry>(
-        TimeDelta::FromSeconds(1000), TimeDelta::FromSeconds(10), 10);
+    registry_ = base::MakeUnique<MockDialRegistry>();
     registry_->RegisterObserver(&mock_observer_);
     list_with_first_device_.push_back(first_device_);
     list_with_second_device_.push_back(second_device_);
   }
 
  protected:
   void SetListenerExpectations() {
     EXPECT_CALL(registry_->mock_service(),
                 AddObserver(A<DialService::Observer*>()));
     EXPECT_CALL(registry_->mock_service(),
@@ skipping 10 matching lines @@
   const DialRegistry::DeviceList empty_list_;
   DialRegistry::DeviceList list_with_first_device_;
   DialRegistry::DeviceList list_with_second_device_;
 };
 
 TEST_F(DialRegistryTest, TestAddRemoveListeners) {
   SetListenerExpectations();
   EXPECT_CALL(registry_->mock_service(), Discover());
   EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)).Times(2);
 
-  EXPECT_FALSE(registry_->repeating_timer_.IsRunning());
+  EXPECT_FALSE(registry_->repeating_timer_);
   registry_->OnListenerAdded();
-  EXPECT_TRUE(registry_->repeating_timer_.IsRunning());
+  EXPECT_TRUE(registry_->repeating_timer_->IsRunning());
   registry_->OnListenerAdded();
-  EXPECT_TRUE(registry_->repeating_timer_.IsRunning());
+  EXPECT_TRUE(registry_->repeating_timer_->IsRunning());
   registry_->OnListenerRemoved();
-  EXPECT_TRUE(registry_->repeating_timer_.IsRunning());
+  EXPECT_TRUE(registry_->repeating_timer_->IsRunning());
   registry_->OnListenerRemoved();
-  EXPECT_FALSE(registry_->repeating_timer_.IsRunning());
+  EXPECT_FALSE(registry_->repeating_timer_);
 }
 
 TEST_F(DialRegistryTest, TestNoDevicesDiscovered) {
   SetListenerExpectations();
   EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_));
   EXPECT_CALL(registry_->mock_service(), Discover());
 
   registry_->OnListenerAdded();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDiscoveryFinished(nullptr);
@@ skipping 61 matching lines @@
   EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_));
   EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_));
   EXPECT_CALL(registry_->mock_service(), Discover());
   EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_));
 
   registry_->OnListenerAdded();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDeviceDiscovered(nullptr, first_device_);
   registry_->OnDiscoveryFinished(nullptr);
 
-  registry_->set_time(Time::Now() + TimeDelta::FromSeconds(30));
+  registry_->set_time(Time::Now() + TimeDelta::FromSeconds(300));
 
   registry_->DoDiscovery();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDiscoveryFinished(nullptr);
   registry_->OnListenerRemoved();
 }
 
 TEST_F(DialRegistryTest, TestExpiredDeviceIsRediscovered) {
   std::vector<Time> discovery_times;
   discovery_times.push_back(Time::Now());
-  discovery_times.push_back(discovery_times[0] + TimeDelta::FromSeconds(30));
-  discovery_times.push_back(discovery_times[1] + TimeDelta::FromSeconds(30));
+  discovery_times.push_back(discovery_times[0] + TimeDelta::FromSeconds(300));
+  discovery_times.push_back(discovery_times[1] + TimeDelta::FromSeconds(300));
 
   DialDeviceData rediscovered_device("first", GURL("http://127.0.0.1/dd.xml"),
                                      discovery_times[2]);
 
   SetListenerExpectations();
 
   InSequence s;
   EXPECT_CALL(registry_->mock_service(), Discover());
   EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_));
   EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_));
@@ skipping 130 matching lines @@
   registry_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDeviceDiscovered(nullptr, third_device_);
   registry_->OnDiscoveryFinished(nullptr);
 
   registry_->OnListenerRemoved();
 }
 
 }  // namespace media_router