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

remoting/host/host_plugin.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 <stdio.h>
 #include <string.h>
 
 #include <string>
 #include <vector>
 
@@ skipping 113 matching lines @@
 }
 
 // Convert an NPVariant into an NSPObject.
 NPObject* ObjectFromNPVariant(const NPVariant& variant) {
   if (!NPVARIANT_IS_OBJECT(variant))
     return NULL;
   return NPVARIANT_TO_OBJECT(variant);
 }
 
 // NPAPI plugin implementation for remoting host script object.
-class HostNPScriptObject {
+class HostNPScriptObject : remoting::HostStatusObserver {
  public:
   HostNPScriptObject(NPP plugin, NPObject* parent)
       : plugin_(plugin),
         parent_(parent),
         state_(kDisconnected),
         on_state_changed_func_(NULL),
         np_thread_id_(base::PlatformThread::CurrentId()) {
     LOG(INFO) << "HostNPScriptObject";
   }
 
@@ skipping 200 matching lines @@
   // Disconnect. No arguments or result.
   bool Disconnect(const NPVariant* args, uint32_t argCount, NPVariant* result);
 
   // Call OnStateChanged handler if there is one.
   void OnStateChanged(State state);
 
   // Callbacks invoked during session setup.
   void OnReceivedSupportID(remoting::SupportAccessVerifier* access_verifier,
                            bool success,
                            const std::string& support_id);
-  void OnConnected();
   void OnHostShutdown();
 
+  // HostStatusObserver interface.
+  virtual void OnSignallingConnected(remoting::SignalStrategy* signal_strategy,
+                                     const std::string& full_jid) {}
+  virtual void OnSignallingDisconnected() {}
+  virtual void OnAuthenticatedClientsChanged(int clients_connected);
+  virtual void OnShutdown() {}
+
   // Call a JavaScript function wrapped as an NPObject.
   // If result is non-null, the result of the call will be stored in it.
   // Caller is responsible for releasing result if they ask for it.
   static bool CallJSFunction(NPObject* func,
                              const NPVariant* args,
                              uint32_t argCount,
                              NPVariant* result);
 
   // Posts a task on the main NP thread.
   void PostTaskToNPThread(Task* task);
@@ skipping 79 matching lines @@
                      access_verifier.get()))) {
     SetException("connect: RegisterSupportHostRequest::Init failed");
     return false;
   }
 
   // Create the Host.
   scoped_refptr<remoting::ChromotingHost> host =
       remoting::ChromotingHost::Create(&host_context_, host_config,
                                        access_verifier.release());
   host->AddStatusObserver(register_request);
+  host->AddStatusObserver(this);
   host->set_me2mom(true);
 
   // Nothing went wrong, so lets save the host, config and request.
   host_ = host;
   host_config_ = host_config;
   register_request_ = register_request;
 
   // Start the Host.
   // TODO(wez): Attach to the Host for notifications of state changes.
   // It currently has no interface for that, though.
@@ skipping 39 matching lines @@
   access_verifier->OnMe2MomHostRegistered(success, support_id);
 
   // Combine the Support Id with the Host Id to make the Access Code.
   // TODO(wez): Locking, anyone?
   access_code_ = support_id + "-" + access_verifier->host_secret();
 
   // Let the caller know that life is good.
   OnStateChanged(kReceivedAccessCode);
 }
 
-void HostNPScriptObject::OnConnected() {
-  CHECK_NE(base::PlatformThread::CurrentId(), np_thread_id_);
-  OnStateChanged(kConnected);
-}
-
 void HostNPScriptObject::OnHostShutdown() {
   CHECK_NE(base::PlatformThread::CurrentId(), np_thread_id_);
   OnStateChanged(kDisconnected);
 }
 
+void HostNPScriptObject::OnAuthenticatedClientsChanged(int clients_connected) {
+  CHECK_NE(base::PlatformThread::CurrentId(), np_thread_id_);
+  OnStateChanged(clients_connected ? kConnected : kDisconnected);
+}
+
 void HostNPScriptObject::OnStateChanged(State state) {
   if (base::PlatformThread::CurrentId() != np_thread_id_) {
     PostTaskToNPThread(NewRunnableMethod(this,
                                          &HostNPScriptObject::OnStateChanged,
                                          state));
     return;
   }
   state_ = state;
   if (on_state_changed_func_) {
     LOG(INFO) << "Calling state changed " << state;
@@ skipping 411 matching lines @@
 }
 
 EXPORT NPError API_CALL NP_GetValue(void* npp,
                                     NPPVariable variable,
                                     void* value) {
   return GetValue((NPP)npp, variable, value);
 }
 #endif
 
 }  // extern "C"