[DIAL tests] Slightly improve DialRegistry tests.

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 "base/test/simple_test_clock.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"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using base::Time;
@@ skipping 19 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() : DialRegistry(), time_(Time::Now()) {}
+  MockDialRegistry() : DialRegistry(), clock_(new base::SimpleTestClock()) {
+    // Takes ownership of |clock|.
+    SetClockForTest(base::WrapUnique(clock_));
+  }
 
   ~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_; }
-
-  void set_time(Time time) { time_ = time; }
+  base::SimpleTestClock* clock() const { return clock_; }
 
  protected:
-  base::Time Now() const override { return time_; }
-
   std::unique_ptr<DialService> CreateDialService() override {
     return base::WrapUnique(&mock_service_);
   }
 
   void ClearDialService() override {
     // Release the pointer but don't delete the object because the test owns it.
     CHECK_EQ(&mock_service_, dial_.release());
   }
 
  private:
   MockDialService mock_service_;
 
-  // Set to mock out the current time.
-  Time time_;
+  // Owned by DialRegistry.
+  base::SimpleTestClock* const clock_;
 };
 
 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>();
+        registry_(new MockDialRegistry()),
+        first_device_("first", GURL("http://127.0.0.1/dd.xml"), Now()),
+        second_device_("second", GURL("http://127.0.0.2/dd.xml"), Now()),
+        third_device_("third", GURL("http://127.0.0.3/dd.xml"), Now()),
+        list_with_first_device_({first_device_}),
+        list_with_second_device_({second_device_}),
+        list_with_first_second_devices_({first_device_, second_device_}) {
     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(),
                 RemoveObserver(A<DialService::Observer*>()));
   }
 
+  void VerifyAndResetMocks() {
+    testing::Mock::VerifyAndClearExpectations(&registry_->mock_service());
+    testing::Mock::VerifyAndClearExpectations(&mock_observer_);
+  }
+
+  Time Now() const { return registry_->clock()->Now(); }
+
+  void AdvanceTime(base::TimeDelta duration) {
+    registry_->clock()->Advance(duration);
+  }
+
   content::TestBrowserThreadBundle thread_bundle_;
+
   std::unique_ptr<MockDialRegistry> registry_;
   MockDialObserver mock_observer_;
   const DialDeviceData first_device_;
   const DialDeviceData second_device_;
   const DialDeviceData third_device_;
 
   const DialRegistry::DeviceList empty_list_;
-  DialRegistry::DeviceList list_with_first_device_;
-  DialRegistry::DeviceList list_with_second_device_;
+  const DialRegistry::DeviceList list_with_first_device_;
+  const DialRegistry::DeviceList list_with_second_device_;
+  const DialRegistry::DeviceList list_with_first_second_devices_;
 };
 
 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_);
   registry_->OnListenerAdded();
   EXPECT_TRUE(registry_->repeating_timer_->IsRunning());
@@ skipping 10 matching lines @@
   EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_));
   EXPECT_CALL(registry_->mock_service(), Discover());
 
   registry_->OnListenerAdded();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDiscoveryFinished(nullptr);
   registry_->OnListenerRemoved();
 }
 
 TEST_F(DialRegistryTest, TestDevicesDiscovered) {
-  DialRegistry::DeviceList expected_list2;
-  expected_list2.push_back(first_device_);
-  expected_list2.push_back(second_device_);
-
   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_));
   EXPECT_CALL(registry_->mock_service(), Discover());
-  EXPECT_CALL(mock_observer_, OnDialDeviceEvent(expected_list2));
+  EXPECT_CALL(mock_observer_,
+              OnDialDeviceEvent(list_with_first_second_devices_));
 
   registry_->OnListenerAdded();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDeviceDiscovered(nullptr, first_device_);
   registry_->OnDiscoveryFinished(nullptr);
 
   registry_->DoDiscovery();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDeviceDiscovered(nullptr, second_device_);
   registry_->OnDiscoveryFinished(nullptr);
   registry_->OnListenerRemoved();
 }
 
 TEST_F(DialRegistryTest, TestDevicesDiscoveredWithTwoListeners) {
-  DialRegistry::DeviceList expected_list2;
-  expected_list2.push_back(first_device_);
-  expected_list2.push_back(second_device_);
-
   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_))
       .Times(2);
   EXPECT_CALL(registry_->mock_service(), Discover());
-  EXPECT_CALL(mock_observer_, OnDialDeviceEvent(expected_list2));
+  EXPECT_CALL(mock_observer_,
+              OnDialDeviceEvent(list_with_first_second_devices_));
 
   registry_->OnListenerAdded();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDeviceDiscovered(nullptr, first_device_);
   registry_->OnDiscoveryFinished(nullptr);
 
   registry_->OnListenerAdded();
 
   registry_->DoDiscovery();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDeviceDiscovered(nullptr, second_device_);
   registry_->OnDiscoveryFinished(nullptr);
   registry_->OnListenerRemoved();
   registry_->OnListenerRemoved();
 }
 
 TEST_F(DialRegistryTest, TestDeviceExpires) {
-  SetListenerExpectations();
   InSequence s;
+
+  EXPECT_CALL(registry_->mock_service(),
+              AddObserver(A<DialService::Observer*>()));
   EXPECT_CALL(registry_->mock_service(), Discover());
   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);
+  VerifyAndResetMocks();
 
-  registry_->set_time(Time::Now() + TimeDelta::FromSeconds(300));
+  // First device has not expired yet.
+  EXPECT_CALL(registry_->mock_service(), Discover());
+  EXPECT_CALL(mock_observer_,
+              OnDialDeviceEvent(list_with_first_second_devices_));
+
+  AdvanceTime(TimeDelta::FromSeconds(100));
+  DialDeviceData second_device_discovered_later = second_device_;
+  second_device_discovered_later.set_response_time(Now());
 
   registry_->DoDiscovery();
   registry_->OnDiscoveryRequest(nullptr);
+  registry_->OnDeviceDiscovered(nullptr, second_device_discovered_later);
   registry_->OnDiscoveryFinished(nullptr);
+  VerifyAndResetMocks();
+
+  // First device has expired, second device has not expired yet.
+  EXPECT_CALL(registry_->mock_service(), Discover());
+  EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_second_device_));
+
+  AdvanceTime(TimeDelta::FromSeconds(200));
+  registry_->DoDiscovery();
+  registry_->OnDiscoveryRequest(nullptr);
+  registry_->OnDiscoveryFinished(nullptr);
+  VerifyAndResetMocks();
+
+  // Second device has expired.
+  EXPECT_CALL(registry_->mock_service(), Discover());
+  EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_));
+
+  AdvanceTime(TimeDelta::FromSeconds(200));
+  registry_->DoDiscovery();
+  registry_->OnDiscoveryRequest(nullptr);
+  registry_->OnDiscoveryFinished(nullptr);
+  VerifyAndResetMocks();
+
+  EXPECT_CALL(registry_->mock_service(),
+              RemoveObserver(A<DialService::Observer*>()));
   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(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_));
   EXPECT_CALL(registry_->mock_service(), Discover());
   EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_));
   EXPECT_CALL(registry_->mock_service(), Discover());
   EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_));
 
-  registry_->set_time(discovery_times[0]);
   registry_->OnListenerAdded();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDeviceDiscovered(nullptr, first_device_);
   registry_->OnDiscoveryFinished(nullptr);
 
   // Will expire "first" device as it is not discovered this time.
-  registry_->set_time(discovery_times[1]);
+  AdvanceTime(TimeDelta::FromSeconds(300));
   registry_->DoDiscovery();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDiscoveryFinished(nullptr);
 
-  // "first" device is rediscovered 30 seconds later.  We pass a device object
+  // "first" device is rediscovered 300 seconds later.  We pass a device object
   // with a newer discovery time so it is not pruned immediately.
-  registry_->set_time(discovery_times[2]);
+  AdvanceTime(TimeDelta::FromSeconds(300));
+  DialDeviceData rediscovered_device = first_device_;
+  rediscovered_device.set_response_time(Now());
+
   registry_->DoDiscovery();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDeviceDiscovered(nullptr, rediscovered_device);
   registry_->OnDiscoveryFinished(nullptr);
 
   registry_->OnListenerRemoved();
 }
 
 TEST_F(DialRegistryTest, TestRemovingListenerDoesNotClearList) {
-  DialRegistry::DeviceList expected_list2;
-  expected_list2.push_back(first_device_);
-  expected_list2.push_back(second_device_);
-
   InSequence s;
   EXPECT_CALL(registry_->mock_service(),
               AddObserver(A<DialService::Observer*>()));
   EXPECT_CALL(registry_->mock_service(), Discover());
   EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_));
-  EXPECT_CALL(mock_observer_, OnDialDeviceEvent(expected_list2));
+  EXPECT_CALL(mock_observer_,
+              OnDialDeviceEvent(list_with_first_second_devices_));
   EXPECT_CALL(registry_->mock_service(),
               RemoveObserver(A<DialService::Observer*>()));
 
   registry_->OnListenerAdded();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDeviceDiscovered(nullptr, first_device_);
   registry_->OnDeviceDiscovered(nullptr, second_device_);
   registry_->OnDiscoveryFinished(nullptr);
   registry_->OnListenerRemoved();
 
   // Removing and adding a listener again fires an event with the current device
   // list (even though no new devices were discovered).
   EXPECT_CALL(registry_->mock_service(),
               AddObserver(A<DialService::Observer*>()));
   EXPECT_CALL(registry_->mock_service(), Discover());
-  EXPECT_CALL(mock_observer_, OnDialDeviceEvent(expected_list2));
+  EXPECT_CALL(mock_observer_,
+              OnDialDeviceEvent(list_with_first_second_devices_));
   EXPECT_CALL(registry_->mock_service(),
               RemoveObserver(A<DialService::Observer*>()));
 
   registry_->OnListenerAdded();
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDiscoveryFinished(nullptr);
   registry_->OnListenerRemoved();
 }
 
 TEST_F(DialRegistryTest, TestNetworkEventConnectionLost) {
@@ skipping 65 matching lines @@
   registry_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 
   registry_->OnDiscoveryRequest(nullptr);
   registry_->OnDeviceDiscovered(nullptr, third_device_);
   registry_->OnDiscoveryFinished(nullptr);
 
   registry_->OnListenerRemoved();
 }
 
 }  // namespace media_router