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/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"
@@ skipping 60 matching lines @@
   DCHECK(CalledOnValidThread());
   DCHECK(!audio_scheduler_.get());
   DCHECK(!desktop_environment_);
   DCHECK(!input_injector_);
   DCHECK(!screen_controls_);
   DCHECK(!video_scheduler_.get());
 
   connection_.reset();
 }
 
+void ClientSession::AddExtensionSession(
+    scoped_ptr<HostExtensionSession> extension_session) {
+  DCHECK(CalledOnValidThread());
+
+  extension_sessions_.push_back(extension_session.release());
+}
+
+void ClientSession::AddHostCapabilities(const std::string& capabilities) {
+  DCHECK(CalledOnValidThread());
+
+  if (capabilities.empty())
+    return;
+
+  if (!host_capabilities_.empty())
+    host_capabilities_.append(" ");

[Wez, 2014/05/28 23:03:41]

See comment in ChromotingHost re doing this accumulation of capabilities in the
ChromotingHost code and just SetHostCapabilities() here.

[dcaiafa, 2014/05/29 00:03:16]

As you mentioned in the comment's message, AddHostCapabilities is also used to
compile capabilities from DesktopEnvironment.

+
+  host_capabilities_.append(capabilities);
+}
+
 void ClientSession::NotifyClientResolution(
     const protocol::ClientResolution& resolution) {
   DCHECK(CalledOnValidThread());
 
   // TODO(sergeyu): Move these checks to protocol layer.
   if (!resolution.has_dips_width() || !resolution.has_dips_height() ||
       resolution.dips_width() < 0 || resolution.dips_height() < 0 ||
       resolution.width() <= 0 || resolution.height() <= 0) {
     LOG(ERROR) << "Received invalid ClientResolution message.";
     return;
@@ skipping 50 matching lines @@
   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_;
+  event_handler_->OnClientCapabilities(this);
 
   // 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()) {
@@ skipping 16 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(HostExtensionSessionList::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;
   }
 
-  host_capabilities_ = desktop_environment_->GetCapabilities();
+  AddHostCapabilities(desktop_environment_->GetCapabilities());
 
   // 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());
+    event_handler_->OnClientCapabilities(this);
+
     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 192 matching lines @@
     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>();
 }
 
 }  // namespace remoting