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

remoting/client/chromoting_client.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/client/chromoting_client.h"
 
 #include "base/bind.h"
+#include "remoting/base/capabilities.h"
 #include "remoting/client/audio_decode_scheduler.h"
 #include "remoting/client/audio_player.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/client_user_interface.h"
 #include "remoting/client/rectangle_update_decoder.h"
 #include "remoting/proto/audio.pb.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/authentication_method.h"
 #include "remoting/protocol/connection_to_host.h"
+#include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/negotiating_client_authenticator.h"
 #include "remoting/protocol/session_config.h"
 #include "remoting/protocol/transport.h"
 
 namespace remoting {
 
 using protocol::AuthenticationMethod;
 
 ChromotingClient::ChromotingClient(
     const ClientConfig& config,
@@ skipping 54 matching lines @@
 
 void ChromotingClient::OnDisconnected(const base::Closure& shutdown_task) {
   shutdown_task.Run();
 }
 
 ChromotingStats* ChromotingClient::GetStats() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return rectangle_decoder_->GetStats();
 }
 
+void ChromotingClient::SetCapabilities(
+    const protocol::Capabilities& capabilities) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  // Only accept the first |protocol::Capabilities| message.
+  if (host_capabilities_) {
+    LOG(WARNING) << "protocol::Capabilities has been received already.";
+    return;
+  }
+
+  host_capabilities_ = make_scoped_ptr(new Capabilities());
+  if (host_capabilities_->FromProtocolMessage(capabilities)) {
+    VLOG(1) << "Host capabilities: " << host_capabilities_->ToString();
+  } else {
+    LOG(ERROR) << "Invalid protocol::Capabilities received.";
+  }
+
+  // Calculate the set of capabilities enabled by both client and host and pass
+  // it to the webapp.
+  user_interface_->SetCapabilities(
+      host_capabilities_->Intersect(config_.capabilities).ToString());
+}
+
 void ChromotingClient::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   DCHECK(task_runner_->BelongsToCurrentThread());
+
   user_interface_->GetClipboardStub()->InjectClipboardEvent(event);
 }
 
 void ChromotingClient::SetCursorShape(
     const protocol::CursorShapeInfo& cursor_shape) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
   user_interface_->GetCursorShapeStub()->SetCursorShape(cursor_shape);
 }
 
 void ChromotingClient::OnConnectionState(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   VLOG(1) << "ChromotingClient::OnConnectionState(" << state << ")";
   if (state == protocol::ConnectionToHost::CONNECTED)
     Initialize();
   user_interface_->OnConnectionState(state, error);
 }
 
 void ChromotingClient::OnConnectionReady(bool ready) {
   VLOG(1) << "ChromotingClient::OnConnectionReady(" << ready << ")";
   user_interface_->OnConnectionReady(ready);
 }
 
 void ChromotingClient::Initialize() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Initialize the decoder.
   rectangle_decoder_->Initialize(connection_->config());
   if (connection_->config().is_audio_enabled())
     audio_decode_scheduler_->Initialize(connection_->config());
+
+  // Negotiate capabilities with the host.
+  if (connection_->config().supports_capabilities()) {
+    VLOG(1) << "Client capabilities: " << config_.capabilities.ToString();
+    connection_->host_stub()->SetCapabilities(
+        *config_.capabilities.ToProtocolMessage());

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

Should we send intersection of capabilities supported by webapp and the client?

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

We do. |config_.capabilities| is a combination of capabilities supported by the
webapp and plugin. The plugin's capabilities are sent to the webapp in the
"hello" message. The webapp combines them with capabilities that it supports and
return the result to the plugin in the "connect" message.

+  } else {
+    VLOG(1) << "The host does not support any capabilities.";
+    host_capabilities_ = make_scoped_ptr(new Capabilities());
+    user_interface_->SetCapabilities(host_capabilities_->ToString());
+  }
 }
 
 }  // namespace remoting