Windows chromoting host installation via the NPAPI plugin

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 "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_util.h"
@@ skipping 39 matching lines @@
 const char* kFuncNameClearPairedClients = "clearPairedClients";
 const char* kFuncNameDeletePairedClient = "deletePairedClient";
 const char* kFuncNameGetHostName = "getHostName";
 const char* kFuncNameGetPinHash = "getPinHash";
 const char* kFuncNameGenerateKeyPair = "generateKeyPair";
 const char* kFuncNameUpdateDaemonConfig = "updateDaemonConfig";
 const char* kFuncNameGetDaemonConfig = "getDaemonConfig";
 const char* kFuncNameGetDaemonVersion = "getDaemonVersion";
 const char* kFuncNameGetPairedClients = "getPairedClients";
 const char* kFuncNameGetUsageStatsConsent = "getUsageStatsConsent";
+const char* kFuncNameInstallHost = "installHost";
 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";
@@ skipping 76 matching lines @@
           method_name == kFuncNameClearPairedClients ||
           method_name == kFuncNameDeletePairedClient ||
           method_name == kFuncNameGetHostName ||
           method_name == kFuncNameGetPinHash ||
           method_name == kFuncNameGenerateKeyPair ||
           method_name == kFuncNameUpdateDaemonConfig ||
           method_name == kFuncNameGetDaemonConfig ||
           method_name == kFuncNameGetDaemonVersion ||
           method_name == kFuncNameGetPairedClients ||
           method_name == kFuncNameGetUsageStatsConsent ||
+          method_name == kFuncNameInstallHost ||
           method_name == kFuncNameStartDaemon ||
           method_name == kFuncNameStopDaemon);
 }
 
 bool HostNPScriptObject::InvokeDefault(const NPVariant* args,
                                        uint32_t arg_count,
                                        NPVariant* result) {
   VLOG(2) << "InvokeDefault";
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   SetException("exception during default invocation");
@@ skipping 25 matching lines @@
   } else if (method_name == kFuncNameUpdateDaemonConfig) {
     return UpdateDaemonConfig(args, arg_count, result);
   } else if (method_name == kFuncNameGetDaemonConfig) {
     return GetDaemonConfig(args, arg_count, result);
   } else if (method_name == kFuncNameGetDaemonVersion) {
     return GetDaemonVersion(args, arg_count, result);
   } else if (method_name == kFuncNameGetPairedClients) {
     return GetPairedClients(args, arg_count, result);
   } else if (method_name == kFuncNameGetUsageStatsConsent) {
     return GetUsageStatsConsent(args, arg_count, result);
+  } else if (method_name == kFuncNameInstallHost) {
+    return InstallHost(args, arg_count, result);
   } else if (method_name == kFuncNameStartDaemon) {
     return StartDaemon(args, arg_count, result);
   } else if (method_name == kFuncNameStopDaemon) {
     return StopDaemon(args, arg_count, result);
   } else {
     SetException("Invoke: unknown method " + method_name);
     return false;
   }
 }
 
@@ skipping 215 matching lines @@
     kFuncNameClearPairedClients,
     kFuncNameDeletePairedClient,
     kFuncNameGetHostName,
     kFuncNameGetPinHash,
     kFuncNameGenerateKeyPair,
     kFuncNameUpdateDaemonConfig,
     kFuncNameGetDaemonConfig,
     kFuncNameGetDaemonVersion,
     kFuncNameGetPairedClients,
     kFuncNameGetUsageStatsConsent,
+    kFuncNameInstallHost,
     kFuncNameStartDaemon,
     kFuncNameStopDaemon
   };
   for (size_t i = 0; i < arraysize(entries); ++i) {
     values->push_back(entries[i]);
   }
   return true;
 }
 
 // string username, string auth_token
@@ skipping 349 matching lines @@
     SetException("getUsageStatsConsent: invalid callback parameter");
     return false;
   }
 
   daemon_controller_->GetUsageStatsConsent(
       base::Bind(&HostNPScriptObject::InvokeGetUsageStatsConsentCallback,
                  weak_ptr_, base::Passed(&callback_obj)));
   return true;
 }
 
+bool HostNPScriptObject::InstallHost(const NPVariant* args,
+                                     uint32_t arg_count,
+                                     NPVariant* result) {
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
+
+  if (arg_count != 1) {
+    SetException("installHost: bad number of arguments");
+    return false;
+  }
+
+  scoped_ptr<ScopedRefNPObject> callback_obj(
+      new ScopedRefNPObject(ObjectFromNPVariant(args[0])));
+  if (!callback_obj->get()) {
+    SetException("installHost: invalid callback parameter");
+    return false;
+  }
+
+  daemon_controller_->InstallHost(
+      base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback, weak_ptr_,
+                 base::Passed(&callback_obj)));
+  return true;
+}
+
 bool HostNPScriptObject::StartDaemon(const NPVariant* args,
                                      uint32_t arg_count,
                                      NPVariant* result) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   if (arg_count != 3) {
     SetException("startDaemon: bad number of arguments");
     return false;
   }
 
@@ skipping 291 matching lines @@
 }
 
 void HostNPScriptObject::SetException(const std::string& exception_string) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   g_npnetscape_funcs->setexception(parent_, exception_string.c_str());
   HOST_LOG << exception_string;
 }
 
 }  // namespace remoting