Add DiscoveryNetworkMonitor implementation

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

Index: chrome/browser/media/router/discovery/discovery_network_list_unittest.cc
diff --git a/chrome/browser/media/router/discovery/discovery_network_list_unittest.cc b/chrome/browser/media/router/discovery/discovery_network_list_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..98814796e30a91b882ba9dbd2f6207ff80867f47
--- /dev/null
+++ b/chrome/browser/media/router/discovery/discovery_network_list_unittest.cc
@@ -0,0 +1,32 @@
+// 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_list.h"
+
+#include <algorithm>
+#include <iterator>
+#include <set>
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+TEST(DiscoveryNetworkListTest, GetDiscoveryNetworkInfoList) {

[mark a. foltz, 2017/06/05 21:28:42]

I am debating if this unit test is worth writing.  The first part of the test is
really sanity checking the output of the syscall and not testing our code.  For
example if this first part failed how could we fix it?

The second part is testing whether the stable sort is correct and there is some
value in that.  Can the part that does the stable sort be factored out into its
own function so it can be fed a list without making the syscall?

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

The first part makes sure that our code isn't returning empty interface names or
empty network ids (for which I have loop breaks/continues).  If it fails then I
missed some condition which will cause our code to return an empty interface
name or network id.

The slightly strange part about this is that while this test is passing, we can
never get a network id of unknown from the monitor.  Maybe the empty test should
only be on the interface name?

The second part tests the stable sort but also that we only get at most one
entry per interface (i.e. not like GetNetworkList).

For now, I removed the network id emptiness test, factored out the stable sort
so it can be tested separately as well, but otherwise left this test alone.

+  auto network_ids = GetDiscoveryNetworkInfoList();
+  for (const auto& network_id : network_ids) {
+    // We can't mock out the OS layer used by GetDiscoveryNetworkIdList, so
+    // instead just check that each returned interface name and ID is non-empty.
+    EXPECT_FALSE(network_id.name.empty());
+    EXPECT_FALSE(network_id.network_id.empty());
+  }
+
+  // Also check that at most one ID is returned per interface name.
+  std::set<std::string> interface_name_set;
+  std::transform(begin(network_ids), end(network_ids),
+                 std::insert_iterator<std::set<std::string>>{
+                     interface_name_set, end(interface_name_set)},
+                 [](const DiscoveryNetworkInfo& network_info) {
+                   return network_info.name;
+                 });
+
+  EXPECT_EQ(interface_name_set.size(), network_ids.size());
+}