Propagate connected user to web app.

remoting/host/plugin/host_script_object.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/plugin/host_script_object.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/threading/platform_thread.h"
 #include "remoting/base/auth_token_util.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_key_pair.h"
 #include "remoting/host/in_memory_host_config.h"
 #include "remoting/host/plugin/host_plugin_utils.h"
 #include "remoting/host/register_support_host_request.h"
 #include "remoting/host/support_access_verifier.h"
 
 namespace remoting {
 
 // Supported Javascript interface:
 // readonly attribute string accessCode;
 // readonly attribute int accessCodeLifetime;
+// readonly attribute string client;
 // readonly attribute int state;
 //
 // state: {
 //     DISCONNECTED,
 //     REQUESTED_ACCESS_CODE,
 //     RECEIVED_ACCESS_CODE,
 //     CONNECTED,
 //     AFFIRMING_CONNECTION,
 //     ERROR,
 // }
 //
 // attribute Function void logDebugInfo(string);
 // attribute Function void onStateChanged();
 //
 // // The |auth_service_with_token| parameter should be in the format
 // // "auth_service:auth_token".  An example would be "oauth2:1/2a3912vd".
 // void connect(string uid, string auth_service_with_token);
 // void disconnect();
 
 namespace {
 
 const char* kAttrNameAccessCode = "accessCode";
 const char* kAttrNameAccessCodeLifetime = "accessCodeLifetime";
+const char* kAttrNameClient = "client";
 const char* kAttrNameState = "state";
 const char* kAttrNameLogDebugInfo = "logDebugInfo";
 const char* kAttrNameOnStateChanged = "onStateChanged";
 const char* kFuncNameConnect = "connect";
 const char* kFuncNameDisconnect = "disconnect";
 
 // States.
 const char* kAttrNameDisconnected = "DISCONNECTED";
 const char* kAttrNameRequestedAccessCode = "REQUESTED_ACCESS_CODE";
 const char* kAttrNameReceivedAccessCode = "RECEIVED_ACCESS_CODE";
@@ skipping 84 matching lines @@
     SetException("Invoke: unknown method " + method_name);
     return false;
   }
 }
 
 bool HostNPScriptObject::HasProperty(const std::string& property_name) {
   logger_->VLog(2, "HasProperty %s", property_name.c_str());
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   return (property_name == kAttrNameAccessCode ||
           property_name == kAttrNameAccessCodeLifetime ||
+          property_name == kAttrNameClient ||
           property_name == kAttrNameState ||
           property_name == kAttrNameLogDebugInfo ||
           property_name == kAttrNameOnStateChanged ||
           property_name == kAttrNameDisconnected ||
           property_name == kAttrNameRequestedAccessCode ||
           property_name == kAttrNameReceivedAccessCode ||
           property_name == kAttrNameConnected ||
           property_name == kAttrNameAffirmingConnection ||
           property_name == kAttrNameError);
 }
@@ skipping 15 matching lines @@
     return true;
   } else if (property_name == kAttrNameState) {
     INT32_TO_NPVARIANT(state_, *result);
     return true;
   } else if (property_name == kAttrNameAccessCode) {
     *result = NPVariantFromString(access_code_);
     return true;
   } else if (property_name == kAttrNameAccessCodeLifetime) {
     INT32_TO_NPVARIANT(access_code_lifetime_.InSeconds(), *result);
     return true;
+  } else if (property_name == kAttrNameClient) {
+    *result = NPVariantFromString(client_username_);
+    return true;
   } else if (property_name == kAttrNameDisconnected) {
     INT32_TO_NPVARIANT(kDisconnected, *result);
     return true;
   } else if (property_name == kAttrNameRequestedAccessCode) {
     INT32_TO_NPVARIANT(kRequestedAccessCode, *result);
     return true;
   } else if (property_name == kAttrNameReceivedAccessCode) {
     INT32_TO_NPVARIANT(kReceivedAccessCode, *result);
     return true;
   } else if (property_name == kAttrNameConnected) {
@@ skipping 90 matching lines @@
 }
 
 void HostNPScriptObject::OnAccessDenied() {
   DCHECK_EQ(MessageLoop::current(), host_context_.network_message_loop());
 
   ++failed_login_attempts_;
   if (failed_login_attempts_ == kMaxLoginAttempts)
     DisconnectInternal();
 }
 
-void HostNPScriptObject::OnAuthenticatedClientsChanged(int clients_connected) {
+void HostNPScriptObject::OnClientAuthenticated(
+    remoting::protocol::ConnectionToClient* client) {
   DCHECK_NE(base::PlatformThread::CurrentId(), np_thread_id_);
-  OnStateChanged(clients_connected ? kConnected : kDisconnected);
+  client_username_ = client->session()->jid();
+  size_t pos = client_username_.find('/');
+  if (pos != std::string::npos)
+    client_username_.replace(pos, std::string::npos, "");
+  LOG(INFO) << "Client " << client_username_ << " connected.";

[Wez, 2011/08/02 21:38:01]

nit: The client has authenticated; they were already connected.

+  OnStateChanged(kConnected);
+}
+
+void HostNPScriptObject::OnClientDisconnected(
+    remoting::protocol::ConnectionToClient* client) {
+  client_username_.clear();
+  OnStateChanged(kDisconnected);
 }
 
 void HostNPScriptObject::OnShutdown() {
   DCHECK_EQ(MessageLoop::current(), host_context_.main_message_loop());
 
   OnStateChanged(kDisconnected);
 }
 
 // string uid, string auth_token
 bool HostNPScriptObject::Connect(const NPVariant* args,
@@ skipping 227 matching lines @@
 }
 
 // static
 void HostNPScriptObject::NPTaskSpringboard(void* task) {
   base::Closure* real_task = reinterpret_cast<base::Closure*>(task);
   real_task->Run();
   delete real_task;
 }
 
 }  // namespace remoting