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"
@@ skipping 78 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());
+
+  // Ignore all the messages but the 1st one.
+  if (client_capabilities_) {
+    LOG(WARNING) << "protocol::Capabilities has been received already.";
+    return;
+  }
+
+  // Calculate the set of capabilities enabled by both client and host and pass
+  // it to the desktop environment.
+  client_capabilities_ = make_scoped_ptr(new Capabilities());
+  if (client_capabilities_->FromProtocolMessage(capabilities)) {
+    VLOG(1) << "Client capabilities: " << client_capabilities_->ToString();

[Sergey Ulanov, 2013/04/16 08:38:53]

nit: this will convert the capabilities to string that will almost never will be
useful. maybe better remove that VLOG 

[alexeypa (please no reviews), 2013/04/16 22:06:11]

It is actually useful. I used it when I tested various combinations of the
client and host. It makes it possible to figure out  what exactly was negotiated
and why.

+  } else {
+    LOG(ERROR) << "Invalid protocol::Capabilities received.";
+  }
+
+  if (desktop_environment_) {

[Sergey Ulanov, 2013/04/16 08:38:53]

It sucks that we need to worry about the case when
OnConnectionChannelsConnected() is called after this method. Is there any way we
can avoid it?  is it possible to move desktop environment creation to
OnConnectionAuthenticated()?

[alexeypa (please no reviews), 2013/04/16 22:06:11]

Done.

[Sergey Ulanov, 2013/04/18 00:34:53]

I don't see it in the last patchset.

[alexeypa (please no reviews), 2013/04/18 18:56:36]

It turned out that |event_handler_->OnSessionAuthenticated(this);| must be the
last line in ClientSession::OnConnectionAuthenticated() because it can delete
the client session. At the same time the desktop environment should be created
after |event_handler_->OnSessionAuthenticated(this)| has been called. So I moved
created on the desktop environment back to
ClientSession::OnConnectionChannelsConnected().

This issue affects not only SetCapabilities but other control messages. I'm
going to address it properly in a separate CL.

+    desktop_environment_->SetCapabilities(
+        client_capabilities_->Intersect(host_capabilities_));
+  }
+}
+
 void ClientSession::OnConnectionAuthenticated(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
 
   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());
@@ skipping 14 matching lines @@
   DCHECK_EQ(connection_.get(), connection);
   DCHECK(!audio_scheduler_);
   DCHECK(!desktop_environment_);
   DCHECK(!input_injector_);
   DCHECK(!screen_controls_);
   DCHECK(!video_scheduler_);
 
   desktop_environment_ =
       desktop_environment_factory_->Create(control_factory_.GetWeakPtr());
 
+  // Negotiate capabilities with the client.
+  if (connection_->session()->config().supports_capabilities()) {
+    host_capabilities_ = desktop_environment_->GetCapabilities();
+    VLOG(1) << "Host capabilities: " << host_capabilities_.ToString();
+
+    connection_->client_stub()->SetCapabilities(
+        *host_capabilities_.ToProtocolMessage());
+
+    // |client_capabilities_| could have been received before all channels were
+    // connected. Process them now.
+    if (client_capabilities_) {
+      desktop_environment_->SetCapabilities(
+          client_capabilities_->Intersect(host_capabilities_));
+    }
+  } else {
+    VLOG(1) << "The client does not support any capabilities.";
+
+    client_capabilities_ = make_scoped_ptr(new Capabilities());
+    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());
   clipboard_echo_filter_.set_host_stub(input_injector_.get());
@@ skipping 159 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