Host extensions

remoting/host/chromoting_host.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/chromoting_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 123 matching lines @@
 void ChromotingHost::AddStatusObserver(HostStatusObserver* observer) {
   DCHECK(CalledOnValidThread());
   status_observers_.AddObserver(observer);
 }
 
 void ChromotingHost::RemoveStatusObserver(HostStatusObserver* observer) {
   DCHECK(CalledOnValidThread());
   status_observers_.RemoveObserver(observer);
 }
 
+void ChromotingHost::AddExtension(scoped_ptr<HostExtension> extension) {
+  extensions_.push_back(extension.release());
+}
+
 void ChromotingHost::RejectAuthenticatingClient() {
   DCHECK(authenticating_client_);
   reject_authenticating_client_ = true;
 }
 
 void ChromotingHost::SetAuthenticatorFactory(
     scoped_ptr<protocol::AuthenticatorFactory> authenticator_factory) {
   DCHECK(CalledOnValidThread());
   session_manager_->set_authenticator_factory(authenticator_factory.Pass());
 }
@@ skipping 48 matching lines @@
   ClientList::iterator it = clients_.begin();
   while (it != clients_.end()) {
     ClientSession* other_client = *it++;
     if (other_client != client)
       other_client->DisconnectSession();
   }
 
   // Disconnects above must have destroyed all other clients.
   DCHECK_EQ(clients_.size(), 1U);
 
+  // Registers capabilities provided by host extensions.
+  for (HostExtensionList::iterator extension = extensions_.begin();
+       extension != extensions_.end(); ++extension) {
+    client->AddHostCapabilities((*extension)->GetCapabilities());

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

Do you really need to do this here? Could it wait until OnClientCapabilities, so
that you can derive the capabilities list from the list of extensions that you
have actually added to the ClientSession?

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

If not then it would seem cleaner to have SetHostCapabilities(), and have the
host collate the list and pass it once, rather than having the ClientSession
accumulate the list.

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

We need to send the host capabilities to the client before it can reply with its
capabilities - so we need to compile the host capabilities before
OnClientCapabilities is called.

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

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

+  }
+
   // Notify observers that there is at least one authenticated client.
   const std::string& jid = client->client_jid();
 
   reject_authenticating_client_ = false;
 
   authenticating_client_ = true;
   FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
                     OnClientAuthenticated(jid));
   authenticating_client_ = false;
 
   return !reject_authenticating_client_;
 }
 
 void ChromotingHost::OnSessionChannelsConnected(ClientSession* client) {
   DCHECK(CalledOnValidThread());
 
   // Notify observers.
   FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
                     OnClientConnected(client->client_jid()));
 }
 
+void ChromotingHost::OnClientCapabilities(ClientSession* client) {
+  DCHECK(CalledOnValidThread());
+
+  // Create extension sessions from each registered extension for this client.
+  for (HostExtensionList::iterator extension = extensions_.begin();
+       extension != extensions_.end(); ++extension) {
+    scoped_ptr<HostExtensionSession> extension_session =
+        (*extension)->CreateExtensionSession(client);
+    if (extension_session)
+      client->AddExtensionSession(extension_session.Pass());
+  }
+}
+
 void ChromotingHost::OnSessionAuthenticationFailed(ClientSession* client) {
   DCHECK(CalledOnValidThread());
 
   // Notify observers.
   FOR_EACH_OBSERVER(HostStatusObserver, status_observers_,
                     OnAccessDenied(client->client_jid()));
 }
 
 void ChromotingHost::OnSessionClosed(ClientSession* client) {
   DCHECK(CalledOnValidThread());
@@ skipping 92 matching lines @@
   DCHECK(CalledOnValidThread());
 
   while (!clients_.empty()) {
     size_t size = clients_.size();
     clients_.front()->DisconnectSession();
     CHECK_EQ(clients_.size(), size - 1);
   }
 }
 
 }  // namespace remoting