Deprecate NonThreadSafe in remoting in favor of SequenceChecker.

remoting/protocol/ice_connection_to_host.cc

 // Copyright 2015 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/ice_connection_to_host.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 10 matching lines @@
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/errors.h"
 #include "remoting/protocol/ice_transport.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/video_renderer.h"
 
 namespace remoting {
 namespace protocol {
 
 IceConnectionToHost::IceConnectionToHost() {}
-IceConnectionToHost::~IceConnectionToHost() {}
+IceConnectionToHost::~IceConnectionToHost() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
 
 void IceConnectionToHost::Connect(
     std::unique_ptr<Session> session,
     scoped_refptr<TransportContext> transport_context,
     HostEventCallback* event_callback) {
   DCHECK(client_stub_);
   DCHECK(clipboard_stub_);
   DCHECK(video_renderer_);
 
   transport_.reset(new IceTransport(transport_context, this));
@@ skipping 39 matching lines @@
 }
 
 void IceConnectionToHost::InitializeAudio(
     scoped_refptr<base::SingleThreadTaskRunner> audio_decode_task_runner,
     base::WeakPtr<AudioStub> audio_stub) {
   audio_decode_scheduler_.reset(
       new AudioDecodeScheduler(audio_decode_task_runner, audio_stub));
 }
 
 void IceConnectionToHost::OnSessionStateChange(Session::State state) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(event_callback_);
 
   switch (state) {
     case Session::INITIALIZING:
     case Session::CONNECTING:
     case Session::ACCEPTING:
     case Session::ACCEPTED:
     case Session::AUTHENTICATING:
       // Don't care about these events.
       break;
@@ skipping 107 matching lines @@
 void IceConnectionToHost::CloseChannels() {
   control_dispatcher_.reset();
   event_dispatcher_.reset();
   clipboard_forwarder_.set_clipboard_stub(nullptr);
   event_forwarder_.set_input_stub(nullptr);
   video_dispatcher_.reset();
   audio_reader_.reset();
 }
 
 void IceConnectionToHost::SetState(State state, ErrorCode error) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // |error| should be specified only when |state| is set to FAILED.
   DCHECK(state == FAILED || error == OK);
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting