network_change_notifier.cc 37 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093
  1. // Copyright (c) 2012 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. #include "net/base/network_change_notifier.h"
  5. #include <limits>
  6. #include <string>
  7. #include <unordered_set>
  8. #include <utility>
  9. #include "base/memory/ref_counted.h"
  10. #include "base/metrics/histogram_functions.h"
  11. #include "base/metrics/histogram_macros.h"
  12. #include "base/no_destructor.h"
  13. #include "base/observer_list.h"
  14. #include "base/sequence_checker.h"
  15. #include "base/strings/string_util.h"
  16. #include "base/synchronization/lock.h"
  17. #include "base/threading/thread_checker.h"
  18. #include "base/timer/timer.h"
  19. #include "build/build_config.h"
  20. #include "build/chromeos_buildflags.h"
  21. #include "net/base/network_change_notifier_factory.h"
  22. #include "net/base/network_interfaces.h"
  23. #include "net/base/url_util.h"
  24. #include "net/dns/dns_config.h"
  25. #include "net/dns/dns_config_service.h"
  26. #include "net/dns/system_dns_config_change_notifier.h"
  27. #include "net/url_request/url_request.h"
  28. #include "third_party/abseil-cpp/absl/types/optional.h"
  29. #include "url/gurl.h"
  30. #if BUILDFLAG(IS_WIN)
  31. #include "net/base/network_change_notifier_win.h"
  32. #elif BUILDFLAG(IS_LINUX)
  33. #include "net/base/network_change_notifier_linux.h"
  34. #elif BUILDFLAG(IS_APPLE)
  35. #include "net/base/network_change_notifier_mac.h"
  36. #elif BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
  37. #include "net/base/network_change_notifier_posix.h"
  38. #elif BUILDFLAG(IS_FUCHSIA)
  39. #include "net/base/network_change_notifier_fuchsia.h"
  40. #endif
  41. namespace net {
  42. namespace {
  43. // The process-wide singleton notifier.
  44. NetworkChangeNotifier* g_network_change_notifier = nullptr;
  45. // Class factory singleton.
  46. NetworkChangeNotifierFactory* g_network_change_notifier_factory = nullptr;
  47. // Lock to protect |g_network_change_notifier| during creation time. Since
  48. // creation of the process-wide instance can happen on any thread, this lock is
  49. // used to guarantee only one instance is created. Once the global instance is
  50. // created, the owner is responsible for destroying it on the same thread. All
  51. // the other calls to the NetworkChangeNotifier do not require this lock as
  52. // the global instance is only destroyed when the process is getting killed.
  53. base::Lock& NetworkChangeNotifierCreationLock() {
  54. static base::NoDestructor<base::Lock> instance;
  55. return *instance;
  56. }
  57. class MockNetworkChangeNotifier : public NetworkChangeNotifier {
  58. public:
  59. explicit MockNetworkChangeNotifier(
  60. std::unique_ptr<SystemDnsConfigChangeNotifier> dns_config_notifier)
  61. : NetworkChangeNotifier(
  62. NetworkChangeCalculatorParams(),
  63. dns_config_notifier.get(),
  64. // Omit adding observers from the constructor as that would prevent
  65. // construction when SequencedTaskRunnerHandle isn't set.
  66. /* omit_observers_in_constructor_for_testing=*/true),
  67. dns_config_notifier_(std::move(dns_config_notifier)) {}
  68. ~MockNetworkChangeNotifier() override { StopSystemDnsConfigNotifier(); }
  69. ConnectionType GetCurrentConnectionType() const override {
  70. return CONNECTION_UNKNOWN;
  71. }
  72. private:
  73. std::unique_ptr<SystemDnsConfigChangeNotifier> dns_config_notifier_;
  74. };
  75. } // namespace
  76. // static
  77. bool NetworkChangeNotifier::test_notifications_only_ = false;
  78. NetworkChangeNotifier::NetworkChangeCalculatorParams::
  79. NetworkChangeCalculatorParams() = default;
  80. // Calculates NetworkChange signal from IPAddress, ConnectionCost, and
  81. // ConnectionType signals.
  82. class NetworkChangeNotifier::NetworkChangeCalculator
  83. : public ConnectionTypeObserver,
  84. public ConnectionCostObserver,
  85. public IPAddressObserver {
  86. public:
  87. explicit NetworkChangeCalculator(const NetworkChangeCalculatorParams& params)
  88. : params_(params) {
  89. DCHECK(g_network_change_notifier);
  90. AddConnectionTypeObserver(this);
  91. AddConnectionCostObserver(this);
  92. AddIPAddressObserver(this);
  93. }
  94. NetworkChangeCalculator(const NetworkChangeCalculator&) = delete;
  95. NetworkChangeCalculator& operator=(const NetworkChangeCalculator&) = delete;
  96. ~NetworkChangeCalculator() override {
  97. DCHECK(thread_checker_.CalledOnValidThread());
  98. RemoveConnectionTypeObserver(this);
  99. RemoveConnectionCostObserver(this);
  100. RemoveIPAddressObserver(this);
  101. }
  102. // NetworkChangeNotifier::IPAddressObserver implementation.
  103. void OnIPAddressChanged() override {
  104. DCHECK(thread_checker_.CalledOnValidThread());
  105. pending_connection_type_ = GetConnectionType();
  106. base::TimeDelta delay = last_announced_connection_type_ == CONNECTION_NONE
  107. ? params_.ip_address_offline_delay_ : params_.ip_address_online_delay_;
  108. // Cancels any previous timer.
  109. timer_.Start(FROM_HERE, delay, this, &NetworkChangeCalculator::Notify);
  110. }
  111. // NetworkChangeNotifier::ConnectionTypeObserver implementation.
  112. void OnConnectionTypeChanged(ConnectionType type) override {
  113. DCHECK(thread_checker_.CalledOnValidThread());
  114. pending_connection_type_ = type;
  115. base::TimeDelta delay = last_announced_connection_type_ == CONNECTION_NONE
  116. ? params_.connection_type_offline_delay_
  117. : params_.connection_type_online_delay_;
  118. // Cancels any previous timer.
  119. timer_.Start(FROM_HERE, delay, this, &NetworkChangeCalculator::Notify);
  120. }
  121. // NetworkChangeNotifier::ConnectionCostObserver implementation.
  122. void OnConnectionCostChanged(ConnectionCost cost) override {
  123. base::UmaHistogramEnumeration("Net.NetworkChangeNotifier.NewConnectionCost",
  124. cost, CONNECTION_COST_LAST);
  125. }
  126. private:
  127. void Notify() {
  128. DCHECK(thread_checker_.CalledOnValidThread());
  129. // Don't bother signaling about dead connections.
  130. if (have_announced_ &&
  131. (last_announced_connection_type_ == CONNECTION_NONE) &&
  132. (pending_connection_type_ == CONNECTION_NONE)) {
  133. return;
  134. }
  135. UMA_HISTOGRAM_ENUMERATION("Net.NetworkChangeNotifier.NewConnectionType",
  136. pending_connection_type_, CONNECTION_LAST + 1);
  137. have_announced_ = true;
  138. last_announced_connection_type_ = pending_connection_type_;
  139. // Immediately before sending out an online signal, send out an offline
  140. // signal to perform any destructive actions before constructive actions.
  141. if (pending_connection_type_ != CONNECTION_NONE)
  142. NetworkChangeNotifier::NotifyObserversOfNetworkChange(CONNECTION_NONE);
  143. NetworkChangeNotifier::NotifyObserversOfNetworkChange(
  144. pending_connection_type_);
  145. }
  146. const NetworkChangeCalculatorParams params_;
  147. // Indicates if NotifyObserversOfNetworkChange has been called yet.
  148. bool have_announced_ = false;
  149. // Last value passed to NotifyObserversOfNetworkChange.
  150. ConnectionType last_announced_connection_type_ = CONNECTION_NONE;
  151. // Value to pass to NotifyObserversOfNetworkChange when Notify is called.
  152. ConnectionType pending_connection_type_ = CONNECTION_NONE;
  153. // Used to delay notifications so duplicates can be combined.
  154. base::OneShotTimer timer_;
  155. base::ThreadChecker thread_checker_;
  156. };
  157. // Holds the collection of observer lists used by NetworkChangeNotifier.
  158. class NetworkChangeNotifier::ObserverList {
  159. public:
  160. ObserverList()
  161. : ip_address_observer_list_(
  162. base::MakeRefCounted<base::ObserverListThreadSafe<
  163. NetworkChangeNotifier::IPAddressObserver>>(
  164. base::ObserverListPolicy::EXISTING_ONLY)),
  165. connection_type_observer_list_(
  166. base::MakeRefCounted<base::ObserverListThreadSafe<
  167. NetworkChangeNotifier::ConnectionTypeObserver>>(
  168. base::ObserverListPolicy::EXISTING_ONLY)),
  169. resolver_state_observer_list_(
  170. base::MakeRefCounted<base::ObserverListThreadSafe<
  171. NetworkChangeNotifier::DNSObserver>>(
  172. base::ObserverListPolicy::EXISTING_ONLY)),
  173. network_change_observer_list_(
  174. base::MakeRefCounted<base::ObserverListThreadSafe<
  175. NetworkChangeNotifier::NetworkChangeObserver>>(
  176. base::ObserverListPolicy::EXISTING_ONLY)),
  177. max_bandwidth_observer_list_(
  178. base::MakeRefCounted<base::ObserverListThreadSafe<
  179. NetworkChangeNotifier::MaxBandwidthObserver>>(
  180. base::ObserverListPolicy::EXISTING_ONLY)),
  181. network_observer_list_(
  182. base::MakeRefCounted<base::ObserverListThreadSafe<
  183. NetworkChangeNotifier::NetworkObserver>>(
  184. base::ObserverListPolicy::EXISTING_ONLY)),
  185. connection_cost_observer_list_(
  186. base::MakeRefCounted<base::ObserverListThreadSafe<
  187. NetworkChangeNotifier::ConnectionCostObserver>>(
  188. base::ObserverListPolicy::EXISTING_ONLY)),
  189. default_network_active_observer_list_(
  190. base::MakeRefCounted<
  191. base::ObserverListThreadSafe<DefaultNetworkActiveObserver>>(
  192. base::ObserverListPolicy::EXISTING_ONLY)) {}
  193. ObserverList(const ObserverList&) = delete;
  194. ObserverList& operator=(const ObserverList&) = delete;
  195. ~ObserverList() = default;
  196. const scoped_refptr<
  197. base::ObserverListThreadSafe<NetworkChangeNotifier::IPAddressObserver>>
  198. ip_address_observer_list_;
  199. const scoped_refptr<base::ObserverListThreadSafe<
  200. NetworkChangeNotifier::ConnectionTypeObserver>>
  201. connection_type_observer_list_;
  202. const scoped_refptr<
  203. base::ObserverListThreadSafe<NetworkChangeNotifier::DNSObserver>>
  204. resolver_state_observer_list_;
  205. const scoped_refptr<base::ObserverListThreadSafe<
  206. NetworkChangeNotifier::NetworkChangeObserver>>
  207. network_change_observer_list_;
  208. const scoped_refptr<
  209. base::ObserverListThreadSafe<NetworkChangeNotifier::MaxBandwidthObserver>>
  210. max_bandwidth_observer_list_;
  211. const scoped_refptr<
  212. base::ObserverListThreadSafe<NetworkChangeNotifier::NetworkObserver>>
  213. network_observer_list_;
  214. const scoped_refptr<base::ObserverListThreadSafe<
  215. NetworkChangeNotifier::ConnectionCostObserver>>
  216. connection_cost_observer_list_;
  217. const scoped_refptr<
  218. base::ObserverListThreadSafe<DefaultNetworkActiveObserver>>
  219. default_network_active_observer_list_;
  220. // Indicates if connection cost observer was added before
  221. // network_change_notifier was initialized, if so ConnectionCostObserverAdded
  222. // is invoked from constructor.
  223. std::atomic_bool connection_cost_observers_added_ = false;
  224. };
  225. class NetworkChangeNotifier::SystemDnsConfigObserver
  226. : public SystemDnsConfigChangeNotifier::Observer {
  227. public:
  228. virtual ~SystemDnsConfigObserver() = default;
  229. void OnSystemDnsConfigChanged(absl::optional<DnsConfig> config) override {
  230. NotifyObserversOfDNSChange();
  231. }
  232. };
  233. void NetworkChangeNotifier::ClearGlobalPointer() {
  234. if (!cleared_global_pointer_) {
  235. cleared_global_pointer_ = true;
  236. DCHECK_EQ(this, g_network_change_notifier);
  237. g_network_change_notifier = nullptr;
  238. }
  239. }
  240. NetworkChangeNotifier::~NetworkChangeNotifier() {
  241. network_change_calculator_.reset();
  242. ClearGlobalPointer();
  243. StopSystemDnsConfigNotifier();
  244. }
  245. // static
  246. NetworkChangeNotifierFactory* NetworkChangeNotifier::GetFactory() {
  247. return g_network_change_notifier_factory;
  248. }
  249. // static
  250. void NetworkChangeNotifier::SetFactory(
  251. NetworkChangeNotifierFactory* factory) {
  252. CHECK(!g_network_change_notifier_factory);
  253. g_network_change_notifier_factory = factory;
  254. }
  255. // static
  256. std::unique_ptr<NetworkChangeNotifier> NetworkChangeNotifier::CreateIfNeeded(
  257. NetworkChangeNotifier::ConnectionType initial_type,
  258. NetworkChangeNotifier::ConnectionSubtype initial_subtype) {
  259. {
  260. base::AutoLock auto_lock(NetworkChangeNotifierCreationLock());
  261. if (g_network_change_notifier)
  262. return nullptr;
  263. }
  264. if (g_network_change_notifier_factory)
  265. return g_network_change_notifier_factory->CreateInstance();
  266. #if BUILDFLAG(IS_WIN)
  267. std::unique_ptr<NetworkChangeNotifierWin> network_change_notifier =
  268. std::make_unique<NetworkChangeNotifierWin>();
  269. network_change_notifier->WatchForAddressChange();
  270. return network_change_notifier;
  271. #elif BUILDFLAG(IS_ANDROID)
  272. // Fallback to use NetworkChangeNotifierPosix if NetworkChangeNotifierFactory
  273. // is not set. Currently used for tests and when running network
  274. // service in a separate process.
  275. return std::make_unique<NetworkChangeNotifierPosix>(initial_type,
  276. initial_subtype);
  277. #elif BUILDFLAG(IS_CHROMEOS)
  278. return std::make_unique<NetworkChangeNotifierPosix>(initial_type,
  279. initial_subtype);
  280. #elif BUILDFLAG(IS_LINUX)
  281. return std::make_unique<NetworkChangeNotifierLinux>(
  282. std::unordered_set<std::string>());
  283. #elif BUILDFLAG(IS_APPLE)
  284. return std::make_unique<NetworkChangeNotifierMac>();
  285. #elif BUILDFLAG(IS_FUCHSIA)
  286. return std::make_unique<NetworkChangeNotifierFuchsia>(
  287. /*require_wlan=*/false);
  288. #else
  289. NOTIMPLEMENTED();
  290. return nullptr;
  291. #endif
  292. }
  293. // static
  294. NetworkChangeNotifier::ConnectionCost
  295. NetworkChangeNotifier::GetConnectionCost() {
  296. return g_network_change_notifier
  297. ? g_network_change_notifier->GetCurrentConnectionCost()
  298. : CONNECTION_COST_UNKNOWN;
  299. }
  300. // static
  301. NetworkChangeNotifier::ConnectionType
  302. NetworkChangeNotifier::GetConnectionType() {
  303. return g_network_change_notifier ?
  304. g_network_change_notifier->GetCurrentConnectionType() :
  305. CONNECTION_UNKNOWN;
  306. }
  307. // static
  308. NetworkChangeNotifier::ConnectionSubtype
  309. NetworkChangeNotifier::GetConnectionSubtype() {
  310. return g_network_change_notifier
  311. ? g_network_change_notifier->GetCurrentConnectionSubtype()
  312. : SUBTYPE_UNKNOWN;
  313. }
  314. // static
  315. void NetworkChangeNotifier::GetMaxBandwidthAndConnectionType(
  316. double* max_bandwidth_mbps,
  317. ConnectionType* connection_type) {
  318. if (!g_network_change_notifier) {
  319. *connection_type = CONNECTION_UNKNOWN;
  320. *max_bandwidth_mbps =
  321. GetMaxBandwidthMbpsForConnectionSubtype(SUBTYPE_UNKNOWN);
  322. return;
  323. }
  324. g_network_change_notifier->GetCurrentMaxBandwidthAndConnectionType(
  325. max_bandwidth_mbps, connection_type);
  326. }
  327. // static
  328. double NetworkChangeNotifier::GetMaxBandwidthMbpsForConnectionSubtype(
  329. ConnectionSubtype subtype) {
  330. switch (subtype) {
  331. case SUBTYPE_GSM:
  332. return 0.01;
  333. case SUBTYPE_IDEN:
  334. return 0.064;
  335. case SUBTYPE_CDMA:
  336. return 0.115;
  337. case SUBTYPE_1XRTT:
  338. return 0.153;
  339. case SUBTYPE_GPRS:
  340. return 0.237;
  341. case SUBTYPE_EDGE:
  342. return 0.384;
  343. case SUBTYPE_UMTS:
  344. return 2.0;
  345. case SUBTYPE_EVDO_REV_0:
  346. return 2.46;
  347. case SUBTYPE_EVDO_REV_A:
  348. return 3.1;
  349. case SUBTYPE_HSPA:
  350. return 3.6;
  351. case SUBTYPE_EVDO_REV_B:
  352. return 14.7;
  353. case SUBTYPE_HSDPA:
  354. return 14.3;
  355. case SUBTYPE_HSUPA:
  356. return 14.4;
  357. case SUBTYPE_EHRPD:
  358. return 21.0;
  359. case SUBTYPE_HSPAP:
  360. return 42.0;
  361. case SUBTYPE_LTE:
  362. return 100.0;
  363. case SUBTYPE_LTE_ADVANCED:
  364. return 100.0;
  365. case SUBTYPE_BLUETOOTH_1_2:
  366. return 1.0;
  367. case SUBTYPE_BLUETOOTH_2_1:
  368. return 3.0;
  369. case SUBTYPE_BLUETOOTH_3_0:
  370. return 24.0;
  371. case SUBTYPE_BLUETOOTH_4_0:
  372. return 1.0;
  373. case SUBTYPE_ETHERNET:
  374. return 10.0;
  375. case SUBTYPE_FAST_ETHERNET:
  376. return 100.0;
  377. case SUBTYPE_GIGABIT_ETHERNET:
  378. return 1000.0;
  379. case SUBTYPE_10_GIGABIT_ETHERNET:
  380. return 10000.0;
  381. case SUBTYPE_WIFI_B:
  382. return 11.0;
  383. case SUBTYPE_WIFI_G:
  384. return 54.0;
  385. case SUBTYPE_WIFI_N:
  386. return 600.0;
  387. case SUBTYPE_WIFI_AC:
  388. return 1300.0;
  389. case SUBTYPE_WIFI_AD:
  390. return 7000.0;
  391. case SUBTYPE_UNKNOWN:
  392. return std::numeric_limits<double>::infinity();
  393. case SUBTYPE_NONE:
  394. return 0.0;
  395. case SUBTYPE_OTHER:
  396. return std::numeric_limits<double>::infinity();
  397. }
  398. NOTREACHED();
  399. return std::numeric_limits<double>::infinity();
  400. }
  401. // static
  402. bool NetworkChangeNotifier::AreNetworkHandlesSupported() {
  403. if (g_network_change_notifier) {
  404. return g_network_change_notifier->AreNetworkHandlesCurrentlySupported();
  405. }
  406. return false;
  407. }
  408. // static
  409. void NetworkChangeNotifier::GetConnectedNetworks(NetworkList* network_list) {
  410. DCHECK(AreNetworkHandlesSupported());
  411. if (g_network_change_notifier) {
  412. g_network_change_notifier->GetCurrentConnectedNetworks(network_list);
  413. } else {
  414. network_list->clear();
  415. }
  416. }
  417. // static
  418. NetworkChangeNotifier::ConnectionType
  419. NetworkChangeNotifier::GetNetworkConnectionType(
  420. handles::NetworkHandle network) {
  421. DCHECK(AreNetworkHandlesSupported());
  422. return g_network_change_notifier
  423. ? g_network_change_notifier->GetCurrentNetworkConnectionType(
  424. network)
  425. : CONNECTION_UNKNOWN;
  426. }
  427. // static
  428. handles::NetworkHandle NetworkChangeNotifier::GetDefaultNetwork() {
  429. DCHECK(AreNetworkHandlesSupported());
  430. return g_network_change_notifier
  431. ? g_network_change_notifier->GetCurrentDefaultNetwork()
  432. : handles::kInvalidNetworkHandle;
  433. }
  434. // static
  435. SystemDnsConfigChangeNotifier*
  436. NetworkChangeNotifier::GetSystemDnsConfigNotifier() {
  437. if (g_network_change_notifier)
  438. return g_network_change_notifier->GetCurrentSystemDnsConfigNotifier();
  439. return nullptr;
  440. }
  441. // static
  442. bool NetworkChangeNotifier::IsDefaultNetworkActive() {
  443. if (g_network_change_notifier)
  444. return g_network_change_notifier->IsDefaultNetworkActiveInternal();
  445. // Assume true as a "default" to avoid batching indefinitely.
  446. return true;
  447. }
  448. // static
  449. const char* NetworkChangeNotifier::ConnectionTypeToString(
  450. ConnectionType type) {
  451. static const char* const kConnectionTypeNames[] = {
  452. "CONNECTION_UNKNOWN", "CONNECTION_ETHERNET", "CONNECTION_WIFI",
  453. "CONNECTION_2G", "CONNECTION_3G", "CONNECTION_4G",
  454. "CONNECTION_NONE", "CONNECTION_BLUETOOTH", "CONNECTION_5G",
  455. };
  456. static_assert(std::size(kConnectionTypeNames) ==
  457. NetworkChangeNotifier::CONNECTION_LAST + 1,
  458. "ConnectionType name count should match");
  459. if (type < CONNECTION_UNKNOWN || type > CONNECTION_LAST) {
  460. NOTREACHED();
  461. return "CONNECTION_INVALID";
  462. }
  463. return kConnectionTypeNames[type];
  464. }
  465. #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
  466. // static
  467. const internal::AddressTrackerLinux*
  468. NetworkChangeNotifier::GetAddressTracker() {
  469. return g_network_change_notifier
  470. ? g_network_change_notifier->GetAddressTrackerInternal()
  471. : nullptr;
  472. }
  473. #endif
  474. // static
  475. bool NetworkChangeNotifier::IsOffline() {
  476. return GetConnectionType() == CONNECTION_NONE;
  477. }
  478. // static
  479. bool NetworkChangeNotifier::IsConnectionCellular(ConnectionType type) {
  480. bool is_cellular = false;
  481. switch (type) {
  482. case CONNECTION_2G:
  483. case CONNECTION_3G:
  484. case CONNECTION_4G:
  485. case CONNECTION_5G:
  486. is_cellular = true;
  487. break;
  488. case CONNECTION_UNKNOWN:
  489. case CONNECTION_ETHERNET:
  490. case CONNECTION_WIFI:
  491. case CONNECTION_NONE:
  492. case CONNECTION_BLUETOOTH:
  493. is_cellular = false;
  494. break;
  495. }
  496. return is_cellular;
  497. }
  498. // static
  499. NetworkChangeNotifier::ConnectionType
  500. NetworkChangeNotifier::ConnectionTypeFromInterfaces() {
  501. NetworkInterfaceList interfaces;
  502. if (!GetNetworkList(&interfaces, EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES))
  503. return CONNECTION_UNKNOWN;
  504. return ConnectionTypeFromInterfaceList(interfaces);
  505. }
  506. // static
  507. NetworkChangeNotifier::ConnectionType
  508. NetworkChangeNotifier::ConnectionTypeFromInterfaceList(
  509. const NetworkInterfaceList& interfaces) {
  510. bool first = true;
  511. ConnectionType result = CONNECTION_NONE;
  512. for (const auto& network_interface : interfaces) {
  513. #if BUILDFLAG(IS_WIN)
  514. if (network_interface.friendly_name == "Teredo Tunneling Pseudo-Interface")
  515. continue;
  516. #endif
  517. #if BUILDFLAG(IS_APPLE)
  518. // Ignore link-local addresses as they aren't globally routable.
  519. // Mac assigns these to disconnected interfaces like tunnel interfaces
  520. // ("utun"), airdrop interfaces ("awdl"), and ethernet ports ("en").
  521. if (network_interface.address.IsLinkLocal())
  522. continue;
  523. #endif
  524. // Remove VMware network interfaces as they're internal and should not be
  525. // used to determine the network connection type.
  526. if (base::ToLowerASCII(network_interface.friendly_name).find("vmnet") !=
  527. std::string::npos) {
  528. continue;
  529. }
  530. if (first) {
  531. first = false;
  532. result = network_interface.type;
  533. } else if (result != network_interface.type) {
  534. return CONNECTION_UNKNOWN;
  535. }
  536. }
  537. return result;
  538. }
  539. // static
  540. std::unique_ptr<NetworkChangeNotifier>
  541. NetworkChangeNotifier::CreateMockIfNeeded() {
  542. {
  543. base::AutoLock auto_lock(NetworkChangeNotifierCreationLock());
  544. if (g_network_change_notifier)
  545. return nullptr;
  546. }
  547. // Use an empty noop SystemDnsConfigChangeNotifier to disable actual system
  548. // DNS configuration notifications.
  549. return std::make_unique<MockNetworkChangeNotifier>(
  550. std::make_unique<SystemDnsConfigChangeNotifier>(
  551. nullptr /* task_runner */, nullptr /* dns_config_service */));
  552. }
  553. NetworkChangeNotifier::IPAddressObserver::IPAddressObserver() = default;
  554. NetworkChangeNotifier::IPAddressObserver::~IPAddressObserver() = default;
  555. NetworkChangeNotifier::ConnectionTypeObserver::ConnectionTypeObserver() =
  556. default;
  557. NetworkChangeNotifier::ConnectionTypeObserver::~ConnectionTypeObserver() =
  558. default;
  559. NetworkChangeNotifier::DNSObserver::DNSObserver() = default;
  560. NetworkChangeNotifier::DNSObserver::~DNSObserver() = default;
  561. NetworkChangeNotifier::NetworkChangeObserver::NetworkChangeObserver() = default;
  562. NetworkChangeNotifier::NetworkChangeObserver::~NetworkChangeObserver() =
  563. default;
  564. NetworkChangeNotifier::MaxBandwidthObserver::MaxBandwidthObserver() = default;
  565. NetworkChangeNotifier::MaxBandwidthObserver::~MaxBandwidthObserver() = default;
  566. NetworkChangeNotifier::NetworkObserver::NetworkObserver() = default;
  567. NetworkChangeNotifier::NetworkObserver::~NetworkObserver() = default;
  568. NetworkChangeNotifier::ConnectionCostObserver::ConnectionCostObserver() =
  569. default;
  570. NetworkChangeNotifier::ConnectionCostObserver::~ConnectionCostObserver() =
  571. default;
  572. NetworkChangeNotifier::DefaultNetworkActiveObserver::
  573. DefaultNetworkActiveObserver() = default;
  574. NetworkChangeNotifier::DefaultNetworkActiveObserver::
  575. ~DefaultNetworkActiveObserver() = default;
  576. void NetworkChangeNotifier::AddIPAddressObserver(IPAddressObserver* observer) {
  577. DCHECK(!observer->observer_list_);
  578. observer->observer_list_ = GetObserverList().ip_address_observer_list_;
  579. observer->observer_list_->AddObserver(observer);
  580. }
  581. void NetworkChangeNotifier::AddConnectionTypeObserver(
  582. ConnectionTypeObserver* observer) {
  583. DCHECK(!observer->observer_list_);
  584. observer->observer_list_ = GetObserverList().connection_type_observer_list_;
  585. observer->observer_list_->AddObserver(observer);
  586. }
  587. void NetworkChangeNotifier::AddDNSObserver(DNSObserver* observer) {
  588. DCHECK(!observer->observer_list_);
  589. observer->observer_list_ = GetObserverList().resolver_state_observer_list_;
  590. observer->observer_list_->AddObserver(observer);
  591. }
  592. void NetworkChangeNotifier::AddNetworkChangeObserver(
  593. NetworkChangeObserver* observer) {
  594. DCHECK(!observer->observer_list_);
  595. observer->observer_list_ = GetObserverList().network_change_observer_list_;
  596. observer->observer_list_->AddObserver(observer);
  597. }
  598. void NetworkChangeNotifier::AddMaxBandwidthObserver(
  599. MaxBandwidthObserver* observer) {
  600. DCHECK(!observer->observer_list_);
  601. observer->observer_list_ = GetObserverList().max_bandwidth_observer_list_;
  602. observer->observer_list_->AddObserver(observer);
  603. }
  604. void NetworkChangeNotifier::AddNetworkObserver(NetworkObserver* observer) {
  605. base::AutoLock auto_lock(NetworkChangeNotifierCreationLock());
  606. DCHECK(AreNetworkHandlesSupported());
  607. DCHECK(!observer->observer_list_);
  608. observer->observer_list_ = GetObserverList().network_observer_list_;
  609. observer->observer_list_->AddObserver(observer);
  610. }
  611. void NetworkChangeNotifier::AddConnectionCostObserver(
  612. ConnectionCostObserver* observer) {
  613. DCHECK(!observer->observer_list_);
  614. GetObserverList().connection_cost_observers_added_ = true;
  615. observer->observer_list_ = GetObserverList().connection_cost_observer_list_;
  616. observer->observer_list_->AddObserver(observer);
  617. base::AutoLock auto_lock(NetworkChangeNotifierCreationLock());
  618. if (g_network_change_notifier) {
  619. g_network_change_notifier->ConnectionCostObserverAdded();
  620. }
  621. }
  622. void NetworkChangeNotifier::AddDefaultNetworkActiveObserver(
  623. DefaultNetworkActiveObserver* observer) {
  624. DCHECK(!observer->observer_list_);
  625. observer->observer_list_ =
  626. GetObserverList().default_network_active_observer_list_;
  627. observer->observer_list_->AddObserver(observer);
  628. base::AutoLock auto_lock(NetworkChangeNotifierCreationLock());
  629. // Currently we lose DefaultNetworkActiveObserverAdded notifications for
  630. // observers added prior to NCN creation. This should be a non-issue as
  631. // currently only Cronet listens to this and its observers are always added
  632. // after NCN creation.
  633. if (g_network_change_notifier) {
  634. g_network_change_notifier->DefaultNetworkActiveObserverAdded();
  635. }
  636. }
  637. void NetworkChangeNotifier::RemoveIPAddressObserver(
  638. IPAddressObserver* observer) {
  639. if (observer->observer_list_) {
  640. observer->observer_list_->RemoveObserver(observer);
  641. observer->observer_list_.reset();
  642. }
  643. }
  644. void NetworkChangeNotifier::RemoveConnectionTypeObserver(
  645. ConnectionTypeObserver* observer) {
  646. if (observer->observer_list_) {
  647. observer->observer_list_->RemoveObserver(observer);
  648. observer->observer_list_.reset();
  649. }
  650. }
  651. void NetworkChangeNotifier::RemoveDNSObserver(DNSObserver* observer) {
  652. if (observer->observer_list_) {
  653. observer->observer_list_->RemoveObserver(observer);
  654. observer->observer_list_.reset();
  655. }
  656. }
  657. void NetworkChangeNotifier::RemoveNetworkChangeObserver(
  658. NetworkChangeObserver* observer) {
  659. if (observer->observer_list_) {
  660. observer->observer_list_->RemoveObserver(observer);
  661. observer->observer_list_.reset();
  662. }
  663. }
  664. void NetworkChangeNotifier::RemoveMaxBandwidthObserver(
  665. MaxBandwidthObserver* observer) {
  666. if (observer->observer_list_) {
  667. observer->observer_list_->RemoveObserver(observer);
  668. observer->observer_list_.reset();
  669. }
  670. }
  671. void NetworkChangeNotifier::RemoveNetworkObserver(NetworkObserver* observer) {
  672. if (observer->observer_list_) {
  673. observer->observer_list_->RemoveObserver(observer);
  674. observer->observer_list_.reset();
  675. }
  676. }
  677. void NetworkChangeNotifier::RemoveConnectionCostObserver(
  678. ConnectionCostObserver* observer) {
  679. if (observer->observer_list_) {
  680. observer->observer_list_->RemoveObserver(observer);
  681. observer->observer_list_.reset();
  682. }
  683. }
  684. void NetworkChangeNotifier::RemoveDefaultNetworkActiveObserver(
  685. DefaultNetworkActiveObserver* observer) {
  686. if (observer->observer_list_) {
  687. observer->observer_list_->RemoveObserver(observer);
  688. observer->observer_list_.reset();
  689. g_network_change_notifier->DefaultNetworkActiveObserverRemoved();
  690. }
  691. }
  692. void NetworkChangeNotifier::TriggerNonSystemDnsChange() {
  693. NetworkChangeNotifier::NotifyObserversOfDNSChange();
  694. }
  695. // static
  696. void NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests() {
  697. if (g_network_change_notifier)
  698. g_network_change_notifier->NotifyObserversOfIPAddressChangeImpl();
  699. }
  700. // static
  701. void NetworkChangeNotifier::NotifyObserversOfConnectionTypeChangeForTests(
  702. ConnectionType type) {
  703. if (g_network_change_notifier)
  704. g_network_change_notifier->NotifyObserversOfConnectionTypeChangeImpl(type);
  705. }
  706. // static
  707. void NetworkChangeNotifier::NotifyObserversOfDNSChangeForTests() {
  708. if (g_network_change_notifier)
  709. g_network_change_notifier->NotifyObserversOfDNSChangeImpl();
  710. }
  711. // static
  712. void NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
  713. ConnectionType type) {
  714. if (g_network_change_notifier)
  715. g_network_change_notifier->NotifyObserversOfNetworkChangeImpl(type);
  716. }
  717. // static
  718. void NetworkChangeNotifier::NotifyObserversOfMaxBandwidthChangeForTests(
  719. double max_bandwidth_mbps,
  720. ConnectionType type) {
  721. if (g_network_change_notifier) {
  722. g_network_change_notifier->NotifyObserversOfMaxBandwidthChangeImpl(
  723. max_bandwidth_mbps, type);
  724. }
  725. }
  726. // static
  727. void NetworkChangeNotifier::NotifyObserversOfConnectionCostChangeForTests(
  728. ConnectionCost cost) {
  729. if (g_network_change_notifier)
  730. g_network_change_notifier->NotifyObserversOfConnectionCostChangeImpl(cost);
  731. }
  732. // static
  733. void NetworkChangeNotifier::NotifyObserversOfDefaultNetworkActiveForTests() {
  734. if (g_network_change_notifier)
  735. g_network_change_notifier->NotifyObserversOfDefaultNetworkActiveImpl();
  736. }
  737. // static
  738. void NetworkChangeNotifier::SetTestNotificationsOnly(bool test_only) {
  739. DCHECK(!g_network_change_notifier);
  740. NetworkChangeNotifier::test_notifications_only_ = test_only;
  741. }
  742. NetworkChangeNotifier::NetworkChangeNotifier(
  743. const NetworkChangeCalculatorParams& params
  744. /*= NetworkChangeCalculatorParams()*/,
  745. SystemDnsConfigChangeNotifier* system_dns_config_notifier /*= nullptr */,
  746. bool omit_observers_in_constructor_for_testing /*= false */)
  747. : system_dns_config_notifier_(system_dns_config_notifier),
  748. system_dns_config_observer_(std::make_unique<SystemDnsConfigObserver>()) {
  749. {
  750. base::AutoLock auto_lock(NetworkChangeNotifierCreationLock());
  751. if (!system_dns_config_notifier_) {
  752. static base::NoDestructor<SystemDnsConfigChangeNotifier> singleton{};
  753. system_dns_config_notifier_ = singleton.get();
  754. }
  755. DCHECK(!g_network_change_notifier);
  756. g_network_change_notifier = this;
  757. system_dns_config_notifier_->AddObserver(system_dns_config_observer_.get());
  758. if (GetObserverList().connection_cost_observers_added_) {
  759. g_network_change_notifier->ConnectionCostObserverAdded();
  760. }
  761. }
  762. if (!omit_observers_in_constructor_for_testing) {
  763. network_change_calculator_ =
  764. std::make_unique<NetworkChangeCalculator>(params);
  765. }
  766. }
  767. #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
  768. const internal::AddressTrackerLinux*
  769. NetworkChangeNotifier::GetAddressTrackerInternal() const {
  770. return nullptr;
  771. }
  772. #endif
  773. NetworkChangeNotifier::ConnectionCost
  774. NetworkChangeNotifier::GetCurrentConnectionCost() {
  775. // This is the default non-platform specific implementation and assumes that
  776. // cellular connectivity is metered and non-cellular is not. The function can
  777. // be specialized on each platform specific notifier implementation.
  778. return IsConnectionCellular(GetCurrentConnectionType())
  779. ? CONNECTION_COST_METERED
  780. : CONNECTION_COST_UNMETERED;
  781. }
  782. NetworkChangeNotifier::ConnectionSubtype
  783. NetworkChangeNotifier::GetCurrentConnectionSubtype() const {
  784. return SUBTYPE_UNKNOWN;
  785. }
  786. void NetworkChangeNotifier::GetCurrentMaxBandwidthAndConnectionType(
  787. double* max_bandwidth_mbps,
  788. ConnectionType* connection_type) const {
  789. // This default implementation conforms to the NetInfo V3 specification but
  790. // should be overridden to provide specific bandwidth data based on the
  791. // platform.
  792. *connection_type = GetCurrentConnectionType();
  793. *max_bandwidth_mbps =
  794. *connection_type == CONNECTION_NONE
  795. ? GetMaxBandwidthMbpsForConnectionSubtype(SUBTYPE_NONE)
  796. : GetMaxBandwidthMbpsForConnectionSubtype(SUBTYPE_UNKNOWN);
  797. }
  798. bool NetworkChangeNotifier::AreNetworkHandlesCurrentlySupported() const {
  799. return false;
  800. }
  801. void NetworkChangeNotifier::GetCurrentConnectedNetworks(
  802. NetworkList* network_list) const {
  803. network_list->clear();
  804. }
  805. NetworkChangeNotifier::ConnectionType
  806. NetworkChangeNotifier::GetCurrentNetworkConnectionType(
  807. handles::NetworkHandle network) const {
  808. return CONNECTION_UNKNOWN;
  809. }
  810. handles::NetworkHandle NetworkChangeNotifier::GetCurrentDefaultNetwork() const {
  811. return handles::kInvalidNetworkHandle;
  812. }
  813. SystemDnsConfigChangeNotifier*
  814. NetworkChangeNotifier::GetCurrentSystemDnsConfigNotifier() {
  815. DCHECK(system_dns_config_notifier_);
  816. return system_dns_config_notifier_;
  817. }
  818. bool NetworkChangeNotifier::IsDefaultNetworkActiveInternal() {
  819. return true;
  820. }
  821. // static
  822. void NetworkChangeNotifier::NotifyObserversOfIPAddressChange() {
  823. if (g_network_change_notifier &&
  824. !NetworkChangeNotifier::test_notifications_only_) {
  825. g_network_change_notifier->NotifyObserversOfIPAddressChangeImpl();
  826. }
  827. }
  828. // static
  829. void NetworkChangeNotifier::NotifyObserversOfConnectionTypeChange() {
  830. if (g_network_change_notifier &&
  831. !NetworkChangeNotifier::test_notifications_only_) {
  832. g_network_change_notifier->NotifyObserversOfConnectionTypeChangeImpl(
  833. GetConnectionType());
  834. }
  835. }
  836. // static
  837. void NetworkChangeNotifier::NotifyObserversOfNetworkChange(
  838. ConnectionType type) {
  839. if (g_network_change_notifier &&
  840. !NetworkChangeNotifier::test_notifications_only_) {
  841. g_network_change_notifier->NotifyObserversOfNetworkChangeImpl(type);
  842. }
  843. }
  844. // static
  845. void NetworkChangeNotifier::NotifyObserversOfMaxBandwidthChange(
  846. double max_bandwidth_mbps,
  847. ConnectionType type) {
  848. if (g_network_change_notifier &&
  849. !NetworkChangeNotifier::test_notifications_only_) {
  850. g_network_change_notifier->NotifyObserversOfMaxBandwidthChangeImpl(
  851. max_bandwidth_mbps, type);
  852. }
  853. }
  854. // static
  855. void NetworkChangeNotifier::NotifyObserversOfDNSChange() {
  856. if (g_network_change_notifier &&
  857. !NetworkChangeNotifier::test_notifications_only_) {
  858. g_network_change_notifier->NotifyObserversOfDNSChangeImpl();
  859. }
  860. }
  861. // static
  862. void NetworkChangeNotifier::NotifyObserversOfSpecificNetworkChange(
  863. NetworkChangeType type,
  864. handles::NetworkHandle network) {
  865. if (g_network_change_notifier &&
  866. !NetworkChangeNotifier::test_notifications_only_) {
  867. g_network_change_notifier->NotifyObserversOfSpecificNetworkChangeImpl(
  868. type, network);
  869. }
  870. }
  871. // static
  872. void NetworkChangeNotifier::NotifyObserversOfConnectionCostChange() {
  873. if (g_network_change_notifier &&
  874. !NetworkChangeNotifier::test_notifications_only_) {
  875. g_network_change_notifier->NotifyObserversOfConnectionCostChangeImpl(
  876. GetConnectionCost());
  877. }
  878. }
  879. // static
  880. void NetworkChangeNotifier::NotifyObserversOfDefaultNetworkActive() {
  881. if (g_network_change_notifier &&
  882. !NetworkChangeNotifier::test_notifications_only_) {
  883. g_network_change_notifier->NotifyObserversOfDefaultNetworkActiveImpl();
  884. }
  885. }
  886. void NetworkChangeNotifier::StopSystemDnsConfigNotifier() {
  887. if (!system_dns_config_notifier_)
  888. return;
  889. system_dns_config_notifier_->RemoveObserver(
  890. system_dns_config_observer_.get());
  891. system_dns_config_observer_ = nullptr;
  892. system_dns_config_notifier_ = nullptr;
  893. }
  894. void NetworkChangeNotifier::NotifyObserversOfIPAddressChangeImpl() {
  895. GetObserverList().ip_address_observer_list_->Notify(
  896. FROM_HERE, &IPAddressObserver::OnIPAddressChanged);
  897. }
  898. void NetworkChangeNotifier::NotifyObserversOfConnectionTypeChangeImpl(
  899. ConnectionType type) {
  900. GetObserverList().connection_type_observer_list_->Notify(
  901. FROM_HERE, &ConnectionTypeObserver::OnConnectionTypeChanged, type);
  902. }
  903. void NetworkChangeNotifier::NotifyObserversOfNetworkChangeImpl(
  904. ConnectionType type) {
  905. GetObserverList().network_change_observer_list_->Notify(
  906. FROM_HERE, &NetworkChangeObserver::OnNetworkChanged, type);
  907. }
  908. void NetworkChangeNotifier::NotifyObserversOfDNSChangeImpl() {
  909. GetObserverList().resolver_state_observer_list_->Notify(
  910. FROM_HERE, &DNSObserver::OnDNSChanged);
  911. }
  912. void NetworkChangeNotifier::NotifyObserversOfMaxBandwidthChangeImpl(
  913. double max_bandwidth_mbps,
  914. ConnectionType type) {
  915. GetObserverList().max_bandwidth_observer_list_->Notify(
  916. FROM_HERE, &MaxBandwidthObserver::OnMaxBandwidthChanged,
  917. max_bandwidth_mbps, type);
  918. }
  919. void NetworkChangeNotifier::NotifyObserversOfSpecificNetworkChangeImpl(
  920. NetworkChangeType type,
  921. handles::NetworkHandle network) {
  922. switch (type) {
  923. case NetworkChangeType::kConnected:
  924. GetObserverList().network_observer_list_->Notify(
  925. FROM_HERE, &NetworkObserver::OnNetworkConnected, network);
  926. break;
  927. case NetworkChangeType::kDisconnected:
  928. GetObserverList().network_observer_list_->Notify(
  929. FROM_HERE, &NetworkObserver::OnNetworkDisconnected, network);
  930. break;
  931. case NetworkChangeType::kSoonToDisconnect:
  932. GetObserverList().network_observer_list_->Notify(
  933. FROM_HERE, &NetworkObserver::OnNetworkSoonToDisconnect, network);
  934. break;
  935. case NetworkChangeType::kMadeDefault:
  936. GetObserverList().network_observer_list_->Notify(
  937. FROM_HERE, &NetworkObserver::OnNetworkMadeDefault, network);
  938. break;
  939. }
  940. }
  941. void NetworkChangeNotifier::NotifyObserversOfConnectionCostChangeImpl(
  942. ConnectionCost cost) {
  943. GetObserverList().connection_cost_observer_list_->Notify(
  944. FROM_HERE, &ConnectionCostObserver::OnConnectionCostChanged, cost);
  945. }
  946. void NetworkChangeNotifier::NotifyObserversOfDefaultNetworkActiveImpl() {
  947. GetObserverList().default_network_active_observer_list_->Notify(
  948. FROM_HERE, &DefaultNetworkActiveObserver::OnDefaultNetworkActive);
  949. }
  950. NetworkChangeNotifier::DisableForTest::DisableForTest()
  951. : network_change_notifier_(g_network_change_notifier) {
  952. DCHECK(g_network_change_notifier);
  953. g_network_change_notifier = nullptr;
  954. }
  955. NetworkChangeNotifier::DisableForTest::~DisableForTest() {
  956. DCHECK(!g_network_change_notifier);
  957. g_network_change_notifier = network_change_notifier_;
  958. }
  959. // static
  960. NetworkChangeNotifier::ObserverList& NetworkChangeNotifier::GetObserverList() {
  961. static base::NoDestructor<NetworkChangeNotifier::ObserverList> observers;
  962. return *observers;
  963. }
  964. } // namespace net