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

net/dns/address_sorter_posix.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/address_sorter_posix.h"
 
 #include <netinet/in.h>
 
 #include <memory>
 #include <utility>
@@ skipping 233 matching lines @@
                                    arraysize(kDefaultPrecedenceTable))),
       label_table_(LoadPolicy(kDefaultLabelTable,
                               arraysize(kDefaultLabelTable))),
       ipv4_scope_table_(LoadPolicy(kDefaultIPv4ScopeTable,
                               arraysize(kDefaultIPv4ScopeTable))) {
   NetworkChangeNotifier::AddIPAddressObserver(this);
   OnIPAddressChanged();
 }
 
 AddressSorterPosix::~AddressSorterPosix() {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 void AddressSorterPosix::Sort(const AddressList& list,
                               const CallbackType& callback) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   std::vector<std::unique_ptr<DestinationInfo>> sort_list;
 
   for (size_t i = 0; i < list.size(); ++i) {
     std::unique_ptr<DestinationInfo> info(new DestinationInfo());
     info->address = list[i].address();
     info->scope = GetScope(ipv4_scope_table_, info->address);
     info->precedence = GetPolicyValue(precedence_table_, info->address);
     info->label = GetPolicyValue(label_table_, info->address);
 
     // Each socket can only be bound once.
@@ skipping 38 matching lines @@
   std::stable_sort(sort_list.begin(), sort_list.end(), CompareDestinations);
 
   AddressList result;
   for (size_t i = 0; i < sort_list.size(); ++i)
     result.push_back(IPEndPoint(sort_list[i]->address, 0 /* port */));
 
   callback.Run(true, result);
 }
 
 void AddressSorterPosix::OnIPAddressChanged() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   source_map_.clear();
 #if defined(OS_LINUX)
   const internal::AddressTrackerLinux* tracker =
       NetworkChangeNotifier::GetAddressTracker();
   if (!tracker)
     return;
   typedef internal::AddressTrackerLinux::AddressMap AddressMap;
   AddressMap map = tracker->GetAddressMap();
   for (AddressMap::const_iterator it = map.begin(); it != map.end(); ++it) {
     const IPAddress& address = it->first;
@@ skipping 49 matching lines @@
     }
     FillPolicy(src.address(), &info);
   }
   freeifaddrs(addrs);
   close(ioctl_socket);
 #endif
 }
 
 void AddressSorterPosix::FillPolicy(const IPAddress& address,
                                     SourceAddressInfo* info) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   info->scope = GetScope(ipv4_scope_table_, address);
   info->label = GetPolicyValue(label_table_, address);
 }
 
 // static
 std::unique_ptr<AddressSorter> AddressSorter::CreateAddressSorter() {
   return std::unique_ptr<AddressSorter>(
       new AddressSorterPosix(ClientSocketFactory::GetDefaultFactory()));
 }
 
 }  // namespace net