OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2017 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "chrome/browser/media/router/discovery/discovery_network_monitor.h" | |
6 | |
7 #include <iostream> | |
8 | |
9 #include "base/lazy_instance.h" | |
10 #include "base/logging.h" | |
11 #include "base/sha1.h" | |
12 #include "base/strings/string_number_conversions.h" | |
13 #include "base/strings/string_util.h" | |
14 #include "chrome/browser/media/router/discovery/discovery_network_list.h" | |
15 #include "net/base/network_interfaces.h" | |
16 | |
17 namespace { | |
18 | |
19 using content::BrowserThread; | |
20 | |
21 const char* kNetworkIdDisconnected = "disconnected"; | |
22 const char* kNetworkIdUnknown = "unknown"; | |
23 | |
24 std::vector<NetworkInfo> GetNetworkInfo() { | |
25 DCHECK_CURRENTLY_ON(BrowserThread::IO); | |
26 | |
27 net::NetworkInterfaceList interface_list; | |
28 if (!net::GetNetworkList(&interface_list, | |
29 net::INCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES)) { | |
30 DVLOG(2) << "net::GetNetworkList failed after a network change event"; | |
31 return std::vector<NetworkInfo>(); | |
32 } | |
33 | |
34 std::vector<NetworkInfo> network_info_list; | |
mark a. foltz
2017/04/18 20:37:00
Maybe this should be a std::Map<std::string, Netwo
btolsch
2017/04/20 04:03:50
Done.
| |
35 for (const auto& interface : interface_list) { | |
36 if (interface.type != net::NetworkChangeNotifier::CONNECTION_ETHERNET && | |
37 interface.type != net::NetworkChangeNotifier::CONNECTION_WIFI) { | |
38 continue; | |
39 } | |
40 network_info_list.push_back( | |
41 NetworkInfo{interface.interface_index, interface.type, interface.name, | |
42 std::string(""), interface.address}); | |
43 } | |
44 | |
45 auto network_ids = GetDiscoveryNetworkIdList(); | |
mark a. foltz
2017/04/18 20:37:00
Or we could have this return results in the same i
btolsch
2017/04/20 04:03:50
The only way to ensure that would be to pass |netw
| |
46 for (const auto& network_id : network_ids) { | |
47 auto matching_info_it = | |
48 std::find_if(begin(network_info_list), end(network_info_list), | |
49 [&network_id](const NetworkInfo& network_info) { | |
50 return network_info.name == network_id.interface_name; | |
51 }); | |
52 if (matching_info_it != end(network_info_list)) { | |
53 matching_info_it->network_id = network_id.network_id; | |
mark a. foltz
2017/04/18 20:37:00
What if an entry doesn't have a network_id in |net
btolsch
2017/04/20 04:03:50
I think the only option would be to set the networ
| |
54 } | |
55 } | |
56 return network_info_list; | |
57 } | |
58 | |
59 base::LazyInstance<DiscoveryNetworkMonitor>::Leaky g_discovery_monitor; | |
60 | |
61 } // namespace | |
62 NetworkInfo::NetworkInfo() {} | |
63 | |
64 NetworkInfo::NetworkInfo( | |
65 uint32_t index, | |
66 net::NetworkChangeNotifier::ConnectionType connection_type, | |
67 std::string name, | |
68 std::string network_id, | |
69 net::IPAddress ip_address) | |
70 : index(index), | |
71 connection_type(connection_type), | |
72 name(name), | |
73 network_id(network_id), | |
74 ip_address(ip_address) {} | |
75 | |
76 NetworkInfo::NetworkInfo(const NetworkInfo&) = default; | |
77 | |
78 NetworkInfo& NetworkInfo::operator=(const NetworkInfo&) = default; | |
79 | |
80 bool NetworkInfo::operator==(const NetworkInfo& o) const { | |
81 return index == o.index && connection_type == o.connection_type && | |
82 name == o.name && network_id == o.network_id && | |
83 ip_address == o.ip_address; | |
84 } | |
85 | |
86 bool NetworkInfo::operator!=(const NetworkInfo& o) const { | |
87 return !(*this == o); | |
88 } | |
89 | |
90 DiscoveryNetworkMonitor::DiscoveryNetworkMonitor() | |
91 : network_id_(kNetworkIdDisconnected), | |
92 observers_(new base::ObserverListThreadSafe<Observer>( | |
93 base::ObserverListThreadSafe< | |
94 Observer>::NotificationType::NOTIFY_EXISTING_ONLY)) { | |
95 net::NetworkChangeNotifier::AddNetworkChangeObserver(this); | |
96 } | |
97 | |
98 DiscoveryNetworkMonitor::~DiscoveryNetworkMonitor() { | |
99 net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this); | |
100 } | |
101 | |
102 DiscoveryNetworkMonitor* DiscoveryNetworkMonitor::GetInstance() { | |
103 DiscoveryNetworkMonitor* monitor = g_discovery_monitor.Pointer(); | |
104 if (!monitor->network_info_callback_) { | |
105 monitor->network_info_callback_ = base::Bind(&GetNetworkInfo); | |
106 } | |
107 return monitor; | |
108 } | |
109 | |
110 DiscoveryNetworkMonitor* DiscoveryNetworkMonitor::GetInstanceForTest( | |
111 NetworkInfoCallback strategy) { | |
112 DiscoveryNetworkMonitor* monitor = g_discovery_monitor.Pointer(); | |
113 monitor->network_info_callback_ = std::move(strategy); | |
114 return monitor; | |
115 } | |
116 | |
117 void DiscoveryNetworkMonitor::RebindNetworkChangeObserverForTest() { | |
118 net::NetworkChangeNotifier::AddNetworkChangeObserver(this); | |
119 } | |
120 | |
121 void DiscoveryNetworkMonitor::AddObserver(Observer* const observer) { | |
122 observers_->AddObserver(observer); | |
123 } | |
124 | |
125 void DiscoveryNetworkMonitor::RemoveObserver(Observer* const observer) { | |
126 observers_->RemoveObserver(observer); | |
127 } | |
128 | |
129 void DiscoveryNetworkMonitor::ForceNetworkInfoRefresh( | |
130 NetworkRefreshCompleteCallback callback) { | |
131 DCHECK_CURRENTLY_ON(BrowserThread::UI); | |
132 | |
133 BrowserThread::PostTask( | |
134 BrowserThread::IO, FROM_HERE, | |
135 base::Bind(&DiscoveryNetworkMonitor::UpdateNetworkInfo, | |
136 base::Unretained(this), callback)); | |
137 } | |
138 | |
139 void DiscoveryNetworkMonitor::OnNetworkChanged( | |
140 net::NetworkChangeNotifier::ConnectionType) { | |
141 DCHECK_CURRENTLY_ON(BrowserThread::UI); | |
142 | |
143 BrowserThread::PostTask( | |
144 BrowserThread::IO, FROM_HERE, | |
145 base::Bind(&DiscoveryNetworkMonitor::UpdateNetworkInfo, | |
146 base::Unretained(this), NetworkRefreshCompleteCallback())); | |
147 } | |
148 | |
149 std::string DiscoveryNetworkMonitor::ComputeNetworkId( | |
150 const std::vector<NetworkInfo>& network_info_list) { | |
151 DCHECK_CURRENTLY_ON(BrowserThread::IO); | |
152 | |
153 if (network_info_list.size() == 0) { | |
154 return kNetworkIdDisconnected; | |
155 } | |
156 std::string network_ids; | |
157 for (const auto& network_info : network_info_list) { | |
158 network_ids += network_info.network_id; | |
159 } | |
160 if (network_ids.size() == 0) { | |
161 return kNetworkIdUnknown; | |
162 } | |
163 | |
164 std::vector<std::string> id_list; | |
165 std::transform( | |
166 network_info_list.begin(), network_info_list.end(), | |
167 std::back_inserter(id_list), | |
168 [](const NetworkInfo& network_info) { return network_info.network_id; }); | |
169 std::sort(id_list.begin(), id_list.end()); | |
mark a. foltz
2017/04/18 20:37:00
Would it be simpler to implement a comparator func
btolsch
2017/04/20 04:03:50
I don't think copying and sorting with a comparato
| |
170 std::string combined_ids; | |
171 for (const auto& id : id_list) { | |
172 combined_ids = combined_ids + id; | |
mark a. foltz
2017/04/18 20:37:00
Nit: You may want to insert a delimeter like ! bet
btolsch
2017/04/20 04:03:50
Done.
| |
173 } | |
174 | |
175 std::string hash = base::SHA1HashString(combined_ids); | |
176 return base::ToLowerASCII(base::HexEncode(hash.data(), hash.length())); | |
177 } | |
178 | |
179 void DiscoveryNetworkMonitor::UpdateNetworkInfo( | |
180 const NetworkRefreshCompleteCallback& callback) { | |
181 DCHECK_CURRENTLY_ON(BrowserThread::IO); | |
182 | |
183 auto network_info_list = network_info_callback_.Run(); | |
184 auto network_id = ComputeNetworkId(network_info_list); | |
185 | |
186 networks_.swap(network_info_list); | |
187 network_id_.swap(network_id); | |
188 | |
189 if (network_id_ != network_id || | |
mark a. foltz
2017/04/18 20:37:00
I think only this check is necessary. Because of t
btolsch
2017/04/20 04:03:50
Done.
| |
190 !std::is_permutation(networks_.begin(), networks_.end(), | |
191 network_info_list.begin())) { | |
192 observers_->Notify(FROM_HERE, &Observer::OnNetworksChanged, | |
193 base::ConstRef(*this)); | |
194 } | |
195 if (callback) { | |
196 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback); | |
197 } | |
198 } | |
OLD | NEW |