[Media Router] Add DialMediaSinkService and DeviceDescriptionService

chrome/browser/media/router/dial_media_sink_service_unittest.cc

Index: chrome/browser/media/router/dial_media_sink_service_unittest.cc
diff --git a/chrome/browser/media/router/dial_media_sink_service_unittest.cc b/chrome/browser/media/router/dial_media_sink_service_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..21b00706f9ddab2032afb583b167d230d0f50133
--- /dev/null
+++ b/chrome/browser/media/router/dial_media_sink_service_unittest.cc
@@ -0,0 +1,182 @@
+// Copyright 2017 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 "chrome/browser/media/router/dial_media_sink_service.h"
+#include "base/test/mock_callback.h"
+#include "chrome/browser/extensions/api/dial/dial_device_data.h"
+#include "chrome/browser/media/router/mock_device_description_service.h"
+#include "chrome/browser/media/router/test_helper.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"
+
+using ::testing::_;
+using ::testing::Return;
+
+using DialRegistry = extensions::api::dial::DialRegistry;
+using DialDeviceData = extensions::api::dial::DialDeviceData;
+
+namespace media_router {
+
+class MockDialRegistry : public DialRegistry {
+ public:
+  MockDialRegistry()
+      : DialRegistry(base::TimeDelta::FromSeconds(2),
+                     base::TimeDelta::FromSeconds(5),
+                     10) {}
+
+  MOCK_METHOD1(RegisterObserver, void(DialRegistry::Observer* observer));
+  MOCK_METHOD1(UnregisterObserver, void(DialRegistry::Observer* observer));
+};
+
+class MockDialMediaSinkCacheService : public DialMediaSinkCacheService {
+ public:
+  MOCK_METHOD0(GetAliveSinks, std::vector<MediaSinkInternal>());
+};
+
+class TestDialMediaSinkService : public DialMediaSinkService {
+ public:
+  TestDialMediaSinkService(
+      const MediaSinkService::OnSinksDiscoveredCallback& callback,
+      content::BrowserContext* browser_context,
+      MockDialRegistry* mock_dial_registry,
+      MockDeviceDescriptionService* mock_description_service,
+      MockDialMediaSinkCacheService* mock_cache_service)
+      : DialMediaSinkService(callback, browser_context),
+        mock_dial_registry_(mock_dial_registry),
+        mock_description_service_(mock_description_service),
+        mock_cache_service_(mock_cache_service) {}
+
+  DialRegistry* dial_registry() override { return mock_dial_registry_; }
+
+  DeviceDescriptionService* description_service() override {
+    return mock_description_service_;
+  }
+
+  DialMediaSinkCacheService* cache_service() override {
+    return mock_cache_service_;
+  }
+
+ private:
+  MockDialRegistry* mock_dial_registry_;
+  MockDeviceDescriptionService* mock_description_service_;
+  MockDialMediaSinkCacheService* mock_cache_service_;
+};
+
+class DialMediaSinkServiceTest : public ::testing::Test {
+ public:
+  DialMediaSinkServiceTest()
+      : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
+        mock_description_service_(&mock_description_service_observer_),
+        media_sink_service_(mock_sink_discovered_cb_.Get(),
+                            &profile_,
+                            &mock_dial_registry_,
+                            &mock_description_service_,
+                            &mock_cache_service_) {}
+
+  DialMediaSinkService* media_sink_service() { return &media_sink_service_; }
+
+ protected:
+  const content::TestBrowserThreadBundle thread_bundle_;
+  TestingProfile profile_;
+
+  base::MockCallback<MediaSinkService::OnSinksDiscoveredCallback>
+      mock_sink_discovered_cb_;
+
+  MockDialRegistry mock_dial_registry_;
+  MockDeviceDescriptionServiceObserver mock_description_service_observer_;
+  MockDeviceDescriptionService mock_description_service_;
+  MockDialMediaSinkCacheService mock_cache_service_;
+
+  TestDialMediaSinkService media_sink_service_;
+};
+
+TEST_F(DialMediaSinkServiceTest, TestStart) {
+  EXPECT_CALL(mock_dial_registry_, RegisterObserver(&media_sink_service_));
+  media_sink_service()->Start();
+
+  DialRegistry::DeviceList deviceList;
+  DialDeviceData first_device("first", GURL("http://127.0.0.1/dd.xml"),
+                              base::Time::Now());
+  DialDeviceData second_device("second", GURL("http://127.0.0.2/dd.xml"),
+                               base::Time::Now());
+  DialDeviceData third_device("third", GURL("http://127.0.0.3/dd.xml"),
+                              base::Time::Now());
+  deviceList.push_back(first_device);
+  deviceList.push_back(second_device);
+  deviceList.push_back(third_device);
+
+  for (const auto& device : deviceList)
+    EXPECT_CALL(mock_description_service_, GetDeviceDescription(device, _, _));
+
+  media_sink_service()->OnDialDeviceEvent(deviceList);
+  EXPECT_TRUE(media_sink_service_.finish_timer_.IsRunning());
+}
+
+TEST_F(DialMediaSinkServiceTest, TestFetchCompleted) {
+  MediaSink sink1("sink1", "sink_name_1", MediaSink::IconType::CAST);
+  DialSinkExtraData extra_data1("192.168.1.1", "model_name1",
+                                "https://example1.com");
+
+  MediaSink sink2("sink2", "sink_name_2", MediaSink::IconType::CAST);
+  DialSinkExtraData extra_data2("192.168.1.2", "model_name2",
+                                "https://example2.com");
+
+  std::vector<MediaSinkInternal> sinks;
+  sinks.push_back(MediaSinkInternal(sink1, extra_data1));
+  sinks.push_back(MediaSinkInternal(sink2, extra_data2));
+
+  EXPECT_CALL(mock_cache_service_, GetAliveSinks())
+      .WillRepeatedly(Return(sinks));
+  EXPECT_CALL(mock_sink_discovered_cb_, Run(sinks));
+  media_sink_service()->FetchCompleted();
+
+  EXPECT_CALL(mock_sink_discovered_cb_, Run(_)).Times(0);
+  media_sink_service()->FetchCompleted();
+}
+
+TEST_F(DialMediaSinkServiceTest, TestIsDifferent) {
+  MediaSink sink1("sink1", "sink_name_1", MediaSink::IconType::CAST);
+  DialSinkExtraData extra_data1("192.168.1.1", "model_name1",
+                                "https://example1.com");
+
+  MediaSink sink2("sink2", "sink_name_2", MediaSink::IconType::CAST);
+  DialSinkExtraData extra_data2("192.168.1.2", "model_name2",
+                                "https://example2.com");
+
+  std::vector<MediaSinkInternal> old_sinks;
+  old_sinks.push_back(MediaSinkInternal(sink1, extra_data1));
+  old_sinks.push_back(MediaSinkInternal(sink2, extra_data2));
+
+  // The same sinks.
+  std::vector<MediaSinkInternal> new_sinks1(old_sinks);
+  ASSERT_FALSE(media_sink_service()->IsDifferent(new_sinks1, old_sinks));
+
+  // Add a new sink to new_sinks.
+  std::vector<MediaSinkInternal> new_sinks2(old_sinks);
+  MediaSink sink3("sink3", "sink_name_3", MediaSink::IconType::CAST);
+  DialSinkExtraData extra_data3("192.168.1.3", "model_name3",
+                                "https://example3.com");
+
+  new_sinks2.push_back(MediaSinkInternal(sink3, extra_data3));
+  ASSERT_TRUE(media_sink_service()->IsDifferent(new_sinks2, old_sinks));
+
+  // Remove a sink from new_sinks.
+  std::vector<MediaSinkInternal> new_sinks3(old_sinks);
+  new_sinks3.erase(new_sinks3.begin());
+  ASSERT_TRUE(media_sink_service()->IsDifferent(new_sinks3, old_sinks));
+
+  // updated a sink from new_sinks
+  std::vector<MediaSinkInternal> new_sinks4(old_sinks);
+  new_sinks4[0].set_name("sink_name_4");
+  ASSERT_TRUE(media_sink_service()->IsDifferent(new_sinks4, old_sinks));
+
+  // Combined add, remove and update
+  std::vector<MediaSinkInternal> new_sinks5;
+  new_sinks5.push_back(MediaSinkInternal(sink1, extra_data2));
+  new_sinks5.push_back(MediaSinkInternal(sink3, extra_data3));
+  ASSERT_TRUE(media_sink_service()->IsDifferent(new_sinks5, old_sinks));
+}
+
+}  // namespace media_router