Deprecate NonThreadSafe in remoting in favor of SequenceChecker.

remoting/host/client_session.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/client_session.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 64 matching lines @@
   extension_manager_.reset(new HostExtensionSessionManager(extensions, this));
 
 #if defined(OS_WIN)
   // LocalInputMonitorWin filters out an echo of the injected input before it
   // reaches |remote_input_filter_|.
   remote_input_filter_.SetExpectLocalEcho(false);
 #endif  // defined(OS_WIN)
 }
 
 ClientSession::~ClientSession() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!audio_stream_);
   DCHECK(!desktop_environment_);
   DCHECK(!input_injector_);
   DCHECK(!screen_controls_);
   DCHECK(!video_stream_);
 
   connection_.reset();
 }
 
 void ClientSession::NotifyClientResolution(
     const protocol::ClientResolution& resolution) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(resolution.dips_width() > 0 && resolution.dips_height() > 0);
 
   VLOG(1) << "Received ClientResolution (dips_width="
           << resolution.dips_width() << ", dips_height="
           << resolution.dips_height() << ")";
 
   if (!screen_controls_)
     return;
 
   webrtc::DesktopSize client_size(resolution.dips_width(),
                                   resolution.dips_height());
   if (connection_->session()->config().protocol() ==
       protocol::SessionConfig::Protocol::WEBRTC) {
     // When using WebRTC round down the dimensions to multiple of 2. Otherwise
     // the dimensions will be rounded on the receiver, which will cause blurring
     // due to scaling. The resulting size is still close to the client size and
     // will fit on the client's screen without scaling.
     // TODO(sergeyu): Make WebRTC handle odd dimensions properly.
     // crbug.com/636071
     client_size.set(client_size.width() & (~1), client_size.height() & (~1));
   }
 
   // Try to match the client's resolution.
   // TODO(sergeyu): Pass clients DPI to the resizer.
   screen_controls_->SetScreenResolution(ScreenResolution(
       client_size, webrtc::DesktopVector(kDefaultDpi, kDefaultDpi)));
 }
 
 void ClientSession::ControlVideo(const protocol::VideoControl& video_control) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Note that |video_stream_| may be null, depending upon whether
   // extensions choose to wrap or "steal" the video capturer or encoder.
   if (video_control.has_enable()) {
     VLOG(1) << "Received VideoControl (enable="
             << video_control.enable() << ")";
     pause_video_ = !video_control.enable();
     if (video_stream_)
       video_stream_->Pause(pause_video_);
   }
   if (video_control.has_lossless_encode()) {
     VLOG(1) << "Received VideoControl (lossless_encode="
             << video_control.lossless_encode() << ")";
     lossless_video_encode_ = video_control.lossless_encode();
     if (video_stream_)
       video_stream_->SetLosslessEncode(lossless_video_encode_);
   }
   if (video_control.has_lossless_color()) {
     VLOG(1) << "Received VideoControl (lossless_color="
             << video_control.lossless_color() << ")";
     lossless_video_color_ = video_control.lossless_color();
     if (video_stream_)
       video_stream_->SetLosslessColor(lossless_video_color_);
   }
 }
 
 void ClientSession::ControlAudio(const protocol::AudioControl& audio_control) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (audio_control.has_enable()) {
     VLOG(1) << "Received AudioControl (enable="
             << audio_control.enable() << ")";
     if (audio_stream_)
       audio_stream_->Pause(!audio_control.enable());
   }
 }
 
 void ClientSession::SetCapabilities(
     const protocol::Capabilities& capabilities) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Ignore all the messages but the 1st one.
   if (client_capabilities_) {
     LOG(WARNING) << "protocol::Capabilities has been received already.";
     return;
   }
 
   // Compute the set of capabilities supported by both client and host.
   client_capabilities_ = base::MakeUnique<std::string>();
   if (capabilities.has_capabilities())
@@ skipping 38 matching lines @@
                  << message.type() << ": " << message.data();
     }
   }
 }
 
 void ClientSession::OnConnectionAuthenticating() {
   event_handler_->OnSessionAuthenticating(this);
 }
 
 void ClientSession::OnConnectionAuthenticated() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!audio_stream_);
   DCHECK(!desktop_environment_);
   DCHECK(!input_injector_);
   DCHECK(!screen_controls_);
   DCHECK(!video_stream_);
 
   is_authenticated_ = true;
 
   if (max_duration_ > base::TimeDelta()) {
     max_duration_timer_.Start(
@@ skipping 36 matching lines @@
   connection_->set_input_stub(&disable_input_filter_);
   host_input_filter_.set_input_stub(input_injector_.get());
 
   // Connect the clipboard stubs.
   connection_->set_clipboard_stub(&disable_clipboard_filter_);
   clipboard_echo_filter_.set_host_stub(input_injector_.get());
   clipboard_echo_filter_.set_client_stub(connection_->client_stub());
 }
 
 void ClientSession::CreateMediaStreams() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Create a VideoStream to pump frames from the capturer to the client.
   video_stream_ = connection_->StartVideoStream(
       desktop_environment_->CreateVideoCapturer());
 
   // Create a AudioStream to pump audio from the capturer to the client.
   std::unique_ptr<protocol::AudioSource> audio_capturer =
       desktop_environment_->CreateAudioCapturer();
   if (audio_capturer) {
     audio_stream_ = connection_->StartAudioStream(std::move(audio_capturer));
   }
 
   video_stream_->SetObserver(this);
 
   // Apply video-control parameters to the new stream.
   video_stream_->SetLosslessEncode(lossless_video_encode_);
   video_stream_->SetLosslessColor(lossless_video_color_);
 
   // Pause capturing if necessary.
   video_stream_->Pause(pause_video_);
 
   if (event_timestamp_source_for_tests_)
     video_stream_->SetEventTimestampsSource(event_timestamp_source_for_tests_);
 }
 
 void ClientSession::OnConnectionChannelsConnected() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   DCHECK(!channels_connected_);
   channels_connected_ = true;
 
   // Negotiate capabilities with the client.
   VLOG(1) << "Host capabilities: " << host_capabilities_;
   protocol::Capabilities capabilities;
   capabilities.set_capabilities(host_capabilities_);
   connection_->client_stub()->SetCapabilities(capabilities);
 
   // Start the event executor.
   input_injector_->Start(CreateClipboardProxy());
   SetDisableInputs(false);
 
   // Create MouseShapePump to send mouse cursor shape.
   mouse_shape_pump_.reset(
       new MouseShapePump(desktop_environment_->CreateMouseCursorMonitor(),
                          connection_->client_stub()));
 
   if (pending_video_layout_message_) {
     connection_->client_stub()->SetVideoLayout(*pending_video_layout_message_);
     pending_video_layout_message_.reset();
   }
 
   // Notify the event handler that all our channels are now connected.
   event_handler_->OnSessionChannelsConnected(this);
 }
 
 void ClientSession::OnConnectionClosed(protocol::ErrorCode error) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   HOST_LOG << "Client disconnected: " << client_jid_ << "; error = " << error;
 
   // Ignore any further callbacks.
   weak_factory_.InvalidateWeakPtrs();
 
   // If the client never authenticated then the session failed.
   if (!is_authenticated_)
     event_handler_->OnSessionAuthenticationFailed(this);
 
@@ skipping 10 matching lines @@
   screen_controls_.reset();
   desktop_environment_.reset();
 
   // Notify the ChromotingHost that this client is disconnected.
   event_handler_->OnSessionClosed(this);
 }
 
 void ClientSession::OnRouteChange(
     const std::string& channel_name,
     const protocol::TransportRoute& route) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   event_handler_->OnSessionRouteChange(this, channel_name, route);
 }
 
 const std::string& ClientSession::client_jid() const {
   return client_jid_;
 }
 
 void ClientSession::DisconnectSession(protocol::ErrorCode error) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(connection_.get());
 
   max_duration_timer_.Stop();
 
   // This triggers OnConnectionClosed(), and the session may be destroyed
   // as the result, so this call must be the last in this method.
   connection_->Disconnect(error);
 }
 
 void ClientSession::OnLocalMouseMoved(const webrtc::DesktopVector& position) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   remote_input_filter_.LocalMouseMoved(position);
 }
 
 void ClientSession::SetDisableInputs(bool disable_inputs) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (disable_inputs)
     input_tracker_.ReleaseAll();
 
   disable_input_filter_.set_enabled(!disable_inputs);
   disable_clipboard_filter_.set_enabled(!disable_inputs);
 }
 
 uint32_t ClientSession::desktop_session_id() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(desktop_environment_);
   return desktop_environment_->GetDesktopSessionId();
 }
 
 ClientSessionControl* ClientSession::session_control() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return this;
 }
 
 void ClientSession::SetEventTimestampsSourceForTests(
     scoped_refptr<protocol::InputEventTimestampsSource>
         event_timestamp_source) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   event_timestamp_source_for_tests_ = event_timestamp_source;
   if (video_stream_)
     video_stream_->SetEventTimestampsSource(event_timestamp_source_for_tests_);
 }
 
 std::unique_ptr<protocol::ClipboardStub> ClientSession::CreateClipboardProxy() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return base::MakeUnique<protocol::ClipboardThreadProxy>(
       client_clipboard_factory_.GetWeakPtr(),
       base::ThreadTaskRunnerHandle::Get());
 }
 
 void ClientSession::OnVideoSizeChanged(protocol::VideoStream* video_stream,
                                        const webrtc::DesktopSize& size,
                                        const webrtc::DesktopVector& dpi) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   mouse_clamping_filter_.set_output_size(size);
 
   switch (connection_->session()->config().protocol()) {
     case protocol::SessionConfig::Protocol::ICE:
       mouse_clamping_filter_.set_input_size(size);
       break;
 
     case protocol::SessionConfig::Protocol::WEBRTC: {
       // When using WebRTC protocol the client sends mouse coordinates in DIPs,
@@ skipping 20 matching lines @@
         connection_->client_stub()->SetVideoLayout(layout);
       } else {
         pending_video_layout_message_.reset(new protocol::VideoLayout(layout));
       }
       break;
     }
   }
 }
 
 }  // namespace remoting