Deprecate NonThreadSafe in remoting in favor of SequenceChecker.

remoting/host/chromoting_host.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/host/chromoting_host.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 65 matching lines @@
       audio_task_runner_(audio_task_runner),
       video_encode_task_runner_(video_encode_task_runner),
       started_(false),
       login_backoff_(&kDefaultBackoffPolicy),
       desktop_environment_options_(options),
       weak_factory_(this) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 }
 
 ChromotingHost::~ChromotingHost() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Disconnect all of the clients.
   while (!clients_.empty()) {
     clients_.front()->DisconnectSession(protocol::OK);
   }
 
   // Destroy the session manager to make sure that |signal_strategy_| does not
   // have any listeners registered.
   session_manager_.reset();
 
   // Notify observers.
   if (started_) {
     for (auto& observer : status_observers_)
       observer.OnShutdown();
   }
 }
 
 void ChromotingHost::Start(const std::string& host_owner_email) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!started_);
 
   HOST_LOG << "Starting host";
   started_ = true;
   for (auto& observer : status_observers_)
     observer.OnStart(host_owner_email);
 
   session_manager_->AcceptIncoming(
       base::Bind(&ChromotingHost::OnIncomingSession, base::Unretained(this)));
 }
 
 void ChromotingHost::AddStatusObserver(HostStatusObserver* observer) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   status_observers_.AddObserver(observer);
 }
 
 void ChromotingHost::RemoveStatusObserver(HostStatusObserver* observer) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   status_observers_.RemoveObserver(observer);
 }
 
 void ChromotingHost::AddExtension(std::unique_ptr<HostExtension> extension) {
   extensions_.push_back(std::move(extension));
 }
 
 void ChromotingHost::SetAuthenticatorFactory(
     std::unique_ptr<protocol::AuthenticatorFactory> authenticator_factory) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   session_manager_->set_authenticator_factory(std::move(authenticator_factory));
 }
 
 void ChromotingHost::SetMaximumSessionDuration(
     const base::TimeDelta& max_session_duration) {
   max_session_duration_ = max_session_duration;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // protocol::ClientSession::EventHandler implementation.
 void ChromotingHost::OnSessionAuthenticating(ClientSession* client) {
   // We treat each incoming connection as a failure to authenticate,
   // and clear the backoff when a connection successfully
   // authenticates. This allows the backoff to protect from parallel
   // connection attempts as well as sequential ones.
   if (login_backoff_.ShouldRejectRequest()) {
     LOG(WARNING) << "Disconnecting client " << client->client_jid() << " due to"
                     " an overload of failed login attempts.";
     client->DisconnectSession(protocol::HOST_OVERLOAD);
     return;
   }
   login_backoff_.InformOfRequest(false);
 }
 
 void ChromotingHost::OnSessionAuthenticated(ClientSession* client) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   login_backoff_.Reset();
 
   // Disconnect all clients, except |client|.
   base::WeakPtr<ChromotingHost> self = weak_factory_.GetWeakPtr();
   while (clients_.size() > 1) {
     clients_[(clients_.front().get() == client) ? 1 : 0]->DisconnectSession(
         protocol::OK);
 
     // Quit if the host was destroyed.
     if (!self)
       return;
   }
 
   // Disconnects above must have destroyed all other clients.
   DCHECK_EQ(clients_.size(), 1U);
   DCHECK(clients_.front().get() == client);
 
   // Notify observers that there is at least one authenticated client.
   for (auto& observer : status_observers_)
     observer.OnClientAuthenticated(client->client_jid());
 }
 
 void ChromotingHost::OnSessionChannelsConnected(ClientSession* client) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Notify observers.
   for (auto& observer : status_observers_)
     observer.OnClientConnected(client->client_jid());
 }
 
 void ChromotingHost::OnSessionAuthenticationFailed(ClientSession* client) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Notify observers.
   for (auto& observer : status_observers_)
     observer.OnAccessDenied(client->client_jid());
 }
 
 void ChromotingHost::OnSessionClosed(ClientSession* client) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   ClientSessions::iterator it =
       std::find_if(clients_.begin(), clients_.end(),
                    [client](const std::unique_ptr<ClientSession>& item) {
                      return item.get() == client;
                    });
   CHECK(it != clients_.end());
 
   bool was_authenticated = client->is_authenticated();
   std::string jid = client->client_jid();
   clients_.erase(it);
 
   if (was_authenticated) {
     for (auto& observer : status_observers_)
       observer.OnClientDisconnected(jid);
   }
 }
 
 void ChromotingHost::OnSessionRouteChange(
     ClientSession* session,
     const std::string& channel_name,
     const protocol::TransportRoute& route) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   for (auto& observer : status_observers_)
     observer.OnClientRouteChange(session->client_jid(), channel_name, route);
 }
 
 void ChromotingHost::OnIncomingSession(
       protocol::Session* session,
       protocol::SessionManager::IncomingSessionResponse* response) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(started_);
 
   if (login_backoff_.ShouldRejectRequest()) {
     LOG(WARNING) << "Rejecting connection due to"
                     " an overload of failed login attempts.";
     *response = protocol::SessionManager::OVERLOAD;
     return;
   }
 
   *response = protocol::SessionManager::ACCEPT;
@@ skipping 18 matching lines @@
   std::vector<HostExtension*> extension_ptrs;
   for (const auto& extension : extensions_)
     extension_ptrs.push_back(extension.get());
   clients_.push_back(base::MakeUnique<ClientSession>(
       this, std::move(connection), desktop_environment_factory_,
       desktop_environment_options_, max_session_duration_, pairing_registry_,
       extension_ptrs));
 }
 
 }  // namespace remoting