Host extensions

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/message_loop_proxy.h"
 #include "remoting/base/capabilities.h"
 #include "remoting/base/logging.h"
 #include "remoting/codec/audio_encoder.h"
 #include "remoting/codec/audio_encoder_opus.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_vpx.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/audio_scheduler.h"
 #include "remoting/host/desktop_environment.h"
+#include "remoting/host/extension_session.h"
 #include "remoting/host/input_injector.h"
 #include "remoting/host/screen_controls.h"
 #include "remoting/host/screen_resolution.h"
 #include "remoting/host/video_scheduler.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/clipboard_thread_proxy.h"
 #include "remoting/protocol/pairing_registry.h"
 #include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
 
 // Default DPI to assume for old clients that use notifyClientDimensions.
 const int kDefaultDPI = 96;
 
 namespace remoting {
 
 ClientSession::ClientSession(
     EventHandler* event_handler,
     scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     scoped_ptr<protocol::ConnectionToClient> connection,
     DesktopEnvironmentFactory* desktop_environment_factory,
     const base::TimeDelta& max_duration,
-    scoped_refptr<protocol::PairingRegistry> pairing_registry)
+    scoped_refptr<protocol::PairingRegistry> pairing_registry,
+    const ExtensionList* extensions)
     : event_handler_(event_handler),
       connection_(connection.Pass()),
       client_jid_(connection_->session()->jid()),
       control_factory_(this),
       desktop_environment_factory_(desktop_environment_factory),
       input_tracker_(&host_input_filter_),
       remote_input_filter_(&input_tracker_),
       mouse_clamping_filter_(&remote_input_filter_),
       disable_input_filter_(mouse_clamping_filter_.input_filter()),
       disable_clipboard_filter_(clipboard_echo_filter_.host_filter()),
       auth_input_filter_(&disable_input_filter_),
       auth_clipboard_filter_(&disable_clipboard_filter_),
       client_clipboard_factory_(clipboard_echo_filter_.client_filter()),
       max_duration_(max_duration),
       audio_task_runner_(audio_task_runner),
       input_task_runner_(input_task_runner),
       video_capture_task_runner_(video_capture_task_runner),
       video_encode_task_runner_(video_encode_task_runner),
       network_task_runner_(network_task_runner),
       ui_task_runner_(ui_task_runner),
-      pairing_registry_(pairing_registry) {
+      pairing_registry_(pairing_registry),
+      extensions_(extensions) {
   connection_->SetEventHandler(this);
 
   // TODO(sergeyu): Currently ConnectionToClient expects stubs to be
   // set before channels are connected. Make it possible to set stubs
   // later and set them only when connection is authenticated.
   connection_->set_clipboard_stub(&auth_clipboard_filter_);
   connection_->set_host_stub(this);
   connection_->set_input_stub(&auth_input_filter_);
 
   // |auth_*_filter_|'s states reflect whether the session is authenticated.
@@ skipping 82 matching lines @@
     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_;
 
+  CreateExtensionSessions();

[Wez, 2014/05/28 01:05:59]

Why are we doing this here *and* in OnConnectionAuthenticated?

[dcaiafa, 2014/05/28 22:44:58]

They are the two sites where client_capabilities_ are established and set in
desktop_environment_. In OnConnectionAuthenticated's case, the client doesn't
support capabilities.

+
   // Calculate the set of capabilities enabled by both client and host and
   // pass it to the desktop environment if it is available.
   desktop_environment_->SetCapabilities(
       IntersectCapabilities(*client_capabilities_, host_capabilities_));
 }
 
 void ClientSession::RequestPairing(
     const protocol::PairingRequest& pairing_request) {
   if (pairing_registry_ && pairing_request.has_client_name()) {
     protocol::PairingRegistry::Pairing pairing =
@@ skipping 15 matching lines @@
         reply.set_data(message.data().substr(0, 16));
       connection_->client_stub()->DeliverHostMessage(reply);
       return;
     } else if (message.type() == "gnubby-auth") {
       if (gnubby_auth_handler_) {
         gnubby_auth_handler_->DeliverClientMessage(message.data());
       } else {
         HOST_LOG << "gnubby auth is not enabled";
       }
       return;
+    } else {
+      for(ExtensionSessionList::iterator it = extension_sessions_.begin();
+          it != extension_sessions_.end(); ++it) {
+        // Extension returns |true| to indicate that the message was handled.
+        if ((*it)->OnExtensionMessage(this, message))
+          return;
+      }
     }
   }
   HOST_LOG << "Unexpected message received: "
             << message.type() << ": " << message.data();
 }
 
 void ClientSession::OnConnectionAuthenticating(
     protocol::ConnectionToClient* connection) {
   event_handler_->OnSessionAuthenticating(this);
 }
@@ skipping 29 matching lines @@
 
   // Create the desktop environment. Drop the connection if it could not be
   // created for any reason (for instance the curtain could not initialize).
   desktop_environment_ =
       desktop_environment_factory_->Create(control_factory_.GetWeakPtr());
   if (!desktop_environment_) {
     DisconnectSession();
     return;
   }
 
+  // Compile a list of capabilities from the desktop environment and the
+  // extensions. It is formatted as a space-separated list of words.
   host_capabilities_ = desktop_environment_->GetCapabilities();
+  for (ExtensionList::const_iterator extension = extensions_->begin();
+       extension != extensions_->end(); ++extension) {
+    std::string extension_capabilities = (*extension)->GetCapabilities();
+    if (!extension_capabilities.empty()) {
+      if (!host_capabilities_.empty())
+        host_capabilities_.append(" ");
+
+      host_capabilities_.append(extension_capabilities);
+    }
+  }
 
   // Ignore protocol::Capabilities messages from the client if it does not
   // support any capabilities.
   if (!connection_->session()->config().SupportsCapabilities()) {
     VLOG(1) << "The client does not support any capabilities.";
 
     client_capabilities_ = make_scoped_ptr(new std::string());
+    CreateExtensionSessions();

[Wez, 2014/05/28 01:05:59]

Could you have the ChromotingHost add the extension in OnSessionAuthenticated(),
which is called shortly before this?

That way you can avoid passing the list of Extensions to ClientSession;
ChromotingHost would call ClientSession::AddExtension() for each extension, and
then once OnSessionAuthenticated() returns the ClientSession can compile the
list of capabilities from the ExtensionSessions.

[dcaiafa, 2014/05/28 22:44:58]

Done.

+
     desktop_environment_->SetCapabilities(*client_capabilities_);
   }
 
   // Create the object that controls the screen resolution.
   screen_controls_ = desktop_environment_->CreateScreenControls();
 
   // Create the event executor.
   input_injector_ = desktop_environment_->CreateInputInjector();
 
   // Connect the host clipboard and input stubs.
@@ skipping 191 matching lines @@
   if (audio_config.codec == protocol::ChannelConfig::CODEC_VERBATIM) {
     return scoped_ptr<AudioEncoder>(new AudioEncoderVerbatim());
   } else if (audio_config.codec == protocol::ChannelConfig::CODEC_OPUS) {
     return scoped_ptr<AudioEncoder>(new AudioEncoderOpus());
   }
 
   NOTREACHED();
   return scoped_ptr<AudioEncoder>();
 }
 
+void ClientSession::CreateExtensionSessions() {
+  DCHECK(extension_sessions_.empty());
+
+  for (ExtensionList::const_iterator extension = extensions_->begin();
+       extension != extensions_->end(); ++extension) {
+    extension_sessions_.push_back(
+        (*extension)->CreateExtensionSession(this).release());
+  }
+}
+
 }  // namespace remoting