Deprecate NonThreadSafe in remoting in favor of SequenceChecker.

remoting/protocol/ssl_hmac_channel_authenticator.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/ssl_hmac_channel_authenticator.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 205 matching lines @@
   result->local_key_pair_ = key_pair;
   return result;
 }
 
 SslHmacChannelAuthenticator::SslHmacChannelAuthenticator(
     const std::string& auth_key)
     : auth_key_(auth_key) {
 }
 
 SslHmacChannelAuthenticator::~SslHmacChannelAuthenticator() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 void SslHmacChannelAuthenticator::SecureAndAuthenticate(
     std::unique_ptr<P2PStreamSocket> socket,
     const DoneCallback& done_callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   done_callback_ = done_callback;
 
   int result;
   if (is_ssl_server()) {
 #if defined(OS_NACL)
     // Client plugin doesn't use server SSL sockets, and so SSLServerSocket
     // implementation is not compiled for NaCl as part of net_nacl.
     NOTREACHED();
     result = net::ERR_FAILED;
@@ skipping 128 matching lines @@
         base::Bind(&SslHmacChannelAuthenticator::OnAuthBytesWritten,
                    base::Unretained(this)));
     if (result == net::ERR_IO_PENDING)
       break;
     if (!HandleAuthBytesWritten(result, callback_called))
       break;
   }
 }
 
 void SslHmacChannelAuthenticator::OnAuthBytesWritten(int result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (HandleAuthBytesWritten(result, nullptr))
     WriteAuthenticationBytes(nullptr);
 }
 
 bool SslHmacChannelAuthenticator::HandleAuthBytesWritten(
     int result, bool* callback_called) {
   if (result <= 0) {
     LOG(ERROR) << "Error writing authentication: " << result;
     if (callback_called)
@@ skipping 19 matching lines @@
                       base::Bind(&SslHmacChannelAuthenticator::OnAuthBytesRead,
                                  base::Unretained(this)));
     if (result == net::ERR_IO_PENDING)
       break;
     if (!HandleAuthBytesRead(result))
       break;
   }
 }
 
 void SslHmacChannelAuthenticator::OnAuthBytesRead(int result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (HandleAuthBytesRead(result))
     ReadAuthenticationBytes();
 }
 
 bool SslHmacChannelAuthenticator::HandleAuthBytesRead(int read_result) {
   if (read_result <= 0) {
     NotifyError(read_result);
     return false;
   }
@@ skipping 41 matching lines @@
                           std::move(socket_), std::move(server_context_)));
   }
 }
 
 void SslHmacChannelAuthenticator::NotifyError(int error) {
   base::ResetAndReturn(&done_callback_).Run(error, nullptr);
 }
 
 }  // namespace protocol
 }  // namespace remoting