Added daemon process NPAPI.

remoting/host/plugin/host_script_object.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/plugin/host_script_object.h"
+#include "remoting/host/plugin/daemon_controller.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/sys_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.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_key_pair.h"
 #include "remoting/host/host_secret.h"
 #include "remoting/host/it2me_host_user_interface.h"
 #include "remoting/host/plugin/host_log_handler.h"
 #include "remoting/host/plugin/policy_hack/nat_policy.h"
 #include "remoting/host/register_support_host_request.h"
 #include "remoting/protocol/it2me_host_authenticator_factory.h"
 
 namespace remoting {
 
-// Supported Javascript interface:
-// readonly attribute string accessCode;
-// readonly attribute int accessCodeLifetime;
-// readonly attribute string client;
-// readonly attribute int state;
-//
-// state: {
-//     DISCONNECTED,
-//     STARTING,
-//     REQUESTED_ACCESS_CODE,
-//     RECEIVED_ACCESS_CODE,
-//     CONNECTED,
-//     DISCONNECTING,
-//     ERROR,
-// }
-//
-// attribute Function void logDebugInfo(string);
-// attribute Function void onNatTraversalPolicyChanged(boolean);
-// attribute Function void onStateChanged(state);
-//
-// // 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();
-// void localize(string (*localize_func)(string,...));
-
 namespace {
 
 const char* kAttrNameAccessCode = "accessCode";
 const char* kAttrNameAccessCodeLifetime = "accessCodeLifetime";
 const char* kAttrNameClient = "client";
+const char* kAttrNameDaemonState = "daemonState";
 const char* kAttrNameState = "state";
 const char* kAttrNameLogDebugInfo = "logDebugInfo";
 const char* kAttrNameOnNatTraversalPolicyChanged =
     "onNatTraversalPolicyChanged";
 const char* kAttrNameOnStateChanged = "onStateChanged";
 const char* kFuncNameConnect = "connect";
 const char* kFuncNameDisconnect = "disconnect";
 const char* kFuncNameLocalize = "localize";
+const char* kFuncNameSetDaemonPin = "setDaemonPin";
+const char* kFuncNameStartDaemon = "startDaemon";
+const char* kFuncNameStopDaemon = "stopDaemon";
 
 // States.
 const char* kAttrNameDisconnected = "DISCONNECTED";
 const char* kAttrNameStarting = "STARTING";
 const char* kAttrNameRequestedAccessCode = "REQUESTED_ACCESS_CODE";
 const char* kAttrNameReceivedAccessCode = "RECEIVED_ACCESS_CODE";
 const char* kAttrNameConnected = "CONNECTED";
 const char* kAttrNameDisconnecting = "DISCONNECTING";
 const char* kAttrNameError = "ERROR";
 
 const int kMaxLoginAttempts = 5;
 
 }  // namespace
 
 HostNPScriptObject::HostNPScriptObject(
     NPP plugin,
     NPObject* parent,
     PluginMessageLoopProxy::Delegate* plugin_thread_delegate)
     : plugin_(plugin),
       parent_(parent),
       state_(kDisconnected),
       np_thread_id_(base::PlatformThread::CurrentId()),
       plugin_message_loop_proxy_(
           new PluginMessageLoopProxy(plugin_thread_delegate)),
       host_context_(plugin_message_loop_proxy_),
       failed_login_attempts_(0),
+      daemon_controller_(DaemonController::Create()),
       disconnected_event_(true, false),
       am_currently_logging_(false),
       nat_traversal_enabled_(false),
       policy_received_(false) {
 }
 
 HostNPScriptObject::~HostNPScriptObject() {
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
 
   // Shutdown It2MeHostUserInterface first so that it doesn't try to post
@@ skipping 37 matching lines @@
       base::Bind(&HostNPScriptObject::OnNatPolicyUpdate,
                  base::Unretained(this)));
   return true;
 }
 
 bool HostNPScriptObject::HasMethod(const std::string& method_name) {
   VLOG(2) << "HasMethod " << method_name;
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   return (method_name == kFuncNameConnect ||
           method_name == kFuncNameDisconnect ||
-          method_name == kFuncNameLocalize);
+          method_name == kFuncNameLocalize ||
+          method_name == kFuncNameSetDaemonPin ||
+          method_name == kFuncNameStartDaemon ||
+          method_name == kFuncNameStopDaemon);
 }
 
 bool HostNPScriptObject::InvokeDefault(const NPVariant* args,
                                        uint32_t argCount,
                                        NPVariant* result) {
   VLOG(2) << "InvokeDefault";
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   SetException("exception during default invocation");
   return false;
 }
 
 bool HostNPScriptObject::Invoke(const std::string& method_name,
                                 const NPVariant* args,
                                 uint32_t argCount,
                                 NPVariant* result) {
   VLOG(2) << "Invoke " << method_name;
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   if (method_name == kFuncNameConnect) {
     return Connect(args, argCount, result);
   } else if (method_name == kFuncNameDisconnect) {
     return Disconnect(args, argCount, result);
   } else if (method_name == kFuncNameLocalize) {
     return Localize(args, argCount, result);
+  } else if (method_name == kFuncNameSetDaemonPin) {
+    return SetDaemonPin(args, argCount, result);
+  } else if (method_name == kFuncNameStartDaemon) {
+    return StartDaemon(args, argCount, result);
+  } else if (method_name == kFuncNameStopDaemon) {
+    return StopDaemon(args, argCount, result);
   } else {
     SetException("Invoke: unknown method " + method_name);
     return false;
   }
 }
 
 bool HostNPScriptObject::HasProperty(const std::string& property_name) {
   VLOG(2) << "HasProperty " << property_name;
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   return (property_name == kAttrNameAccessCode ||
           property_name == kAttrNameAccessCodeLifetime ||
           property_name == kAttrNameClient ||
+          property_name == kAttrNameDaemonState ||
           property_name == kAttrNameState ||
           property_name == kAttrNameLogDebugInfo ||
           property_name == kAttrNameOnNatTraversalPolicyChanged ||
           property_name == kAttrNameOnStateChanged ||
           property_name == kAttrNameDisconnected ||
           property_name == kAttrNameStarting ||
           property_name == kAttrNameRequestedAccessCode ||
           property_name == kAttrNameReceivedAccessCode ||
           property_name == kAttrNameConnected ||
           property_name == kAttrNameDisconnecting ||
@@ skipping 25 matching lines @@
     base::AutoLock auto_lock(access_code_lock_);
     *result = NPVariantFromString(access_code_);
     return true;
   } else if (property_name == kAttrNameAccessCodeLifetime) {
     base::AutoLock auto_lock(access_code_lock_);
     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 == kAttrNameDaemonState) {
+    INT32_TO_NPVARIANT(daemon_controller_->GetState(), *result);
+    return true;
   } else if (property_name == kAttrNameDisconnected) {
     INT32_TO_NPVARIANT(kDisconnected, *result);
     return true;
   } else if (property_name == kAttrNameStarting) {
     INT32_TO_NPVARIANT(kStarting, *result);
     return true;
   } else if (property_name == kAttrNameRequestedAccessCode) {
     INT32_TO_NPVARIANT(kRequestedAccessCode, *result);
     return true;
   } else if (property_name == kAttrNameReceivedAccessCode) {
@@ skipping 72 matching lines @@
 }
 
 bool HostNPScriptObject::Enumerate(std::vector<std::string>* values) {
   VLOG(2) << "Enumerate";
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   const char* entries[] = {
     kAttrNameAccessCode,
     kAttrNameState,
     kAttrNameLogDebugInfo,
     kAttrNameOnStateChanged,
-    kFuncNameConnect,
-    kFuncNameDisconnect,
-    kFuncNameLocalize,
     kAttrNameDisconnected,
     kAttrNameStarting,
     kAttrNameRequestedAccessCode,
     kAttrNameReceivedAccessCode,
     kAttrNameConnected,
     kAttrNameDisconnecting,
-    kAttrNameError
+    kAttrNameError,
+    kFuncNameConnect,
+    kFuncNameDisconnect,
+    kFuncNameLocalize,
+    kFuncNameSetDaemonPin,
+    kFuncNameStartDaemon,
+    kFuncNameStopDaemon
   };
   for (size_t i = 0; i < arraysize(entries); ++i) {
     values->push_back(entries[i]);
   }
   return true;
 }
 
 void HostNPScriptObject::OnAccessDenied(const std::string& jid) {
   DCHECK(host_context_.network_message_loop()->BelongsToCurrentThread());
 
@@ skipping 216 matching lines @@
   if (NPVARIANT_IS_OBJECT(args[0])) {
     ScopedRefNPObject localize_func(NPVARIANT_TO_OBJECT(args[0]));
     LocalizeStrings(localize_func.get());
     return true;
   } else {
     SetException("localize: unexpected type for argument 1");
     return false;
   }
 }
 
+bool HostNPScriptObject::SetDaemonPin(const NPVariant* args,
+                                      uint32_t arg_count,
+                                      NPVariant* result) {
+  if (arg_count != 1) {
+    SetException("startDaemon: bad number of arguments");
+    return false;
+  }
+  if (NPVARIANT_IS_STRING(args[0])) {
+    bool set_pin_result =
+        daemon_controller_->SetPin(StringFromNPVariant(args[0]));
+    BOOLEAN_TO_NPVARIANT(set_pin_result, *result);
+    return true;
+  } else {
+    SetException("startDaemon: unexpected type for argument 1");
+    return false;
+  }
+}
+
+bool HostNPScriptObject::StartDaemon(const NPVariant* args,
+                                     uint32_t arg_count,
+                                     NPVariant* result) {
+  if (arg_count != 0) {
+    SetException("startDaemon: bad number of arguments");
+    return false;
+  }
+  bool start_result = daemon_controller_->Start();
+  BOOLEAN_TO_NPVARIANT(start_result, *result);
+  return true;
+}
+
+bool HostNPScriptObject::StopDaemon(const NPVariant* args,
+                                    uint32_t arg_count,
+                                    NPVariant* result) {
+  if (arg_count != 0) {
+    SetException("startDaemon: bad number of arguments");
+    return false;
+  }
+  bool stop_result = daemon_controller_->Stop();
+  BOOLEAN_TO_NPVARIANT(stop_result, *result);
+  return true;
+}
+
 void HostNPScriptObject::DisconnectInternal() {
   if (!host_context_.network_message_loop()->BelongsToCurrentThread()) {
     host_context_.network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&HostNPScriptObject::DisconnectInternal,
                               base::Unretained(this)));
     return;
   }
 
   switch (state_) {
     case kDisconnected:
@@ skipping 257 matching lines @@
                                                uint32_t argCount) {
   NPVariant np_result;
   bool is_good = g_npnetscape_funcs->invokeDefault(plugin_, func, args,
                                                    argCount, &np_result);
   if (is_good)
       g_npnetscape_funcs->releasevariantvalue(&np_result);
   return is_good;
 }
 
 }  // namespace remoting