Add DiscoveryNetworkMonitor implementation

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

Index: chrome/browser/media/router/discovery/discovery_network_monitor.cc
diff --git a/chrome/browser/media/router/discovery/discovery_network_monitor.cc b/chrome/browser/media/router/discovery/discovery_network_monitor.cc
new file mode 100644
index 0000000000000000000000000000000000000000..51c9d260f92b2cb5881d858bfc53a0b49111c8ba
--- /dev/null
+++ b/chrome/browser/media/router/discovery/discovery_network_monitor.cc
@@ -0,0 +1,203 @@
+// 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/lazy_instance.h"
+#include "base/logging.h"
+#include "base/sha1.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "chrome/browser/media/router/discovery/discovery_network_list.h"
+#include "net/base/network_interfaces.h"
+
+namespace {
+
+using content::BrowserThread;
+
+std::vector<NetworkInfo> GetNetworkInfo() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  net::NetworkInterfaceList interface_list;
+  if (!net::GetNetworkList(&interface_list,
+                           net::INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES)) {
+    DVLOG(2) << "net::GetNetworkList failed after a network change event";
+    return std::vector<NetworkInfo>();
+  }
+
+  std::map<std::string, NetworkInfo> network_info_map;
+  for (const auto& interface : interface_list) {
+    if (interface.type != net::NetworkChangeNotifier::CONNECTION_ETHERNET &&
+        interface.type != net::NetworkChangeNotifier::CONNECTION_WIFI) {
+      continue;
+    }
+    // Skip duplicate addresses for the same interface.
+    if (network_info_map.find(interface.name) != network_info_map.end()) {
+      continue;
+    }
+    network_info_map.insert(std::make_pair(
+        interface.name, NetworkInfo{interface.interface_index, interface.type,
+                                    interface.name, std::string("")}));
+  }
+
+  auto network_ids = GetDiscoveryNetworkIdList();
+  for (const auto& network_id : network_ids) {
+    auto matching_info_it = network_info_map.find(network_id.interface_name);
+    if (matching_info_it != end(network_info_map)) {
+      matching_info_it->second.network_id = network_id.network_id;
+    }
+  }
+
+  std::vector<NetworkInfo> network_info_list;
+  std::transform(network_info_map.begin(), network_info_map.end(),
+                 std::back_inserter(network_info_list),
+                 [](const decltype(network_info_map)::value_type& entry) {
+                   return entry.second;
+                 });
+  return network_info_list;
+}
+
+base::LazyInstance<DiscoveryNetworkMonitor>::Leaky g_discovery_monitor;
+
+}  // namespace
+
+NetworkInfo::NetworkInfo() {}
+
+NetworkInfo::NetworkInfo(
+    uint32_t index,
+    net::NetworkChangeNotifier::ConnectionType connection_type,
+    std::string name,
+    std::string network_id)
+    : index(index),
+      connection_type(connection_type),
+      name(name),
+      network_id(network_id) {}
+
+NetworkInfo::NetworkInfo(const NetworkInfo&) = default;
+
+NetworkInfo& NetworkInfo::operator=(const NetworkInfo&) = default;
+
+bool NetworkInfo::operator==(const NetworkInfo& o) const {
+  return index == o.index && connection_type == o.connection_type &&
+         name == o.name && network_id == o.network_id;
+}
+
+bool NetworkInfo::operator!=(const NetworkInfo& o) const {
+  return !(*this == o);
+}
+
+DiscoveryNetworkMonitor::DiscoveryNetworkMonitor()
+    : network_id_(kNetworkIdDisconnected),
+      observers_(new base::ObserverListThreadSafe<Observer>(
+          base::ObserverListThreadSafe<
+              Observer>::NotificationType::NOTIFY_EXISTING_ONLY)) {
+  net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
+}
+
+DiscoveryNetworkMonitor::~DiscoveryNetworkMonitor() {
+  net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
+}
+
+// static
+DiscoveryNetworkMonitor* DiscoveryNetworkMonitor::GetInstance() {
+  DiscoveryNetworkMonitor* monitor = g_discovery_monitor.Pointer();
+  if (!monitor->network_info_callback_) {
+    monitor->network_info_callback_ = base::Bind(&GetNetworkInfo);
+  }
+  return monitor;
+}
+
+// static
+DiscoveryNetworkMonitor* DiscoveryNetworkMonitor::GetInstanceForTest(
+    NetworkInfoCallback strategy) {
+  DiscoveryNetworkMonitor* monitor = g_discovery_monitor.Pointer();
+  monitor->network_info_callback_ = std::move(strategy);
+  return monitor;
+}
+
+void DiscoveryNetworkMonitor::RebindNetworkChangeObserverForTest() {
+  net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
+}
+
+void DiscoveryNetworkMonitor::AddObserver(Observer* const observer) {
+  observers_->AddObserver(observer);
+}
+
+void DiscoveryNetworkMonitor::RemoveObserver(Observer* const observer) {
+  observers_->RemoveObserver(observer);
+}
+
+void DiscoveryNetworkMonitor::Refresh(NetworkRefreshCompleteCallback callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&DiscoveryNetworkMonitor::UpdateNetworkInfo,
+                 base::Unretained(this), callback));
+}
+
+void DiscoveryNetworkMonitor::OnNetworkChanged(
+    net::NetworkChangeNotifier::ConnectionType) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&DiscoveryNetworkMonitor::UpdateNetworkInfo,
+                 base::Unretained(this), NetworkRefreshCompleteCallback()));
+}
+
+// static
+const char DiscoveryNetworkMonitor::kNetworkIdDisconnected[] = "disconnected";
+// static
+const char DiscoveryNetworkMonitor::kNetworkIdUnknown[] = "unknown";
+
+std::string DiscoveryNetworkMonitor::ComputeNetworkId(
+    const std::vector<NetworkInfo>& network_info_list) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (network_info_list.size() == 0) {
+    return kNetworkIdDisconnected;
+  }
+  std::string network_ids;
+  for (const auto& network_info : network_info_list) {
+    network_ids += network_info.network_id;
+  }
+  if (network_ids.size() == 0) {
+    return kNetworkIdUnknown;
+  }
+
+  std::vector<std::string> id_list;
+  std::transform(
+      network_info_list.begin(), network_info_list.end(),
+      std::back_inserter(id_list),
+      [](const NetworkInfo& network_info) { return network_info.network_id; });
+  std::sort(id_list.begin(), id_list.end());
+  std::string combined_ids;
+  for (const auto& id : id_list) {
+    combined_ids = combined_ids + "!" + id;
+  }
+
+  std::string hash = base::SHA1HashString(combined_ids);
+  return base::ToLowerASCII(base::HexEncode(hash.data(), hash.length()));
+}
+
+void DiscoveryNetworkMonitor::UpdateNetworkInfo(
+    const NetworkRefreshCompleteCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  auto network_info_list = network_info_callback_.Run();
+  auto network_id = ComputeNetworkId(network_info_list);
+
+  networks_.swap(network_info_list);
+  network_id_.swap(network_id);
+
+  if (!std::is_permutation(networks_.begin(), networks_.end(),
+                           network_info_list.begin())) {
+    observers_->Notify(FROM_HERE, &Observer::OnNetworksChanged,
+                       base::ConstRef(*this));
+  }
+  if (callback) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
+  }
+}