Deprecate NonThreadSafe in remoting in favor of SequenceChecker.

remoting/host/host_status_logger.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 "remoting/host/host_status_logger.h"
 
 #include "base/bind.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/host_status_monitor.h"
 #include "remoting/host/server_log_entry_host.h"
 #include "remoting/protocol/transport.h"
 #include "remoting/signaling/server_log_entry.h"
 
 namespace remoting {
 
 HostStatusLogger::HostStatusLogger(base::WeakPtr<HostStatusMonitor> monitor,
                                    ServerLogEntry::Mode mode,
                                    SignalStrategy* signal_strategy,
                                    const std::string& directory_bot_jid)
     : log_to_server_(mode, signal_strategy, directory_bot_jid),
       monitor_(monitor) {
   monitor_->AddStatusObserver(this);
 }
 
 HostStatusLogger::~HostStatusLogger() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (monitor_.get())
     monitor_->RemoveStatusObserver(this);
 }
 
 void HostStatusLogger::LogSessionStateChange(const std::string& jid,
                                              bool connected) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   std::unique_ptr<ServerLogEntry> entry(
       MakeLogEntryForSessionStateChange(connected));
   AddHostFieldsToLogEntry(entry.get());
   entry->AddModeField(log_to_server_.mode());
 
   if (connected && connection_route_type_.count(jid) > 0)
     AddConnectionTypeToLogEntry(entry.get(), connection_route_type_[jid]);
 
   log_to_server_.Log(*entry.get());
 }
 
 void HostStatusLogger::OnClientConnected(const std::string& jid) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   LogSessionStateChange(jid, true);
 }
 
 void HostStatusLogger::OnClientDisconnected(const std::string& jid) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   LogSessionStateChange(jid, false);
   connection_route_type_.erase(jid);
 }
 
 void HostStatusLogger::OnClientRouteChange(
     const std::string& jid,
     const std::string& channel_name,
     const protocol::TransportRoute& route) {
   // Store connection type for the video channel. It is logged later
   // when client authentication is finished.
   if (channel_name == kVideoChannelName) {
     connection_route_type_[jid] = route.type;
   }
 }
 
 void HostStatusLogger::SetSignalingStateForTest(SignalStrategy::State state) {
   log_to_server_.OnSignalStrategyStateChange(state);
 }
 
 }  // namespace remoting