Notify calling web-app when Host plugin becomes connected to a client.

remoting/host/chromoting_host.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/callback.h"
 #include "build/build_config.h"
 #include "remoting/base/constants.h"
@@ skipping 260 matching lines @@
     protocol::Session* session,
     protocol::SessionManager::IncomingSessionResponse* response) {
   base::AutoLock auto_lock(lock_);
   if (state_ != kStarted) {
     *response = protocol::SessionManager::DECLINE;
     return;
   }
 
   // If we are running Me2Mom and already have an authenticated client then
   // reject the connection immediately.
-  if (is_it2me_ && HasAuthenticatedClients()) {
+  if (is_it2me_ && AuthenticatedClientsCount() > 0) {
     *response = protocol::SessionManager::DECLINE;
     return;
   }
 
   // Check that the client has access to the host.
   if (!access_verifier_->VerifyPermissions(session->jid(),
                                            session->initiator_token())) {
     *response = protocol::SessionManager::DECLINE;
 
     // Notify observers.
@@ skipping 101 matching lines @@
     if (client->get()->authenticated()) {
       recorder_->Stop(NULL);
       recorder_ = NULL;
     }
   }
 
   // Close the connection to connection just to be safe.
   connection->Disconnect();
 
   // Also remove reference to ConnectionToClient from this object.
+  int old_authenticated_clients = AuthenticatedClientsCount();
   clients_.erase(client);
 
-  if (!HasAuthenticatedClients()) {
+  // Notify the observers of the change, if any.
+  int authenticated_clients = AuthenticatedClientsCount();
+  if (old_authenticated_clients != authenticated_clients) {
+    for (StatusObserverList::iterator it = status_observers_.begin();
+         it != status_observers_.end(); ++it) {
+      (*it)->OnAuthenticatedClientsChanged(authenticated_clients);
+    }
+  }
+
+  // Enable the "curtain", if at least one client is actually authenticated.
+  if (AuthenticatedClientsCount() > 0) {
     EnableCurtainMode(false);
     if (is_it2me_) {
       MonitorLocalInputs(false);
       ShowDisconnectWindow(false, std::string());
       ShowContinueWindow(false);
       StartContinueWindowTimer(false);
     }
   }
 }
 
@@ skipping 15 matching lines @@
 
   return NULL;
 }
 
 std::string ChromotingHost::GenerateHostAuthToken(
     const std::string& encoded_client_token) {
   // TODO(ajwong): Return the signature of this instead.
   return encoded_client_token;
 }
 
-bool ChromotingHost::HasAuthenticatedClients() const {
+int ChromotingHost::AuthenticatedClientsCount() const {
+  int authenticated_clients = 0;
   for (ClientList::const_iterator it = clients_.begin(); it != clients_.end();
        ++it) {
     if (it->get()->authenticated())
-      return true;
+      ++authenticated_clients;
   }
-  return false;
+  return authenticated_clients;
 }
 
 void ChromotingHost::EnableCurtainMode(bool enable) {
   // TODO(jamiewalch): This will need to be more sophisticated when we think
   // about proper crash recovery and daemon mode.
   // TODO(wez): CurtainMode shouldn't be driven directly by ChromotingHost.
   if (is_it2me_ || enable == is_curtained_)
     return;
   desktop_environment_->curtain()->EnableCurtainMode(enable);
   is_curtained_ = enable;
@@ skipping 59 matching lines @@
   EnableCurtainMode(true);
   if (is_it2me_) {
     MonitorLocalInputs(true);
     std::string username = connection->session()->jid();
     size_t pos = username.find('/');
     if (pos != std::string::npos)
       username.replace(pos, std::string::npos, "");
     ShowDisconnectWindow(true, username);
     StartContinueWindowTimer(true);
   }
+
+  // Notify observers that there is at least one authenticated client.
+  for (StatusObserverList::iterator it = status_observers_.begin();
+       it != status_observers_.end(); ++it) {
+    (*it)->OnAuthenticatedClientsChanged(AuthenticatedClientsCount());
+  }
 }
 
 void ChromotingHost::LocalLoginFailed(
     scoped_refptr<ConnectionToClient> connection) {
   if (MessageLoop::current() != context_->main_message_loop()) {
     context_->main_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::LocalLoginFailed, this,
                               connection));
     return;
   }
@@ skipping 139 matching lines @@
 
   for (std::vector<Task*>::iterator it = shutdown_tasks_.begin();
        it != shutdown_tasks_.end(); ++it) {
     (*it)->Run();
     delete *it;
   }
   shutdown_tasks_.clear();
 }
 
 }  // namespace remoting