Replace deprecated base::NonThreadSafe in chrome/browser/devtools in favor of SequenceChecker.

chrome/browser/devtools/device/android_device_manager.cc

 // Copyright 2014 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 "chrome/browser/devtools/device/android_device_manager.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <utility>
@@ skipping 439 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> device_task_runner,
     scoped_refptr<DeviceProvider> provider,
     const std::string& serial)
     : task_runner_(device_task_runner),
       provider_(provider),
       serial_(serial),
       weak_factory_(this) {
 }
 
 AndroidDeviceManager::Device::~Device() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   provider_->AddRef();
   DeviceProvider* raw_ptr = provider_.get();
   provider_ = nullptr;
   task_runner_->PostTask(FROM_HERE,
                          base::BindOnce(&ReleaseDeviceAndProvider,
                                         base::Unretained(raw_ptr), serial_));
 }
 
 AndroidDeviceManager::HandlerThread*
 AndroidDeviceManager::HandlerThread::instance_ = nullptr;
@@ skipping 64 matching lines @@
                         base::Bind(&AndroidDeviceManager::UpdateDevices,
                                    weak_factory_.GetWeakPtr(), callback));
 }
 
 AndroidDeviceManager::AndroidDeviceManager()
     : handler_thread_(HandlerThread::GetInstance()),
       weak_factory_(this) {
 }
 
 AndroidDeviceManager::~AndroidDeviceManager() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   SetDeviceProviders(DeviceProviders());
 }
 
 void AndroidDeviceManager::UpdateDevices(
     const DevicesCallback& callback,
     std::unique_ptr<DeviceDescriptors> descriptors) {
   Devices response;
   DeviceWeakMap new_devices;
   for (DeviceDescriptors::const_iterator it = descriptors->begin();
        it != descriptors->end();
        ++it) {
     DeviceWeakMap::iterator found = devices_.find(it->serial);
     scoped_refptr<Device> device;
     if (found == devices_.end() || !found->second ||
         found->second->provider_.get() != it->provider.get()) {
       device =
           new Device(handler_thread_->message_loop(), it->provider, it->serial);
     } else {
       device = found->second.get();
     }
     response.push_back(device);
     new_devices[it->serial] = device->weak_factory_.GetWeakPtr();
   }
   devices_.swap(new_devices);
   callback.Run(response);
 }