| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include <stddef.h> | |
| 6 | |
| 7 #include "base/memory/ptr_util.h" | |
| 8 #include "chrome/browser/extensions/api/dial/dial_device_data.h" | |
| 9 #include "chrome/browser/extensions/api/dial/dial_registry.h" | |
| 10 #include "chrome/browser/extensions/api/dial/dial_service.h" | |
| 11 #include "chrome/test/base/testing_profile.h" | |
| 12 #include "content/public/test/test_browser_thread_bundle.h" | |
| 13 #include "testing/gmock/include/gmock/gmock.h" | |
| 14 #include "testing/gtest/include/gtest/gtest.h" | |
| 15 #include "url/gurl.h" | |
| 16 | |
| 17 using base::Time; | |
| 18 using base::TimeDelta; | |
| 19 using ::testing::A; | |
| 20 using ::testing::AtLeast; | |
| 21 using ::testing::Return; | |
| 22 using ::testing::InSequence; | |
| 23 | |
| 24 namespace extensions { | |
| 25 namespace api { | |
| 26 namespace dial { | |
| 27 | |
| 28 class MockDialObserver : public DialRegistry::Observer { | |
| 29 public: | |
| 30 ~MockDialObserver() override {} | |
| 31 | |
| 32 MOCK_METHOD1(OnDialDeviceEvent, | |
| 33 void(const DialRegistry::DeviceList& devices)); | |
| 34 MOCK_METHOD1(OnDialError, void(DialRegistry::DialErrorCode type)); | |
| 35 }; | |
| 36 | |
| 37 class MockDialService : public DialService { | |
| 38 public: | |
| 39 ~MockDialService() override {} | |
| 40 | |
| 41 MOCK_METHOD0(Discover, bool()); | |
| 42 MOCK_METHOD1(AddObserver, void(DialService::Observer*)); | |
| 43 MOCK_METHOD1(RemoveObserver, void(DialService::Observer*)); | |
| 44 MOCK_CONST_METHOD1(HasObserver, bool(const DialService::Observer*)); | |
| 45 }; | |
| 46 | |
| 47 class MockDialRegistry : public DialRegistry { | |
| 48 public: | |
| 49 MockDialRegistry(const base::TimeDelta& refresh_interval, | |
| 50 const base::TimeDelta& expiration, | |
| 51 const size_t max_devices) | |
| 52 : DialRegistry(refresh_interval, expiration, max_devices), | |
| 53 time_(Time::Now()) {} | |
| 54 | |
| 55 ~MockDialRegistry() override { | |
| 56 // Don't let the DialRegistry delete this. | |
| 57 DialService* tmp = dial_.release(); | |
| 58 if (tmp) | |
| 59 CHECK_EQ(&mock_service_, tmp); | |
| 60 } | |
| 61 | |
| 62 // Returns the mock Dial service. | |
| 63 MockDialService& mock_service() { | |
| 64 return mock_service_; | |
| 65 } | |
| 66 | |
| 67 void set_time(Time time) { time_ = time; } | |
| 68 | |
| 69 protected: | |
| 70 base::Time Now() const override { return time_; } | |
| 71 | |
| 72 std::unique_ptr<DialService> CreateDialService() override { | |
| 73 return base::WrapUnique(&mock_service_); | |
| 74 } | |
| 75 | |
| 76 void ClearDialService() override { | |
| 77 // Release the pointer but don't delete the object because the test owns it. | |
| 78 CHECK_EQ(&mock_service_, dial_.release()); | |
| 79 } | |
| 80 | |
| 81 private: | |
| 82 MockDialService mock_service_; | |
| 83 | |
| 84 // Set to mock out the current time. | |
| 85 Time time_; | |
| 86 }; | |
| 87 | |
| 88 class DialRegistryTest : public testing::Test { | |
| 89 public: | |
| 90 DialRegistryTest() | |
| 91 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), | |
| 92 first_device_("first", GURL("http://127.0.0.1/dd.xml"), Time::Now()), | |
| 93 second_device_("second", GURL("http://127.0.0.2/dd.xml"), Time::Now()), | |
| 94 third_device_("third", GURL("http://127.0.0.3/dd.xml"), Time::Now()) { | |
| 95 registry_ = base::MakeUnique<MockDialRegistry>( | |
| 96 TimeDelta::FromSeconds(1000), TimeDelta::FromSeconds(10), 10); | |
| 97 registry_->RegisterObserver(&mock_observer_); | |
| 98 list_with_first_device_.push_back(first_device_); | |
| 99 list_with_second_device_.push_back(second_device_); | |
| 100 } | |
| 101 | |
| 102 protected: | |
| 103 void SetListenerExpectations() { | |
| 104 EXPECT_CALL(registry_->mock_service(), | |
| 105 AddObserver(A<DialService::Observer*>())); | |
| 106 EXPECT_CALL(registry_->mock_service(), | |
| 107 RemoveObserver(A<DialService::Observer*>())); | |
| 108 } | |
| 109 | |
| 110 content::TestBrowserThreadBundle thread_bundle_; | |
| 111 std::unique_ptr<MockDialRegistry> registry_; | |
| 112 MockDialObserver mock_observer_; | |
| 113 const DialDeviceData first_device_; | |
| 114 const DialDeviceData second_device_; | |
| 115 const DialDeviceData third_device_; | |
| 116 | |
| 117 const DialRegistry::DeviceList empty_list_; | |
| 118 DialRegistry::DeviceList list_with_first_device_; | |
| 119 DialRegistry::DeviceList list_with_second_device_; | |
| 120 }; | |
| 121 | |
| 122 TEST_F(DialRegistryTest, TestAddRemoveListeners) { | |
| 123 SetListenerExpectations(); | |
| 124 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 125 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)).Times(2); | |
| 126 | |
| 127 EXPECT_FALSE(registry_->repeating_timer_.IsRunning()); | |
| 128 registry_->OnListenerAdded(); | |
| 129 EXPECT_TRUE(registry_->repeating_timer_.IsRunning()); | |
| 130 registry_->OnListenerAdded(); | |
| 131 EXPECT_TRUE(registry_->repeating_timer_.IsRunning()); | |
| 132 registry_->OnListenerRemoved(); | |
| 133 EXPECT_TRUE(registry_->repeating_timer_.IsRunning()); | |
| 134 registry_->OnListenerRemoved(); | |
| 135 EXPECT_FALSE(registry_->repeating_timer_.IsRunning()); | |
| 136 } | |
| 137 | |
| 138 TEST_F(DialRegistryTest, TestNoDevicesDiscovered) { | |
| 139 SetListenerExpectations(); | |
| 140 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); | |
| 141 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 142 | |
| 143 registry_->OnListenerAdded(); | |
| 144 registry_->OnDiscoveryRequest(nullptr); | |
| 145 registry_->OnDiscoveryFinished(nullptr); | |
| 146 registry_->OnListenerRemoved(); | |
| 147 } | |
| 148 | |
| 149 TEST_F(DialRegistryTest, TestDevicesDiscovered) { | |
| 150 DialRegistry::DeviceList expected_list2; | |
| 151 expected_list2.push_back(first_device_); | |
| 152 expected_list2.push_back(second_device_); | |
| 153 | |
| 154 SetListenerExpectations(); | |
| 155 InSequence s; | |
| 156 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 157 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); | |
| 158 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)); | |
| 159 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 160 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(expected_list2)); | |
| 161 | |
| 162 registry_->OnListenerAdded(); | |
| 163 registry_->OnDiscoveryRequest(nullptr); | |
| 164 registry_->OnDeviceDiscovered(nullptr, first_device_); | |
| 165 registry_->OnDiscoveryFinished(nullptr); | |
| 166 | |
| 167 registry_->DoDiscovery(); | |
| 168 registry_->OnDiscoveryRequest(nullptr); | |
| 169 registry_->OnDeviceDiscovered(nullptr, second_device_); | |
| 170 registry_->OnDiscoveryFinished(nullptr); | |
| 171 registry_->OnListenerRemoved(); | |
| 172 } | |
| 173 | |
| 174 TEST_F(DialRegistryTest, TestDevicesDiscoveredWithTwoListeners) { | |
| 175 DialRegistry::DeviceList expected_list2; | |
| 176 expected_list2.push_back(first_device_); | |
| 177 expected_list2.push_back(second_device_); | |
| 178 | |
| 179 SetListenerExpectations(); | |
| 180 InSequence s; | |
| 181 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 182 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); | |
| 183 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)) | |
| 184 .Times(2); | |
| 185 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 186 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(expected_list2)); | |
| 187 | |
| 188 registry_->OnListenerAdded(); | |
| 189 registry_->OnDiscoveryRequest(nullptr); | |
| 190 registry_->OnDeviceDiscovered(nullptr, first_device_); | |
| 191 registry_->OnDiscoveryFinished(nullptr); | |
| 192 | |
| 193 registry_->OnListenerAdded(); | |
| 194 | |
| 195 registry_->DoDiscovery(); | |
| 196 registry_->OnDiscoveryRequest(nullptr); | |
| 197 registry_->OnDeviceDiscovered(nullptr, second_device_); | |
| 198 registry_->OnDiscoveryFinished(nullptr); | |
| 199 registry_->OnListenerRemoved(); | |
| 200 registry_->OnListenerRemoved(); | |
| 201 } | |
| 202 | |
| 203 TEST_F(DialRegistryTest, TestDeviceExpires) { | |
| 204 SetListenerExpectations(); | |
| 205 InSequence s; | |
| 206 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 207 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); | |
| 208 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)); | |
| 209 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 210 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); | |
| 211 | |
| 212 registry_->OnListenerAdded(); | |
| 213 registry_->OnDiscoveryRequest(nullptr); | |
| 214 registry_->OnDeviceDiscovered(nullptr, first_device_); | |
| 215 registry_->OnDiscoveryFinished(nullptr); | |
| 216 | |
| 217 registry_->set_time(Time::Now() + TimeDelta::FromSeconds(30)); | |
| 218 | |
| 219 registry_->DoDiscovery(); | |
| 220 registry_->OnDiscoveryRequest(nullptr); | |
| 221 registry_->OnDiscoveryFinished(nullptr); | |
| 222 registry_->OnListenerRemoved(); | |
| 223 } | |
| 224 | |
| 225 TEST_F(DialRegistryTest, TestExpiredDeviceIsRediscovered) { | |
| 226 std::vector<Time> discovery_times; | |
| 227 discovery_times.push_back(Time::Now()); | |
| 228 discovery_times.push_back(discovery_times[0] + TimeDelta::FromSeconds(30)); | |
| 229 discovery_times.push_back(discovery_times[1] + TimeDelta::FromSeconds(30)); | |
| 230 | |
| 231 DialDeviceData rediscovered_device("first", | |
| 232 GURL("http://127.0.0.1/dd.xml"), | |
| 233 discovery_times[2]); | |
| 234 | |
| 235 SetListenerExpectations(); | |
| 236 | |
| 237 InSequence s; | |
| 238 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 239 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); | |
| 240 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)); | |
| 241 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 242 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); | |
| 243 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 244 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)); | |
| 245 | |
| 246 registry_->set_time(discovery_times[0]); | |
| 247 registry_->OnListenerAdded(); | |
| 248 registry_->OnDiscoveryRequest(nullptr); | |
| 249 registry_->OnDeviceDiscovered(nullptr, first_device_); | |
| 250 registry_->OnDiscoveryFinished(nullptr); | |
| 251 | |
| 252 // Will expire "first" device as it is not discovered this time. | |
| 253 registry_->set_time(discovery_times[1]); | |
| 254 registry_->DoDiscovery(); | |
| 255 registry_->OnDiscoveryRequest(nullptr); | |
| 256 registry_->OnDiscoveryFinished(nullptr); | |
| 257 | |
| 258 // "first" device is rediscovered 30 seconds later. We pass a device object | |
| 259 // with a newer discovery time so it is not pruned immediately. | |
| 260 registry_->set_time(discovery_times[2]); | |
| 261 registry_->DoDiscovery(); | |
| 262 registry_->OnDiscoveryRequest(nullptr); | |
| 263 registry_->OnDeviceDiscovered(nullptr, rediscovered_device); | |
| 264 registry_->OnDiscoveryFinished(nullptr); | |
| 265 | |
| 266 registry_->OnListenerRemoved(); | |
| 267 } | |
| 268 | |
| 269 TEST_F(DialRegistryTest, TestRemovingListenerDoesNotClearList) { | |
| 270 DialRegistry::DeviceList expected_list2; | |
| 271 expected_list2.push_back(first_device_); | |
| 272 expected_list2.push_back(second_device_); | |
| 273 | |
| 274 InSequence s; | |
| 275 EXPECT_CALL(registry_->mock_service(), | |
| 276 AddObserver(A<DialService::Observer*>())); | |
| 277 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 278 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); | |
| 279 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(expected_list2)); | |
| 280 EXPECT_CALL(registry_->mock_service(), | |
| 281 RemoveObserver(A<DialService::Observer*>())); | |
| 282 | |
| 283 registry_->OnListenerAdded(); | |
| 284 registry_->OnDiscoveryRequest(nullptr); | |
| 285 registry_->OnDeviceDiscovered(nullptr, first_device_); | |
| 286 registry_->OnDeviceDiscovered(nullptr, second_device_); | |
| 287 registry_->OnDiscoveryFinished(nullptr); | |
| 288 registry_->OnListenerRemoved(); | |
| 289 | |
| 290 // Removing and adding a listener again fires an event with the current device | |
| 291 // list (even though no new devices were discovered). | |
| 292 EXPECT_CALL(registry_->mock_service(), | |
| 293 AddObserver(A<DialService::Observer*>())); | |
| 294 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 295 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(expected_list2)); | |
| 296 EXPECT_CALL(registry_->mock_service(), | |
| 297 RemoveObserver(A<DialService::Observer*>())); | |
| 298 | |
| 299 registry_->OnListenerAdded(); | |
| 300 registry_->OnDiscoveryRequest(nullptr); | |
| 301 registry_->OnDiscoveryFinished(nullptr); | |
| 302 registry_->OnListenerRemoved(); | |
| 303 } | |
| 304 | |
| 305 TEST_F(DialRegistryTest, TestNetworkEventConnectionLost) { | |
| 306 SetListenerExpectations(); | |
| 307 | |
| 308 InSequence s; | |
| 309 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 310 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); | |
| 311 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)); | |
| 312 EXPECT_CALL(mock_observer_, | |
| 313 OnDialError(DialRegistry::DIAL_NETWORK_DISCONNECTED)); | |
| 314 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); | |
| 315 | |
| 316 registry_->OnListenerAdded(); | |
| 317 registry_->OnDiscoveryRequest(nullptr); | |
| 318 registry_->OnDeviceDiscovered(nullptr, first_device_); | |
| 319 registry_->OnDiscoveryFinished(nullptr); | |
| 320 | |
| 321 registry_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_NONE); | |
| 322 | |
| 323 registry_->OnDiscoveryRequest(nullptr); | |
| 324 registry_->OnDiscoveryFinished(nullptr); | |
| 325 registry_->OnListenerRemoved(); | |
| 326 } | |
| 327 | |
| 328 TEST_F(DialRegistryTest, TestNetworkEventConnectionRestored) { | |
| 329 DialRegistry::DeviceList expected_list3; | |
| 330 expected_list3.push_back(second_device_); | |
| 331 expected_list3.push_back(third_device_); | |
| 332 | |
| 333 // A disconnection should shutdown the DialService, so we expect the observer | |
| 334 // to be added twice. | |
| 335 EXPECT_CALL(registry_->mock_service(), | |
| 336 AddObserver(A<DialService::Observer*>())) | |
| 337 .Times(2); | |
| 338 EXPECT_CALL(registry_->mock_service(), | |
| 339 RemoveObserver(A<DialService::Observer*>())) | |
| 340 .Times(2); | |
| 341 | |
| 342 InSequence s; | |
| 343 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 344 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); | |
| 345 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)); | |
| 346 | |
| 347 EXPECT_CALL(mock_observer_, | |
| 348 OnDialError(DialRegistry::DIAL_NETWORK_DISCONNECTED)); | |
| 349 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); | |
| 350 | |
| 351 EXPECT_CALL(registry_->mock_service(), Discover()); | |
| 352 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_second_device_)); | |
| 353 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(expected_list3)); | |
| 354 | |
| 355 registry_->OnListenerAdded(); | |
| 356 registry_->OnDiscoveryRequest(nullptr); | |
| 357 registry_->OnDeviceDiscovered(nullptr, first_device_); | |
| 358 registry_->OnDiscoveryFinished(nullptr); | |
| 359 | |
| 360 registry_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_NONE); | |
| 361 | |
| 362 registry_->OnDiscoveryRequest(nullptr); | |
| 363 registry_->OnDiscoveryFinished(nullptr); | |
| 364 | |
| 365 registry_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_WIFI); | |
| 366 | |
| 367 registry_->OnDiscoveryRequest(nullptr); | |
| 368 registry_->OnDeviceDiscovered(nullptr, second_device_); | |
| 369 registry_->OnDiscoveryFinished(nullptr); | |
| 370 | |
| 371 registry_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET); | |
| 372 | |
| 373 registry_->OnDiscoveryRequest(nullptr); | |
| 374 registry_->OnDeviceDiscovered(nullptr, third_device_); | |
| 375 registry_->OnDiscoveryFinished(nullptr); | |
| 376 | |
| 377 registry_->OnListenerRemoved(); | |
| 378 } | |
| 379 | |
| 380 } // namespace dial | |
| 381 } // namespace api | |
| 382 } // namespace extensions | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2756483007:
[Device Discovery] Move files from browser/extensions/api/dial to browser/media/router/discovery/di… (Closed)
