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

net/dns/dns_config_service_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/dns/dns_config_service_win.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_path_watcher.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/free_deleter.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
-#include "base/threading/non_thread_safe.h"
+#include "base/threading/thread_checker.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "net/base/ip_address.h"
 #include "net/base/network_change_notifier.h"
 #include "net/dns/dns_hosts.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/serial_worker.h"
@@ skipping 25 matching lines @@
 enum HostsParseWinResult {
   HOSTS_PARSE_WIN_OK = 0,
   HOSTS_PARSE_WIN_UNREADABLE_HOSTS_FILE,
   HOSTS_PARSE_WIN_COMPUTER_NAME_FAILED,
   HOSTS_PARSE_WIN_IPHELPER_FAILED,
   HOSTS_PARSE_WIN_BAD_ADDRESS,
   HOSTS_PARSE_WIN_MAX  // Bounding values for enumeration.
 };
 
 // Convenience for reading values using RegKey.
-class RegistryReader : public base::NonThreadSafe {
+class RegistryReader {
  public:
   explicit RegistryReader(const wchar_t* key) {
     // Ignoring the result. |key_.Valid()| will catch failures.
     key_.Open(HKEY_LOCAL_MACHINE, key, KEY_QUERY_VALUE);
   }
 
+  ~RegistryReader() { DCHECK_CALLED_ON_VALID_THREAD(thread_checker_); }
+
   bool ReadString(const wchar_t* name,
                   DnsSystemSettings::RegString* out) const {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     out->set = false;
     if (!key_.Valid()) {
       // Assume that if the |key_| is invalid then the key is missing.
       return true;
     }
     LONG result = key_.ReadValue(name, &out->value);
     if (result == ERROR_SUCCESS) {
       out->set = true;
       return true;
     }
     return (result == ERROR_FILE_NOT_FOUND);
   }
 
   bool ReadDword(const wchar_t* name,
                  DnsSystemSettings::RegDword* out) const {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     out->set = false;
     if (!key_.Valid()) {
       // Assume that if the |key_| is invalid then the key is missing.
       return true;
     }
     LONG result = key_.ReadValueDW(name, &out->value);
     if (result == ERROR_SUCCESS) {
       out->set = true;
       return true;
     }
     return (result == ERROR_FILE_NOT_FOUND);
   }
 
  private:
   base::win::RegKey key_;
 
+  THREAD_CHECKER(thread_checker_);
+
   DISALLOW_COPY_AND_ASSIGN(RegistryReader);
 };
 
 // Wrapper for GetAdaptersAddresses. Returns NULL if failed.
 std::unique_ptr<IP_ADAPTER_ADDRESSES, base::FreeDeleter> ReadIpHelper(
     ULONG flags) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   std::unique_ptr<IP_ADAPTER_ADDRESSES, base::FreeDeleter> out;
   ULONG len = 15000;  // As recommended by MSDN for GetAdaptersAddresses.
@@ skipping 156 matching lines @@
       } else if (!have_ipv6 && (ipe.GetFamily() == ADDRESS_FAMILY_IPV6)) {
         have_ipv6 = true;
         (*hosts)[DnsHostsKey(localname, ADDRESS_FAMILY_IPV6)] = ipe.address();
       }
     }
   }
   return HOSTS_PARSE_WIN_OK;
 }
 
 // Watches a single registry key for changes.
-class RegistryWatcher : public base::NonThreadSafe {
+class RegistryWatcher {
  public:
   typedef base::Callback<void(bool succeeded)> CallbackType;
   RegistryWatcher() {}
 
+  ~RegistryWatcher() { DCHECK_CALLED_ON_VALID_THREAD(thread_checker_); }
+
   bool Watch(const wchar_t* key, const CallbackType& callback) {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     DCHECK(!callback.is_null());
     DCHECK(callback_.is_null());
     callback_ = callback;
     if (key_.Open(HKEY_LOCAL_MACHINE, key, KEY_NOTIFY) != ERROR_SUCCESS)
       return false;
 
     return key_.StartWatching(base::Bind(&RegistryWatcher::OnObjectSignaled,
                                          base::Unretained(this)));
   }
 
   void OnObjectSignaled() {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     DCHECK(!callback_.is_null());
     if (key_.StartWatching(base::Bind(&RegistryWatcher::OnObjectSignaled,
                                       base::Unretained(this)))) {
       callback_.Run(true);
     } else {
       key_.Close();
       callback_.Run(false);
     }
   }
 
  private:
   CallbackType callback_;
   base::win::RegKey key_;
 
+  THREAD_CHECKER(thread_checker_);
+
   DISALLOW_COPY_AND_ASSIGN(RegistryWatcher);
 };
 
 // Returns true iff |address| is DNS address from IPv6 stateless discovery,
 // i.e., matches fec0:0:0:ffff::{1,2,3}.
 // http://tools.ietf.org/html/draft-ietf-ipngwg-dns-discovery
 bool IsStatelessDiscoveryAddress(const IPAddress& address) {
   if (!address.IsIPv6())
     return false;
   const uint8_t kPrefix[] = {0xfe, 0xc0, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
@@ skipping 431 matching lines @@
 }
 
 }  // namespace internal
 
 // static
 std::unique_ptr<DnsConfigService> DnsConfigService::CreateSystemService() {
   return std::unique_ptr<DnsConfigService>(new internal::DnsConfigServiceWin());
 }
 
 }  // namespace net