Move off of deprecated base::NonThreadSafe in device/

device/serial/serial_io_handler_posix.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 "device/serial/serial_io_handler_posix.h"
 
 #include <sys/ioctl.h>
 #include <termios.h>
 
 #include "base/files/file_util.h"
@@ skipping 102 matching lines @@
 
 // static
 scoped_refptr<SerialIoHandler> SerialIoHandler::Create(
     scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner) {
   return new SerialIoHandlerPosix(file_thread_task_runner,
                                   ui_thread_task_runner);
 }
 
 void SerialIoHandlerPosix::ReadImpl() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(pending_read_buffer());
   DCHECK(file().IsValid());
 
   // Try to read immediately. This is needed because on some platforms
   // (e.g., OSX) there may not be a notification from the message loop
   // when the fd is ready to read immediately after it is opened. There
   // is no danger of blocking because the fd is opened with async flag.
   AttemptRead(true);
 }
 
 void SerialIoHandlerPosix::WriteImpl() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(pending_write_buffer());
   DCHECK(file().IsValid());
 
   EnsureWatchingWrites();
 }
 
 void SerialIoHandlerPosix::CancelReadImpl() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   file_read_watcher_.reset();
   QueueReadCompleted(0, read_cancel_reason());
 }
 
 void SerialIoHandlerPosix::CancelWriteImpl() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   file_write_watcher_.reset();
   QueueWriteCompleted(0, write_cancel_reason());
 }
 
 bool SerialIoHandlerPosix::ConfigurePortImpl() {
 #if defined(OS_LINUX)
   struct termios2 config;
   if (ioctl(file().GetPlatformFile(), TCGETS2, &config) < 0) {
 #else
   struct termios config;
@@ skipping 133 matching lines @@
 
 SerialIoHandlerPosix::SerialIoHandlerPosix(
     scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner)
     : SerialIoHandler(file_thread_task_runner, ui_thread_task_runner) {}
 
 SerialIoHandlerPosix::~SerialIoHandlerPosix() {
 }
 
 void SerialIoHandlerPosix::AttemptRead(bool within_read) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (pending_read_buffer()) {
     int bytes_read = HANDLE_EINTR(read(file().GetPlatformFile(),
                                        pending_read_buffer(),
                                        pending_read_buffer_len()));
     if (bytes_read < 0) {
       if (errno == EAGAIN) {
         // The fd does not have data to read yet so continue waiting.
         EnsureWatchingReads();
       } else if (errno == ENXIO) {
@@ skipping 36 matching lines @@
     // completes and releases the pending_read_buffer.
     file_read_watcher_.reset();
 
     QueueReadCompleted(bytes_read, error);
   } else {
     ReadCompleted(bytes_read, error);
   }
 }
 
 void SerialIoHandlerPosix::OnFileCanWriteWithoutBlocking() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (pending_write_buffer()) {
     int bytes_written = HANDLE_EINTR(write(file().GetPlatformFile(),
                                            pending_write_buffer(),
                                            pending_write_buffer_len()));
     if (bytes_written < 0) {
       WriteCompleted(0, serial::SendError::SYSTEM_ERROR);
     } else {
       WriteCompleted(bytes_written, serial::SendError::NONE);
     }
   } else {
     // Stop watching the fd if we get notifications with no pending
     // writes to avoid starving the message loop.
     file_write_watcher_.reset();
   }
 }
 
 void SerialIoHandlerPosix::EnsureWatchingReads() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(file().IsValid());
   if (!file_read_watcher_) {
     file_read_watcher_ = base::FileDescriptorWatcher::WatchReadable(
         file().GetPlatformFile(), base::Bind(&SerialIoHandlerPosix::AttemptRead,
                                              base::Unretained(this), false));
   }
 }
 
 void SerialIoHandlerPosix::EnsureWatchingWrites() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(file().IsValid());
   if (!file_write_watcher_) {
     file_write_watcher_ = base::FileDescriptorWatcher::WatchWritable(
         file().GetPlatformFile(),
         base::Bind(&SerialIoHandlerPosix::OnFileCanWriteWithoutBlocking,
                    base::Unretained(this)));
   }
 }
 
 bool SerialIoHandlerPosix::Flush() const {
@@ skipping 231 matching lines @@
   memcpy(buffer, chars_stashed_, std::min(new_bytes_read, 2));
   memcpy(chars_stashed_, tmp, num_chars_stashed_);
   return new_bytes_read;
 }
 
 std::string SerialIoHandler::MaybeFixUpPortName(const std::string& port_name) {
   return port_name;
 }
 
 }  // namespace device