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