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

chrome/browser/devtools/device/adb/mock_adb_server.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/adb/mock_adb_server.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
-#include "base/threading/non_thread_safe.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/browser_test.h"
 #include "content/public/test/test_utils.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/log/net_log_source.h"
 #include "net/socket/stream_socket.h"
@@ skipping 143 matching lines @@
     "   \"url\": \"about:blank\",\n"
     "   \"webSocketDebuggerUrl\": \"ws:///devtools/page/"
     "44681551-ADFD-2411-076B-3AB14C1C60E2\"\n"
     "}]";
 
 static const int kBufferSize = 16*1024;
 static const uint16_t kAdbPort = 5037;
 
 static const int kAdbMessageHeaderSize = 4;
 
-class SimpleHttpServer : base::NonThreadSafe {
+class SimpleHttpServer {
  public:
   class Parser {
    public:
     virtual int Consume(const char* data, int size) = 0;
     virtual ~Parser() {}
   };
 
   using SendCallback = base::Callback<void(const std::string&)>;
   using ParserFactory = base::Callback<Parser*(const SendCallback&)>;
 
   SimpleHttpServer(const ParserFactory& factory, net::IPEndPoint endpoint);
   virtual ~SimpleHttpServer();
 
  private:
-  class Connection : base::NonThreadSafe {
+  class Connection {
    public:
     Connection(net::StreamSocket* socket, const ParserFactory& factory);
     virtual ~Connection();
 
    private:
     void Send(const std::string& message);
     void ReadData();
     void OnDataRead(int count);
     void WriteData();
     void OnDataWritten(int count);
 
     std::unique_ptr<net::StreamSocket> socket_;
     std::unique_ptr<Parser> parser_;
     scoped_refptr<net::GrowableIOBuffer> input_buffer_;
     scoped_refptr<net::GrowableIOBuffer> output_buffer_;
     int bytes_to_write_;
     bool read_closed_;
+
+    SEQUENCE_CHECKER(sequence_checker_);
+
     base::WeakPtrFactory<Connection> weak_factory_;
 
     DISALLOW_COPY_AND_ASSIGN(Connection);
   };
 
   void OnConnect();
   void OnAccepted(int result);
 
   ParserFactory factory_;
   std::unique_ptr<net::TCPServerSocket> socket_;
   std::unique_ptr<net::StreamSocket> client_socket_;
+
+  SEQUENCE_CHECKER(sequence_checker_);
+
   base::WeakPtrFactory<SimpleHttpServer> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleHttpServer);
 };
 
 SimpleHttpServer::SimpleHttpServer(const ParserFactory& factory,
                                    net::IPEndPoint endpoint)
     : factory_(factory),
       socket_(new net::TCPServerSocket(nullptr, net::NetLogSource())),
       weak_factory_(this) {
   socket_->Listen(endpoint, 5);
   OnConnect();
 }
 
 SimpleHttpServer::~SimpleHttpServer() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 SimpleHttpServer::Connection::Connection(net::StreamSocket* socket,
                                          const ParserFactory& factory)
     : socket_(socket),
       parser_(factory.Run(base::Bind(&Connection::Send,
                                      base::Unretained(this)))),
       input_buffer_(new net::GrowableIOBuffer()),
       output_buffer_(new net::GrowableIOBuffer()),
       bytes_to_write_(0),
       read_closed_(false),
       weak_factory_(this) {
   input_buffer_->SetCapacity(kBufferSize);
   ReadData();
 }
 
 SimpleHttpServer::Connection::~Connection() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 void SimpleHttpServer::Connection::Send(const std::string& message) {
-  CHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   const char* data = message.c_str();
   int size = message.size();
 
   if ((output_buffer_->offset() + bytes_to_write_ + size) >
       output_buffer_->capacity()) {
     // If not enough space without relocation
     if (output_buffer_->capacity() < (bytes_to_write_ + size)) {
       // If even buffer is not enough
       int new_size = std::max(output_buffer_->capacity() * 2, size * 2);
       output_buffer_->SetCapacity(new_size);
     }
     memmove(output_buffer_->StartOfBuffer(),
             output_buffer_->data(),
             bytes_to_write_);
     output_buffer_->set_offset(0);
   }
 
   memcpy(output_buffer_->data() + bytes_to_write_, data, size);
   bytes_to_write_ += size;
 
   if (bytes_to_write_ == size)
     // If write loop wasn't yet started, then start it
     WriteData();
 }
 
 void SimpleHttpServer::Connection::ReadData() {
-  CHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (input_buffer_->RemainingCapacity() == 0)
     input_buffer_->SetCapacity(input_buffer_->capacity() * 2);
 
   int read_result = socket_->Read(
       input_buffer_.get(),
       input_buffer_->RemainingCapacity(),
       base::Bind(&Connection::OnDataRead, base::Unretained(this)));
 
   if (read_result != net::ERR_IO_PENDING)
     OnDataRead(read_result);
 }
 
 void SimpleHttpServer::Connection::OnDataRead(int count) {
-  CHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (count <= 0) {
     if (bytes_to_write_ == 0)
       delete this;
     else
       read_closed_ = true;
     return;
   }
   input_buffer_->set_offset(input_buffer_->offset() + count);
   int bytes_processed;
 
   do {
     char* data = input_buffer_->StartOfBuffer();
     int data_size = input_buffer_->offset();
     bytes_processed = parser_->Consume(data, data_size);
 
     if (bytes_processed) {
       memmove(data, data + bytes_processed, data_size - bytes_processed);
       input_buffer_->set_offset(data_size - bytes_processed);
     }
   } while (bytes_processed);
   // Posting to avoid deep recursion in case of synchronous IO
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::BindOnce(&Connection::ReadData, weak_factory_.GetWeakPtr()));
 }
 
 void SimpleHttpServer::Connection::WriteData() {
-  CHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   CHECK_GE(output_buffer_->capacity(),
            output_buffer_->offset() + bytes_to_write_) << "Overflow";
 
   int write_result = socket_->Write(
       output_buffer_.get(),
       bytes_to_write_,
       base::Bind(&Connection::OnDataWritten, base::Unretained(this)));
 
   if (write_result != net::ERR_IO_PENDING)
     OnDataWritten(write_result);
 }
 
 void SimpleHttpServer::Connection::OnDataWritten(int count) {
-  CHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (count < 0) {
     delete this;
     return;
   }
   CHECK_GT(count, 0);
   CHECK_GE(output_buffer_->capacity(),
            output_buffer_->offset() + bytes_to_write_) << "Overflow";
 
   bytes_to_write_ -= count;
   output_buffer_->set_offset(output_buffer_->offset() + count);
 
   if (bytes_to_write_ != 0)
     // Posting to avoid deep recursion in case of synchronous IO
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::BindOnce(&Connection::WriteData, weak_factory_.GetWeakPtr()));
   else if (read_closed_)
     delete this;
 }
 
 void SimpleHttpServer::OnConnect() {
-  CHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   int accept_result = socket_->Accept(&client_socket_,
       base::Bind(&SimpleHttpServer::OnAccepted, base::Unretained(this)));
 
   if (accept_result != net::ERR_IO_PENDING)
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::BindOnce(&SimpleHttpServer::OnAccepted,
                                   weak_factory_.GetWeakPtr(), accept_result));
 }
 
 void SimpleHttpServer::OnAccepted(int result) {
-  CHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   ASSERT_EQ(result, 0);  // Fails if the socket is already in use.
   new Connection(client_socket_.release(), factory_);
   OnConnect();
 }
 
 class AdbParser : public SimpleHttpServer::Parser,
-                  public base::NonThreadSafe,
                   public MockAndroidConnection::Delegate {
  public:
   static Parser* Create(FlushMode flush_mode,
                         const SimpleHttpServer::SendCallback& callback) {
     return new AdbParser(flush_mode, callback);
   }
 
-  ~AdbParser() override {}
+  ~AdbParser() override { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); }
+
  private:
   explicit AdbParser(FlushMode flush_mode,
                      const SimpleHttpServer::SendCallback& callback)
       : flush_mode_(flush_mode),
         callback_(callback) {
   }
 
   int Consume(const char* data, int size) override {
-    CHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     if (mock_connection_) {
       mock_connection_->Receive(std::string(data, size));
       return size;
     }
     if (size >= kAdbMessageHeaderSize) {
       std::string message_header(data, kAdbMessageHeaderSize);
       int message_size;
 
       EXPECT_TRUE(base::HexStringToInt(message_header, &message_size));
 
       if (size >= message_size + kAdbMessageHeaderSize) {
         std::string message_body(data + kAdbMessageHeaderSize, message_size);
         ProcessCommand(message_body);
         return kAdbMessageHeaderSize + message_size;
       }
     }
     return 0;
   }
 
   void ProcessCommand(const std::string& command) {
-    CHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     if (command == "host:devices") {
       SendSuccess(base::StringPrintf("%s\tdevice\n%s\toffline",
                                      kSerialOnline,
                                      kSerialOffline));
     } else if (base::StartsWith(command, kHostTransportPrefix,
                                 base::CompareCase::SENSITIVE)) {
       serial_ = command.substr(sizeof(kHostTransportPrefix) - 1);
       SendSuccess(std::string());
     } else if (serial_ != kSerialOnline) {
       Send("FAIL", "device offline (x)");
     } else {
       mock_connection_ =
           base::MakeUnique<MockAndroidConnection>(this, serial_, command);
     }
   }
 
   void SendSuccess(const std::string& response) override {
     Send("OKAY", response);
   }
 
   void SendRaw(const std::string& data) override {
     callback_.Run(data);
   }
 
   void Send(const std::string& status, const std::string& response) {
-    CHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     CHECK_EQ(4U, status.size());
     std::string buffer = status;
     if (flush_mode_ == FlushWithoutSize) {
         callback_.Run(buffer);
         buffer = std::string();
     }
 
     int size = response.size();
     if (size > 0) {
       static const char kHexChars[] = "0123456789ABCDEF";
       for (int i = 3; i >= 0; i--)
         buffer += kHexChars[ (size >> 4*i) & 0x0f ];
       if (flush_mode_ == FlushWithSize) {
           callback_.Run(buffer);
           buffer = std::string();
       }
       buffer += response;
       callback_.Run(buffer);
     } else if (flush_mode_ != FlushWithoutSize) {
       callback_.Run(buffer);
     }
   }
 
   FlushMode flush_mode_;
   SimpleHttpServer::SendCallback callback_;
   std::string serial_;
   std::unique_ptr<MockAndroidConnection> mock_connection_;
+
+  SEQUENCE_CHECKER(sequence_checker_);
 };
 
 static SimpleHttpServer* mock_adb_server_ = NULL;
 
 void StartMockAdbServerOnIOThread(FlushMode flush_mode) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   CHECK(mock_adb_server_ == NULL);
   net::IPEndPoint endpoint(net::IPAddress(127, 0, 0, 1), kAdbPort);
   mock_adb_server_ = new SimpleHttpServer(
       base::Bind(&AdbParser::Create, flush_mode), endpoint);
@@ skipping 125 matching lines @@
       base::MessageLoop::QuitWhenIdleClosure());
   content::RunMessageLoop();
 }
 
 void StopMockAdbServer() {
   BrowserThread::PostTaskAndReply(BrowserThread::IO, FROM_HERE,
                                   base::BindOnce(&StopMockAdbServerOnIOThread),
                                   base::MessageLoop::QuitWhenIdleClosure());
   content::RunMessageLoop();
 }
-