Replace deprecated base::NonThreadSafe in extensions/browser/api/cast_channel in favor of SequenceC…

extensions/browser/api/cast_channel/cast_transport.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 "extensions/browser/api/cast_channel/cast_transport.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 38 matching lines @@
   DCHECK(socket);
 
   // Buffer is reused across messages to minimize unnecessary buffer
   // [re]allocations.
   read_buffer_ = new net::GrowableIOBuffer();
   read_buffer_->SetCapacity(MessageFramer::MessageHeader::max_message_size());
   framer_.reset(new MessageFramer(read_buffer_));
 }
 
 CastTransportImpl::~CastTransportImpl() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   FlushWriteQueue();
 }
 
 bool CastTransportImpl::IsTerminalWriteState(
     CastTransportImpl::WriteState write_state) {
   return write_state == WRITE_STATE_ERROR || write_state == WRITE_STATE_IDLE;
 }
 
 bool CastTransportImpl::IsTerminalReadState(
     CastTransportImpl::ReadState read_state) {
@@ skipping 69 matching lines @@
       return proto::CHANNEL_ERROR_CONNECT_TIMEOUT;
     case CHANNEL_ERROR_UNKNOWN:
       return proto::CHANNEL_ERROR_UNKNOWN;
     default:
       NOTREACHED();
       return proto::CHANNEL_ERROR_NONE;
   }
 }
 
 void CastTransportImpl::SetReadDelegate(std::unique_ptr<Delegate> delegate) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(delegate);
   delegate_ = std::move(delegate);
   if (started_) {
     delegate_->Start();
   }
 }
 
 void CastTransportImpl::FlushWriteQueue() {
   for (; !write_queue_.empty(); write_queue_.pop()) {
     net::CompletionCallback& callback = write_queue_.front().callback;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, net::ERR_FAILED));
     callback.Reset();
   }
 }
 
 void CastTransportImpl::SendMessage(const CastMessage& message,
                                     const net::CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   std::string serialized_message;
   if (!MessageFramer::Serialize(message, &serialized_message)) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, net::ERR_FAILED));
     return;
   }
   WriteRequest write_request(
       message.namespace_(), serialized_message, callback);
 
   write_queue_.push(write_request);
@@ skipping 28 matching lines @@
   if (write_state_ != write_state)
     write_state_ = write_state;
 }
 
 void CastTransportImpl::SetErrorState(ChannelError error_state) {
   VLOG_WITH_CONNECTION(2) << "SetErrorState: " << error_state;
   error_state_ = error_state;
 }
 
 void CastTransportImpl::OnWriteResult(int result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_NE(WRITE_STATE_IDLE, write_state_);
   if (write_queue_.empty()) {
     SetWriteState(WRITE_STATE_IDLE);
     return;
   }
 
   // Network operations can either finish synchronously or asynchronously.
   // This method executes the state machine transitions in a loop so that
   // write state transitions happen even when network operations finish
   // synchronously.
@@ skipping 95 matching lines @@
 
 int CastTransportImpl::DoWriteHandleError(int result) {
   VLOG_WITH_CONNECTION(2) << "DoWriteHandleError result=" << result;
   DCHECK_NE(CHANNEL_ERROR_NONE, error_state_);
   DCHECK_LT(result, 0);
   SetWriteState(WRITE_STATE_ERROR);
   return net::ERR_FAILED;
 }
 
 void CastTransportImpl::Start() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!started_);
   DCHECK_EQ(READ_STATE_READ, read_state_);
   DCHECK(delegate_) << "Read delegate must be set prior to calling Start()";
   started_ = true;
   delegate_->Start();
   SetReadState(READ_STATE_READ);
 
   // Start the read state machine.
   OnReadResult(net::OK);
 }
 
 void CastTransportImpl::OnReadResult(int result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // Network operations can either finish synchronously or asynchronously.
   // This method executes the state machine transitions in a loop so that
   // write state transitions happen even when network operations finish
   // synchronously.
   int rv = result;
   do {
     VLOG_WITH_CONNECTION(2) << "OnReadResult(state=" << read_state_
                             << ", result=" << rv << ")";
     ReadState state = read_state_;
     read_state_ = READ_STATE_UNKNOWN;
@@ skipping 87 matching lines @@
   VLOG_WITH_CONNECTION(2) << "DoReadHandleError";
   DCHECK_NE(CHANNEL_ERROR_NONE, error_state_);
   DCHECK_LE(result, 0);
   SetReadState(READ_STATE_ERROR);
   return net::ERR_FAILED;
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions