Deprecate NonThreadSafe in net/ in favor of SequenceChecker/ThreadChecker.

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"
@@ skipping 47 matching lines @@
       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() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (is_watching_) {
     CancelIPChangeNotify(&addr_overlapped_);

[mmenke, 2017/05/26 20:20:03]

This class uses an overlapped structure, which I don't believe is safe to
teardown on threads other than the one on which it was created.

Do we have a standard way to account for that?

     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
@@ skipping 49 matching lines @@
 //   * 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());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   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;
@@ skipping 61 matching lines @@
   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_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(is_watching_);
   is_watching_ = false;
 
   // Start watching for the next address change.
   WatchForAddressChange();
 
   NotifyObservers();
 }
 
 void NetworkChangeNotifierWin::NotifyObservers() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   SetCurrentConnectionType(RecomputeCurrentConnectionType());
   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;
   timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this,
                &NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange);
 }
 
 void NetworkChangeNotifierWin::WatchForAddressChange() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!is_watching_);
 
   // NotifyAddrChange occasionally fails with ERROR_OPEN_FAILED for unknown
   // reasons.  More rarely, it's also been observed failing with
   // ERROR_NO_SYSTEM_RESOURCES.  When either of these happens, we retry later.
   if (!WatchForAddressChangeInternal()) {
     ++sequential_failures_;
 
     // TODO(mmenke):  If the UMA histograms indicate that this fixes
     // http://crbug.com/69198, remove this histogram and consider reducing the
@@ skipping 20 matching lines @@
   if (sequential_failures_ < 2000) {
     UMA_HISTOGRAM_COUNTS_10000("Net.NotifyAddrChangeFailures",
                                sequential_failures_);
   }
 
   is_watching_ = true;
   sequential_failures_ = 0;
 }
 
 bool NetworkChangeNotifierWin::WatchForAddressChangeInternal() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (!dns_config_service_thread_->IsRunning()) {
     dns_config_service_thread_->StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
   }
 
   ResetEventIfSignaled(addr_overlapped_.hEvent);
   HANDLE handle = NULL;
   DWORD ret = NotifyAddrChange(&handle, &addr_overlapped_);
   if (ret != ERROR_IO_PENDING)
@@ skipping 22 matching lines @@
 
   NotifyObserversOfConnectionTypeChange();
   double max_bandwidth_mbps = 0.0;
   ConnectionType connection_type = CONNECTION_NONE;
   GetCurrentMaxBandwidthAndConnectionType(&max_bandwidth_mbps,
                                           &connection_type);
   NotifyObserversOfMaxBandwidthChange(max_bandwidth_mbps, connection_type);
 }
 
 }  // namespace net