Add DiscoveryNetworkMonitor implementation

chrome/browser/media/router/discovery/discovery_network_monitor_unittest.cc

Index: chrome/browser/media/router/discovery/discovery_network_monitor_unittest.cc
diff --git a/chrome/browser/media/router/discovery/discovery_network_monitor_unittest.cc b/chrome/browser/media/router/discovery/discovery_network_monitor_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f1f5378d98abf14afba8f4b1ba9d1d7755e48e10
--- /dev/null
+++ b/chrome/browser/media/router/discovery/discovery_network_monitor_unittest.cc
@@ -0,0 +1,171 @@
+// Copyright (c) 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/discovery/discovery_network_monitor.h"
+
+#include "base/run_loop.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+using content::BrowserThread;
+
+using testing::_;
+using testing::Invoke;
+
+class MockDiscoveryObserver : public DiscoveryNetworkMonitor::Observer {
+ public:
+  MOCK_METHOD1(OnNetworksChanged, void(const DiscoveryNetworkMonitor&));
+};
+
+class DiscoveryNetworkMonitorTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    fake_network_info.clear();
+    discovery_network_monitor->SetNetworkInfoFunctionForTest(
+        &FakeGetNetworkInfo);
+
+    // NetworkChangeNotifier provides singleton behavior while simultaneously

[imcheng, 2017/05/31 21:19:56]

Sorry if this has already been discussed -- can we just create a
DiscoveryNetworkMonitor instance in this test rather than using the singleton
instance?

[btolsch, 2017/06/05 22:38:33]

Done.

+    // allowing the creator to own the instance.  This makes it possible to
+    // reset it for each test, however this isn't possible with LazyInstance<>,
+    // which DiscoveryNetworkMonitor uses.  It's also not possible to just leave
+    // one NetworkChangeNotifier mock alive for all the tests because the thread
+    // bundle is being recreated in each fixture which causes their task runners
+    // to become different.
+    if (should_rebind_to_network_change_mock) {
+      discovery_network_monitor->RebindNetworkChangeObserverForTest();
+    } else {
+      should_rebind_to_network_change_mock = true;
+    }
+
+    // Clear the network info list and network ID before each test since the
+    // monitor is a singleton.
+    net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
+        net::NetworkChangeNotifier::CONNECTION_NONE);
+    base::RunLoop().RunUntilIdle();
+  }
+
+  static std::vector<DiscoveryNetworkInfo> FakeGetNetworkInfo() {
+    return fake_network_info;
+  }
+
+  static bool should_rebind_to_network_change_mock;
+
+  content::TestBrowserThreadBundle test_browser_thread_bundle;
+  MockDiscoveryObserver mock_observer;
+
+  std::vector<DiscoveryNetworkInfo> fake_ethernet_info{
+      {{std::string("enp0s2"), std::string("ethernet1")}}};
+  std::vector<DiscoveryNetworkInfo> fake_wifi_info{
+      {DiscoveryNetworkInfo{std::string("wlp3s0"), std::string("wifi1")},
+       DiscoveryNetworkInfo{std::string("wlp3s1"), std::string("wifi2")}}};
+
+  std::unique_ptr<net::NetworkChangeNotifier> network_change_notifier =
+      base::WrapUnique(net::NetworkChangeNotifier::CreateMock());
+
+  static std::vector<DiscoveryNetworkInfo> fake_network_info;
+  DiscoveryNetworkMonitor* discovery_network_monitor =
+      DiscoveryNetworkMonitor::GetInstance();
+};
+
+// static
+bool DiscoveryNetworkMonitorTest::should_rebind_to_network_change_mock = false;
+// static
+std::vector<DiscoveryNetworkInfo>
+    DiscoveryNetworkMonitorTest::fake_network_info;
+
+}  // namespace
+
+TEST_F(DiscoveryNetworkMonitorTest, NetworkIdIsConsistent) {
+  fake_network_info = fake_ethernet_info;
+  std::string current_network_id;
+
+  auto capture_network_id =
+      [&current_network_id](const DiscoveryNetworkMonitor& monitor) {
+        DCHECK_CURRENTLY_ON(BrowserThread::IO);
+        current_network_id = monitor.GetNetworkId();
+      };
+  discovery_network_monitor->AddObserver(&mock_observer);
+  EXPECT_CALL(mock_observer, OnNetworksChanged(_))
+      .WillOnce(Invoke(capture_network_id));
+
+  net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
+      net::NetworkChangeNotifier::CONNECTION_ETHERNET);
+  base::RunLoop().RunUntilIdle();
+
+  std::string ethernet_network_id = current_network_id;
+
+  fake_network_info.clear();
+  EXPECT_CALL(mock_observer, OnNetworksChanged(_))
+      .WillOnce(Invoke(capture_network_id));
+
+  net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
+      net::NetworkChangeNotifier::CONNECTION_NONE);
+  base::RunLoop().RunUntilIdle();
+
+  fake_network_info = fake_wifi_info;
+  EXPECT_CALL(mock_observer, OnNetworksChanged(_))
+      .WillOnce(Invoke(capture_network_id));
+
+  net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
+      net::NetworkChangeNotifier::CONNECTION_WIFI);
+  base::RunLoop().RunUntilIdle();
+
+  std::string wifi_network_id = current_network_id;
+  fake_network_info = fake_ethernet_info;
+  EXPECT_CALL(mock_observer, OnNetworksChanged(_))
+      .WillOnce(Invoke(capture_network_id));
+
+  net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
+      net::NetworkChangeNotifier::CONNECTION_ETHERNET);
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(ethernet_network_id, current_network_id);
+  EXPECT_NE(ethernet_network_id, wifi_network_id);
+
+  discovery_network_monitor->RemoveObserver(&mock_observer);
+}
+
+TEST_F(DiscoveryNetworkMonitorTest, RemoveObserverStopsNotifications) {
+  fake_network_info = fake_ethernet_info;
+
+  discovery_network_monitor->AddObserver(&mock_observer);
+  EXPECT_CALL(mock_observer, OnNetworksChanged(_))
+      .WillOnce(Invoke([](const DiscoveryNetworkMonitor& monitor) {
+        DCHECK_CURRENTLY_ON(BrowserThread::IO);
+      }));
+
+  net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
+      net::NetworkChangeNotifier::CONNECTION_ETHERNET);
+  base::RunLoop().RunUntilIdle();
+
+  discovery_network_monitor->RemoveObserver(&mock_observer);
+  fake_network_info.clear();
+
+  net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
+      net::NetworkChangeNotifier::CONNECTION_NONE);
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(DiscoveryNetworkMonitorTest, RefreshIndependentOfChangeObserver) {
+  fake_network_info = fake_ethernet_info;
+
+  discovery_network_monitor->AddObserver(&mock_observer);
+  auto force_refresh_callback = []() {
+    DiscoveryNetworkMonitor* discovery_network_monitor =
+        DiscoveryNetworkMonitor::GetInstance();
+    EXPECT_NE(std::string(DiscoveryNetworkMonitor::kNetworkIdDisconnected),
+              discovery_network_monitor->GetNetworkId());
+    EXPECT_NE(std::string(DiscoveryNetworkMonitor::kNetworkIdUnknown),
+              discovery_network_monitor->GetNetworkId());
+  };
+
+  EXPECT_EQ(std::string(DiscoveryNetworkMonitor::kNetworkIdDisconnected),
+            discovery_network_monitor->GetNetworkId());
+  discovery_network_monitor->Refresh(base::Bind(force_refresh_callback));
+  base::RunLoop().RunUntilIdle();
+}