Deprecate NonThreadSafe in remoting in favor of SequenceChecker.

remoting/protocol/channel_multiplexer.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 "remoting/protocol/channel_multiplexer.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/net_errors.h"
 #include "remoting/protocol/message_serialization.h"
 #include "remoting/protocol/p2p_stream_socket.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
@@ skipping 62 matching lines @@
   int send_id_;
   bool id_sent_;
   int receive_id_;
   MuxSocket* socket_;
   std::list<std::unique_ptr<PendingPacket>> pending_packets_;
 
   DISALLOW_COPY_AND_ASSIGN(MuxChannel);
 };
 
 class ChannelMultiplexer::MuxSocket : public P2PStreamSocket,
-                                      public base::NonThreadSafe,
                                       public base::SupportsWeakPtr<MuxSocket> {
  public:
   MuxSocket(MuxChannel* channel);
   ~MuxSocket() override;
 
   void OnWriteComplete();
   void OnBaseChannelError(int error);
   void OnPacketReceived();
 
   // P2PStreamSocket interface.
   int Read(const scoped_refptr<net::IOBuffer>& buffer, int buffer_len,
            const net::CompletionCallback& callback) override;
   int Write(const scoped_refptr<net::IOBuffer>& buffer, int buffer_len,
             const net::CompletionCallback& callback) override;
 
  private:
   MuxChannel* channel_;
 
   int base_channel_error_ = net::OK;
 
   net::CompletionCallback read_callback_;
   scoped_refptr<net::IOBuffer> read_buffer_;
   int read_buffer_size_;
 
   bool write_pending_;
   int write_result_;
   net::CompletionCallback write_callback_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   DISALLOW_COPY_AND_ASSIGN(MuxSocket);
 };
 
 
 ChannelMultiplexer::MuxChannel::MuxChannel(
     ChannelMultiplexer* multiplexer,
     const std::string& name,
     int send_id)
     : multiplexer_(multiplexer),
       name_(name),
@@ skipping 74 matching lines @@
       write_result_(0) {
 }
 
 ChannelMultiplexer::MuxSocket::~MuxSocket() {
   channel_->OnSocketDestroyed();
 }
 
 int ChannelMultiplexer::MuxSocket::Read(
     const scoped_refptr<net::IOBuffer>& buffer, int buffer_len,
     const net::CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(read_callback_.is_null());
 
   if (base_channel_error_ != net::OK)
     return base_channel_error_;
 
   int result = channel_->DoRead(buffer, buffer_len);
   if (result == 0) {
     read_buffer_ = buffer;
     read_buffer_size_ = buffer_len;
     read_callback_ = callback;
     return net::ERR_IO_PENDING;
   }
   return result;
 }
 
 int ChannelMultiplexer::MuxSocket::Write(
     const scoped_refptr<net::IOBuffer>& buffer, int buffer_len,
     const net::CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(write_callback_.is_null());
 
   if (base_channel_error_ != net::OK)
     return base_channel_error_;
 
   std::unique_ptr<MultiplexPacket> packet(new MultiplexPacket());
   size_t size = std::min(kMaxPacketSize, buffer_len);
   packet->mutable_data()->assign(buffer->data(), size);
 
   write_pending_ = true;
@@ skipping 47 matching lines @@
 }
 
 ChannelMultiplexer::ChannelMultiplexer(StreamChannelFactory* factory,
                                        const std::string& base_channel_name)
     : base_channel_factory_(factory),
       base_channel_name_(base_channel_name),
       next_channel_id_(0),
       weak_factory_(this) {}
 
 ChannelMultiplexer::~ChannelMultiplexer() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(pending_channels_.empty());
 
   // Cancel creation of the base channel if it hasn't finished.
   if (base_channel_factory_)
     base_channel_factory_->CancelChannelCreation(base_channel_name_);
 }
 
 void ChannelMultiplexer::CreateChannel(const std::string& name,
                                        const ChannelCreatedCallback& callback) {
   if (base_channel_.get()) {
@@ skipping 131 matching lines @@
   channel->OnIncomingPacket(std::move(packet));
 }
 
 void ChannelMultiplexer::DoWrite(std::unique_ptr<MultiplexPacket> packet,
                                  const base::Closure& done_task) {
   writer_.Write(SerializeAndFrameMessage(*packet), done_task);
 }
 
 }  // namespace protocol
 }  // namespace remoting