[NetworkChangeNotifier] Run Windows connection type computation on other thread

net/base/network_change_notifier_win.cc

 // Copyright (c) 2012 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 "net/base/network_change_notifier_win.h"
 
 #include <iphlpapi.h>
 #include <winsock2.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
+#include "base/task_runner_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "net/base/winsock_init.h"
 #include "net/base/winsock_util.h"
 #include "net/dns/dns_config_service.h"
 
 namespace net {
 
 namespace {
 
 // Time between NotifyAddrChange retries, on failure.
 const int kWatchForAddressChangeRetryIntervalMs = 500;
 
-}  // namespace
-
-// Thread on which we can run DnsConfigService, which requires AssertIOAllowed
-// to open registry keys and to handle FilePathWatcher updates.
-class NetworkChangeNotifierWin::DnsConfigServiceThread : public base::Thread {
- public:
-  DnsConfigServiceThread() : base::Thread("DnsConfigService") {}
-
-  ~DnsConfigServiceThread() override { Stop(); }
-
-  void Init() override {
-    service_ = DnsConfigService::CreateSystemService();
-    service_->WatchConfig(base::Bind(&NetworkChangeNotifier::SetDnsConfig));
-  }
-
-  void CleanUp() override { service_.reset(); }
-
- private:
-  std::unique_ptr<DnsConfigService> service_;
-
-  DISALLOW_COPY_AND_ASSIGN(DnsConfigServiceThread);
-};
-
-NetworkChangeNotifierWin::NetworkChangeNotifierWin()
-    : NetworkChangeNotifier(NetworkChangeCalculatorParamsWin()),
-      is_watching_(false),
-      sequential_failures_(0),
-      dns_config_service_thread_(new DnsConfigServiceThread()),
-      last_computed_connection_type_(RecomputeCurrentConnectionType()),
-      last_announced_offline_(last_computed_connection_type_ ==
-                              CONNECTION_NONE),
-      weak_factory_(this) {
-  memset(&addr_overlapped_, 0, sizeof addr_overlapped_);
-  addr_overlapped_.hEvent = WSACreateEvent();
-}
-
-NetworkChangeNotifierWin::~NetworkChangeNotifierWin() {
-  if (is_watching_) {
-    CancelIPChangeNotify(&addr_overlapped_);
-    addr_watcher_.StopWatching();
-  }
-  WSACloseEvent(addr_overlapped_.hEvent);
-}
-
-// static
-NetworkChangeNotifier::NetworkChangeCalculatorParams
-NetworkChangeNotifierWin::NetworkChangeCalculatorParamsWin() {
-  NetworkChangeCalculatorParams params;
-  // Delay values arrived at by simple experimentation and adjusted so as to
-  // produce a single signal when switching between network connections.
-  params.ip_address_offline_delay_ = base::TimeDelta::FromMilliseconds(1500);
-  params.ip_address_online_delay_ = base::TimeDelta::FromMilliseconds(1500);
-  params.connection_type_offline_delay_ =
-      base::TimeDelta::FromMilliseconds(1500);
-  params.connection_type_online_delay_ = base::TimeDelta::FromMilliseconds(500);
-  return params;
-}
-
 // This implementation does not return the actual connection type but merely
 // determines if the user is "online" (in which case it returns
 // CONNECTION_UNKNOWN) or "offline" (and then it returns CONNECTION_NONE).
 // This is challenging since the only thing we can test with certainty is
 // whether a *particular* host is reachable.
 //
 // While we can't conclusively determine when a user is "online", we can at
 // least reliably recognize some of the situtations when they are clearly
 // "offline". For example, if the user's laptop is not plugged into an ethernet
 // network and is not connected to any wireless networks, it must be offline.
@@ skipping 28 matching lines @@
 // workstation. Here is what I found:
 //   * Approach (1) was pretty much zero-cost after the initial call.
 //   * Approach (2) took an average of 3.25 milliseconds to enumerate the
 //     adapters.
 //   * Approach (3) took an average of 0.8 ms to enumerate the providers.
 //
 // In terms of correctness, all three approaches were comparable for the simple
 // experiments I ran... However none of them correctly returned "offline" when
 // executing 'ipconfig /release'.
 //
-NetworkChangeNotifier::ConnectionType
-NetworkChangeNotifierWin::RecomputeCurrentConnectionType() const {
-  DCHECK(CalledOnValidThread());
-
+// It is not thread safe, see crbug.com/324913.
+NetworkChangeNotifier::ConnectionType RecomputeCurrentConnectionType() {
   EnsureWinsockInit();
 
   // The following code was adapted from:
   // http://src.chromium.org/viewvc/chrome/trunk/src/chrome/common/net/notifier/base/win/async_network_alive_win32.cc?view=markup&pathrev=47343
   // The main difference is we only call WSALookupServiceNext once, whereas
   // the earlier code would traverse the entire list and pass LUP_FLUSHPREVIOUS
   // to skip past the large results.
 
   HANDLE ws_handle;
   WSAQUERYSET query_set = {0};
@@ skipping 43 matching lines @@
     } else {
       LOG(WARNING) << "WSALookupServiceNext() failed with:" << result;
     }
   }
 
   result = WSALookupServiceEnd(ws_handle);
   LOG_IF(ERROR, result != 0)
       << "WSALookupServiceEnd() failed with: " << result;
 
   // TODO(droger): Return something more detailed than CONNECTION_UNKNOWN.
-  return found_connection ? ConnectionTypeFromInterfaces()
-                          : NetworkChangeNotifier::CONNECTION_NONE;
+  return found_connection
+             ? NetworkChangeNotifier::ConnectionTypeFromInterfaces()
+             : NetworkChangeNotifier::CONNECTION_NONE;
+}
+
+}  // namespace
+
+// Thread on which we can run DnsConfigService, which requires AssertIOAllowed
+// to open registry keys and to handle FilePathWatcher updates.
+class NetworkChangeNotifierWin::DnsConfigServiceThread : public base::Thread {
+ public:
+  DnsConfigServiceThread() : base::Thread("DnsConfigService") {}
+
+  ~DnsConfigServiceThread() override { Stop(); }
+
+  void Init() override {
+    service_ = DnsConfigService::CreateSystemService();
+    service_->WatchConfig(base::Bind(&NetworkChangeNotifier::SetDnsConfig));
+  }
+
+  void CleanUp() override { service_.reset(); }
+
+ private:
+  std::unique_ptr<DnsConfigService> service_;
+
+  DISALLOW_COPY_AND_ASSIGN(DnsConfigServiceThread);
+};
+
+NetworkChangeNotifierWin::NetworkChangeNotifierWin()
+    : NetworkChangeNotifier(NetworkChangeCalculatorParamsWin()),
+      is_watching_(false),
+      sequential_failures_(0),
+      dns_config_service_thread_(new DnsConfigServiceThread()),
+      last_computed_connection_type_(RecomputeCurrentConnectionType()),
+      last_announced_offline_(last_computed_connection_type_ ==
+                              CONNECTION_NONE),
+      calculate_connection_type_(
+          base::BindRepeating(&RecomputeCurrentConnectionType)),
+      weak_factory_(this) {
+  memset(&addr_overlapped_, 0, sizeof addr_overlapped_);
+  addr_overlapped_.hEvent = WSACreateEvent();
+}
+
+NetworkChangeNotifierWin::~NetworkChangeNotifierWin() {
+  if (is_watching_) {
+    CancelIPChangeNotify(&addr_overlapped_);
+    addr_watcher_.StopWatching();
+  }
+  WSACloseEvent(addr_overlapped_.hEvent);
+}
+
+// static
+NetworkChangeNotifier::NetworkChangeCalculatorParams
+NetworkChangeNotifierWin::NetworkChangeCalculatorParamsWin() {
+  NetworkChangeCalculatorParams params;
+  // Delay values arrived at by simple experimentation and adjusted so as to
+  // produce a single signal when switching between network connections.
+  params.ip_address_offline_delay_ = base::TimeDelta::FromMilliseconds(1500);
+  params.ip_address_online_delay_ = base::TimeDelta::FromMilliseconds(1500);
+  params.connection_type_offline_delay_ =
+      base::TimeDelta::FromMilliseconds(1500);
+  params.connection_type_online_delay_ = base::TimeDelta::FromMilliseconds(500);
+  return params;
 }
 
 NetworkChangeNotifier::ConnectionType
 NetworkChangeNotifierWin::GetCurrentConnectionType() const {
   base::AutoLock auto_lock(last_computed_connection_type_lock_);
   return last_computed_connection_type_;
 }
 
 void NetworkChangeNotifierWin::SetCurrentConnectionType(
     ConnectionType connection_type) {
   base::AutoLock auto_lock(last_computed_connection_type_lock_);
   last_computed_connection_type_ = connection_type;
 }
 
 void NetworkChangeNotifierWin::OnObjectSignaled(HANDLE object) {
   DCHECK(CalledOnValidThread());
   DCHECK(is_watching_);
   is_watching_ = false;
 
   // Start watching for the next address change.
   WatchForAddressChange();
+  DCHECK(dns_task_runner_);
 
-  NotifyObservers();
+  base::PostTaskAndReplyWithResult(
+      dns_task_runner_.get(), FROM_HERE, calculate_connection_type_,
+      base::Bind(&NetworkChangeNotifierWin::NotifyObservers,
+                 weak_factory_.GetWeakPtr()));
 }
 
-void NetworkChangeNotifierWin::NotifyObservers() {
+void NetworkChangeNotifierWin::NotifyObservers(ConnectionType connection_type) {
   DCHECK(CalledOnValidThread());
-  SetCurrentConnectionType(RecomputeCurrentConnectionType());
+  SetCurrentConnectionType(connection_type);
   NotifyObserversOfIPAddressChange();
 
   // Calling GetConnectionType() at this very moment is likely to give
   // the wrong result, so we delay that until a little bit later.
   //
   // The one second delay chosen here was determined experimentally
   // by adamk on Windows 7.
   // If after one second we determine we are still offline, we will
   // delay again.
   offline_polls_ = 0;
+  // TODO(jkarlin): I'm not sure that calling with 'this' is safe. Can it be
+  // deleted?
   timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this,
                &NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange);
 }
 
 void NetworkChangeNotifierWin::WatchForAddressChange() {
   DCHECK(CalledOnValidThread());
   DCHECK(!is_watching_);
 
   // NotifyAddrChange occasionally fails with ERROR_OPEN_FAILED for unknown
   // reasons.  More rarely, it's also been observed failing with
@@ skipping 13 matching lines @@
         FROM_HERE, base::Bind(&NetworkChangeNotifierWin::WatchForAddressChange,
                               weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(
             kWatchForAddressChangeRetryIntervalMs));
     return;
   }
 
   // Treat the transition from NotifyAddrChange failing to succeeding as a
   // network change event, since network changes were not being observed in
   // that interval.
-  if (sequential_failures_ > 0)
-    NotifyObservers();
+  if (sequential_failures_ > 0) {
+    base::PostTaskAndReplyWithResult(
+        dns_task_runner_.get(), FROM_HERE, calculate_connection_type_,
+        base::Bind(&NetworkChangeNotifierWin::NotifyObservers,
+                   weak_factory_.GetWeakPtr()));
+  }
 
   if (sequential_failures_ < 2000) {
     UMA_HISTOGRAM_COUNTS_10000("Net.NotifyAddrChangeFailures",
                                sequential_failures_);
   }
 
   is_watching_ = true;
   sequential_failures_ = 0;
 }
 
 bool NetworkChangeNotifierWin::WatchForAddressChangeInternal() {
   DCHECK(CalledOnValidThread());
 
   if (!dns_config_service_thread_->IsRunning()) {
     dns_config_service_thread_->StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
+    if (!dns_task_runner_)
+      dns_task_runner_ =
+          dns_config_service_thread_->message_loop()->task_runner();
   }
 
   ResetEventIfSignaled(addr_overlapped_.hEvent);
   HANDLE handle = NULL;
   DWORD ret = NotifyAddrChange(&handle, &addr_overlapped_);
   if (ret != ERROR_IO_PENDING)
     return false;
 
   addr_watcher_.StartWatchingOnce(addr_overlapped_.hEvent, this);
   return true;
 }
 
 void NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange() {
-  SetCurrentConnectionType(RecomputeCurrentConnectionType());
+  base::PostTaskAndReplyWithResult(
+      dns_task_runner_.get(), FROM_HERE, calculate_connection_type_,
+      base::Bind(
+          &NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChangeImpl,
+          weak_factory_.GetWeakPtr()));
+}
+
+void NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChangeImpl(
+    ConnectionType connection_type) {
+  SetCurrentConnectionType(connection_type);
   bool current_offline = IsOffline();
   offline_polls_++;
   // If we continue to appear offline, delay sending out the notification in
   // case we appear to go online within 20 seconds.  UMA histogram data shows
   // we may not detect the transition to online state after 1 second but within
   // 20 seconds we generally do.
   if (last_announced_offline_ && current_offline && offline_polls_ <= 20) {
     timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this,
                  &NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange);
     return;
   }
   if (last_announced_offline_)
     UMA_HISTOGRAM_CUSTOM_COUNTS("NCN.OfflinePolls", offline_polls_, 1, 50, 50);
   last_announced_offline_ = current_offline;
 
   NotifyObserversOfConnectionTypeChange();
   double max_bandwidth_mbps = 0.0;
-  ConnectionType connection_type = CONNECTION_NONE;
+  ConnectionType connection_type2 = CONNECTION_NONE;

[pauljensen, 2017/05/22 18:01:51]

can we give this variable a more descriptive name?

[jkarlin, 2017/05/23 11:44:38]

Done.

   GetCurrentMaxBandwidthAndConnectionType(&max_bandwidth_mbps,
-                                          &connection_type);
-  NotifyObserversOfMaxBandwidthChange(max_bandwidth_mbps, connection_type);
+                                          &connection_type2);
+  NotifyObserversOfMaxBandwidthChange(max_bandwidth_mbps, connection_type2);
 }
 
 }  // namespace net