Set the initial resolution of an RDP session to the client screen resolution if it is available.

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 "base/message_loop_proxy.h"
 #include "media/video/capture/screen/screen_capturer.h"
+#include "remoting/base/capabilities.h"
 #include "remoting/codec/audio_encoder.h"
 #include "remoting/codec/audio_encoder_opus.h"
 #include "remoting/codec/audio_encoder_speex.h"
 #include "remoting/codec/audio_encoder_verbatim.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/codec/video_encoder_verbatim.h"
 #include "remoting/codec/video_encoder_vp8.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/audio_scheduler.h"
 #include "remoting/host/desktop_environment.h"
@@ skipping 68 matching lines @@
   DCHECK(!desktop_environment_);
   DCHECK(!input_injector_);
   DCHECK(!screen_controls_);
   DCHECK(!video_scheduler_);
 
   connection_.reset();
 }
 
 void ClientSession::NotifyClientResolution(
     const protocol::ClientResolution& resolution) {
+  DCHECK(CalledOnValidThread());
+
   if (!resolution.has_dips_width() || !resolution.has_dips_height())
     return;
 
   VLOG(1) << "Received ClientResolution (dips_width="
           << resolution.dips_width() << ", dips_height="
           << resolution.dips_height() << ")";
 
   if (!screen_controls_)
     return;
 
   ScreenResolution client_resolution(
       SkISize::Make(resolution.dips_width(), resolution.dips_height()),
       SkIPoint::Make(kDefaultDPI, kDefaultDPI));
 
   // Try to match the client's resolution.
   if (client_resolution.IsValid())
     screen_controls_->SetScreenResolution(client_resolution);
 }
 
 void ClientSession::ControlVideo(const protocol::VideoControl& video_control) {
+  DCHECK(CalledOnValidThread());
+
   if (video_control.has_enable()) {
     VLOG(1) << "Received VideoControl (enable="
             << video_control.enable() << ")";
     if (video_scheduler_)
       video_scheduler_->Pause(!video_control.enable());
   }
 }
 
 void ClientSession::ControlAudio(const protocol::AudioControl& audio_control) {
+  DCHECK(CalledOnValidThread());
+
   if (audio_control.has_enable()) {
     VLOG(1) << "Received AudioControl (enable="
             << audio_control.enable() << ")";
     if (audio_scheduler_)
       audio_scheduler_->Pause(!audio_control.enable());
   }
 }
 
+void ClientSession::SetCapabilities(
+    const protocol::Capabilities& capabilities) {
+  DCHECK(CalledOnValidThread());
+
+  // The client should not send protocol::Capabilities if it is not supported by
+  // the config channel.
+  if (!connection_->session()->config().SupportsCapabilities()) {
+    LOG(ERROR) << "Unexpected protocol::Capabilities has been received.";
+    return;
+  }
+
+  // Ignore all the messages but the 1st one.
+  if (client_capabilities_) {
+    LOG(WARNING) << "protocol::Capabilities has been received already.";
+    return;
+  }
+
+  client_capabilities_ = make_scoped_ptr(new std::string());
+  if (capabilities.has_capabilities())
+    *client_capabilities_ = capabilities.capabilities();
+
+  VLOG(1) << "Client capabilities: " << *client_capabilities_;
+
+  // Calculate the set of capabilities enabled by both client and host and
+  // pass it to the desktop environment if it is available.
+  if (desktop_environment_) {
+    desktop_environment_->SetCapabilities(
+        IntersectCapabilities(*client_capabilities_, host_capabilities_));
+  }
+}
+
 void ClientSession::OnConnectionAuthenticated(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
+  DCHECK(!desktop_environment_);
 
   auth_input_filter_.set_enabled(true);
   auth_clipboard_filter_.set_enabled(true);
 
   clipboard_echo_filter_.set_client_stub(connection_->client_stub());
   mouse_clamping_filter_.set_video_stub(connection_->video_stub());
 
   if (max_duration_ > base::TimeDelta()) {
     // TODO(simonmorris): Let Disconnect() tell the client that the
     // disconnection was caused by the session exceeding its maximum duration.
     max_duration_timer_.Start(FROM_HERE, max_duration_,
                               this, &ClientSession::DisconnectSession);
   }
 
+  // The session may be destroyed as the result result of this call, so it must
+  // be the last in this method.
   event_handler_->OnSessionAuthenticated(this);
 }
 
 void ClientSession::OnConnectionChannelsConnected(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
   DCHECK(!audio_scheduler_);
-  DCHECK(!desktop_environment_);
   DCHECK(!input_injector_);
   DCHECK(!screen_controls_);
   DCHECK(!video_scheduler_);
 
+  // Create the desktop environment.
   desktop_environment_ =
       desktop_environment_factory_->Create(control_factory_.GetWeakPtr());
+  host_capabilities_ = desktop_environment_->GetCapabilities();
+
+  // Negotiate capabilities with the client.
+  if (connection_->session()->config().SupportsCapabilities()) {
+    VLOG(1) << "Host capabilities: " << host_capabilities_;
+
+    protocol::Capabilities capabilities;
+    capabilities.set_capabilities(host_capabilities_);
+    connection_->client_stub()->SetCapabilities(capabilities);
+
+    // |client_capabilities_| could have been received before all channels were
+    // connected. Process them now.
+    if (client_capabilities_) {
+      desktop_environment_->SetCapabilities(
+          IntersectCapabilities(*client_capabilities_, host_capabilities_));
+    }
+  } else {
+    VLOG(1) << "The client does not support any capabilities.";
+
+    client_capabilities_ = make_scoped_ptr(new std::string());
+    desktop_environment_->SetCapabilities(*client_capabilities_);
+  }
 
   // Create the object that controls the screen resolution.
   screen_controls_ = desktop_environment_->CreateScreenControls();
 
   // Create and start the event executor.
   input_injector_ = desktop_environment_->CreateInputInjector();
   input_injector_->Start(CreateClipboardProxy());
 
   // Connect the host clipboard and input stubs.
   host_input_filter_.set_input_stub(input_injector_.get());
@@ skipping 160 matching lines @@
     return scoped_ptr<AudioEncoder>(new AudioEncoderSpeex());
   } else if (audio_config.codec == protocol::ChannelConfig::CODEC_OPUS) {
     return scoped_ptr<AudioEncoder>(new AudioEncoderOpus());
   }
 
   NOTIMPLEMENTED();
   return scoped_ptr<AudioEncoder>(NULL);
 }
 
 }  // namespace remoting