Deprecate NonThreadSafe in remoting in favor of SequenceChecker.

remoting/host/signaling_connector.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/signaling_connector.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 42 matching lines @@
       reconnect_attempts_(0) {
   DCHECK(!auth_failed_callback_.is_null());
   DCHECK(dns_blackhole_checker_.get());
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
   signal_strategy_->AddListener(this);
   ScheduleTryReconnect();
 }
 
 SignalingConnector::~SignalingConnector() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   signal_strategy_->RemoveListener(this);
   net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 void SignalingConnector::OnSignalStrategyStateChange(
     SignalStrategy::State state) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (state == SignalStrategy::CONNECTED) {
     HOST_LOG << "Signaling connected. New JID: "
              << signal_strategy_->GetLocalAddress().jid();
     reconnect_attempts_ = 0;
   } else if (state == SignalStrategy::DISCONNECTED) {
     HOST_LOG << "Signaling disconnected. error="
              << SignalStrategyErrorToString(signal_strategy_->GetError());
     reconnect_attempts_++;
 
     if (signal_strategy_->GetError() == SignalStrategy::AUTHENTICATION_FAILED)
       oauth_token_getter_->InvalidateCache();
 
     ScheduleTryReconnect();
   }
 }
 
 bool SignalingConnector::OnSignalStrategyIncomingStanza(
     const buzz::XmlElement* stanza) {
   return false;
 }
 
 void SignalingConnector::OnConnectionTypeChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (type != net::NetworkChangeNotifier::CONNECTION_NONE &&
       signal_strategy_->GetState() == SignalStrategy::DISCONNECTED) {
     HOST_LOG << "Network state changed to online.";
     ResetAndTryReconnect();
   }
 }
 
 void SignalingConnector::OnIPAddressChanged() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (signal_strategy_->GetState() == SignalStrategy::DISCONNECTED) {
     HOST_LOG << "IP address has changed.";
     ResetAndTryReconnect();
   }
 }
 
 void SignalingConnector::OnAccessToken(OAuthTokenGetter::Status status,
                                        const std::string& user_email,
                                        const std::string& access_token) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (status == OAuthTokenGetter::AUTH_ERROR) {
     auth_failed_callback_.Run();
     return;
   } else if (status == OAuthTokenGetter::NETWORK_ERROR) {
     OnNetworkError();
     return;
   }
 
   DCHECK_EQ(status, OAuthTokenGetter::SUCCESS);
   HOST_LOG << "Received user info.";
 
   signal_strategy_->SetAuthInfo(user_email, access_token);
 
   // Now that we've refreshed the token and verified that it's for the correct
   // user account, try to connect using the new token.
   DCHECK_EQ(signal_strategy_->GetState(), SignalStrategy::DISCONNECTED);
   signal_strategy_->Connect();
 }
 
 void SignalingConnector::OnNetworkError() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   reconnect_attempts_++;
   ScheduleTryReconnect();
 }
 
 void SignalingConnector::ScheduleTryReconnect() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (timer_.IsRunning() || net::NetworkChangeNotifier::IsOffline())
     return;
   int delay_s = std::min(1 << reconnect_attempts_,
                          kMaxReconnectDelaySeconds);
   timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(delay_s),
                this, &SignalingConnector::TryReconnect);
 }
 
 void SignalingConnector::ResetAndTryReconnect() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   signal_strategy_->Disconnect();
   reconnect_attempts_ = 0;
   timer_.Stop();
   ScheduleTryReconnect();
 }
 
 void SignalingConnector::TryReconnect() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(dns_blackhole_checker_.get());
 
   // This will check if this machine is allowed to access the chromoting
   // host talkgadget.
   dns_blackhole_checker_->CheckForDnsBlackhole(
       base::Bind(&SignalingConnector::OnDnsBlackholeCheckerDone,
                  base::Unretained(this)));
 }
 
 void SignalingConnector::OnDnsBlackholeCheckerDone(bool allow) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Unable to access the host talkgadget. Don't allow the connection, but
   // schedule a reconnect in case this is a transient problem rather than
   // an outright block.
   if (!allow) {
     reconnect_attempts_++;
     HOST_LOG << "Talkgadget check failed. Scheduling reconnect. Attempt "
               << reconnect_attempts_;
     ScheduleTryReconnect();
     return;
   }
 
   if (signal_strategy_->GetState() == SignalStrategy::DISCONNECTED) {
     HOST_LOG << "Attempting to connect signaling.";
     oauth_token_getter_->CallWithToken(
         base::Bind(&SignalingConnector::OnAccessToken, AsWeakPtr()));
   }
 }
 
 }  // namespace remoting