Add DiscoveryNetworkMonitor implementation

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

+// 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)) {

[mark a. foltz, 2017/05/04 23:16:42]

Can you add a comment explaining this flag?

[btolsch, 2017/05/23 08:55:02]

This is removed as I'm no longer using GetNetworkList at all.

+    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;
+    }

[mark a. foltz, 2017/05/04 23:16:41]

Beyond checking that there is at least one ETHERNET or WIFI interface, I'm not
sure I follow why we need to return information from |interface_list| and
combine it with the network_id_list.

[btolsch, 2017/05/23 08:55:02]

This served two purposes: populating |networks_| (which I now realize is no
longer publicly accessible so isn't important) and checking which interfaces are
up.  The latter can actually be accomplished in GetDiscoveryNetworkIdList, so
all this is removed.

+    // 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,

[mark a. foltz, 2017/05/04 23:16:41]

I don't think this is needed to compute the network_id.  Just drop
network_info_map?

[btolsch, 2017/05/23 08:55:02]

Done.

+                                    interface.name, std::string("")}));
+  }
+

[mark a. foltz, 2017/05/04 23:16:39]

If network_info_map is empty, early return.

[btolsch, 2017/05/23 08:55:02]

Done.

+  auto network_ids = GetDiscoveryNetworkIdList();
+  for (const auto& network_id : network_ids) {

[mark a. foltz, 2017/05/04 23:16:41]

If network_ids is empty, early return.

[btolsch, 2017/05/23 08:55:03]

Done.

+    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";

[mark a. foltz, 2017/05/04 23:16:41]

constexpr char here and below

[btolsch, 2017/05/23 08:55:02]

Done.

+// static
+const char DiscoveryNetworkMonitor::kNetworkIdUnknown[] = "unknown";
+
+std::string DiscoveryNetworkMonitor::ComputeNetworkId(

[mark a. foltz, 2017/05/04 23:16:42]

I don't see a reference to |this|; move to anonymous namespace as a static
function?

[btolsch, 2017/05/23 08:55:02]

Done.

+    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(),

[mark a. foltz, 2017/05/04 23:16:40]

Can you just compare the previous and the new network_id?

[btolsch, 2017/05/23 08:55:02]

Not necessarily.  The ID, when it isn't unknown/disconnected, is a hash which
could experience collisions.  On the other hand, if you feel this is too
expensive, and as long as other discovery layers aren't completely dependent on
this for accurate network updates (which I believe they aren't), we could just
compare IDs.

+                           network_info_list.begin())) {
+    observers_->Notify(FROM_HERE, &Observer::OnNetworksChanged,
+                       base::ConstRef(*this));
+  }
+  if (callback) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
+  }
+}