| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "remoting/host/plugin/host_script_object.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/json/json_reader.h" | |
| 9 #include "base/json/json_writer.h" | |
| 10 #include "base/strings/string_util.h" | |
| 11 #include "base/strings/stringprintf.h" | |
| 12 #include "base/strings/sys_string_conversions.h" | |
| 13 #include "base/strings/utf_string_conversions.h" | |
| 14 #include "remoting/base/auth_token_util.h" | |
| 15 #include "remoting/base/auto_thread.h" | |
| 16 #include "remoting/base/logging.h" | |
| 17 #include "remoting/base/resources.h" | |
| 18 #include "remoting/base/rsa_key_pair.h" | |
| 19 #include "remoting/host/chromoting_host_context.h" | |
| 20 #include "remoting/host/host_config.h" | |
| 21 #include "remoting/host/pairing_registry_delegate.h" | |
| 22 #include "remoting/host/pin_hash.h" | |
| 23 #include "remoting/host/plugin/host_log_handler.h" | |
| 24 #include "remoting/host/policy_hack/policy_watcher.h" | |
| 25 #include "remoting/host/service_urls.h" | |
| 26 #include "third_party/npapi/bindings/npapi.h" | |
| 27 #include "third_party/npapi/bindings/npfunctions.h" | |
| 28 #include "third_party/npapi/bindings/npruntime.h" | |
| 29 | |
| 30 namespace remoting { | |
| 31 | |
| 32 namespace { | |
| 33 | |
| 34 const char* kAttrNameAccessCode = "accessCode"; | |
| 35 const char* kAttrNameAccessCodeLifetime = "accessCodeLifetime"; | |
| 36 const char* kAttrNameClient = "client"; | |
| 37 const char* kAttrNameDaemonState = "daemonState"; | |
| 38 const char* kAttrNameState = "state"; | |
| 39 const char* kAttrNameLogDebugInfo = "logDebugInfo"; | |
| 40 const char* kAttrNameOnNatTraversalPolicyChanged = | |
| 41 "onNatTraversalPolicyChanged"; | |
| 42 const char* kAttrNameOnStateChanged = "onStateChanged"; | |
| 43 const char* kAttrNameXmppServerAddress = "xmppServerAddress"; | |
| 44 const char* kAttrNameXmppServerUseTls = "xmppServerUseTls"; | |
| 45 const char* kAttrNameDirectoryBotJid = "directoryBotJid"; | |
| 46 const char* kAttrNameSupportedFeatures = "supportedFeatures"; | |
| 47 const char* kFuncNameConnect = "connect"; | |
| 48 const char* kFuncNameDisconnect = "disconnect"; | |
| 49 const char* kFuncNameLocalize = "localize"; | |
| 50 const char* kFuncNameClearPairedClients = "clearPairedClients"; | |
| 51 const char* kFuncNameDeletePairedClient = "deletePairedClient"; | |
| 52 const char* kFuncNameGetHostName = "getHostName"; | |
| 53 const char* kFuncNameGetPinHash = "getPinHash"; | |
| 54 const char* kFuncNameGenerateKeyPair = "generateKeyPair"; | |
| 55 const char* kFuncNameUpdateDaemonConfig = "updateDaemonConfig"; | |
| 56 const char* kFuncNameGetDaemonConfig = "getDaemonConfig"; | |
| 57 const char* kFuncNameGetDaemonVersion = "getDaemonVersion"; | |
| 58 const char* kFuncNameGetPairedClients = "getPairedClients"; | |
| 59 const char* kFuncNameGetUsageStatsConsent = "getUsageStatsConsent"; | |
| 60 const char* kFuncNameInstallHost = "installHost"; | |
| 61 const char* kFuncNameStartDaemon = "startDaemon"; | |
| 62 const char* kFuncNameStopDaemon = "stopDaemon"; | |
| 63 | |
| 64 // States. | |
| 65 const char* kAttrNameDisconnected = "DISCONNECTED"; | |
| 66 const char* kAttrNameStarting = "STARTING"; | |
| 67 const char* kAttrNameRequestedAccessCode = "REQUESTED_ACCESS_CODE"; | |
| 68 const char* kAttrNameReceivedAccessCode = "RECEIVED_ACCESS_CODE"; | |
| 69 const char* kAttrNameConnected = "CONNECTED"; | |
| 70 const char* kAttrNameDisconnecting = "DISCONNECTING"; | |
| 71 const char* kAttrNameError = "ERROR"; | |
| 72 const char* kAttrNameInvalidDomainError = "INVALID_DOMAIN_ERROR"; | |
| 73 | |
| 74 // Space separated list of features supported in addition to the base protocol. | |
| 75 const char* kSupportedFeatures = "pairingRegistry"; | |
| 76 | |
| 77 } // namespace | |
| 78 | |
| 79 HostNPScriptObject::HostNPScriptObject( | |
| 80 NPP plugin, | |
| 81 NPObject* parent, | |
| 82 scoped_refptr<AutoThreadTaskRunner> plugin_task_runner) | |
| 83 : plugin_(plugin), | |
| 84 parent_(parent), | |
| 85 plugin_task_runner_(plugin_task_runner), | |
| 86 am_currently_logging_(false), | |
| 87 state_(kDisconnected), | |
| 88 weak_factory_(this) { | |
| 89 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 90 | |
| 91 weak_ptr_ = weak_factory_.GetWeakPtr(); | |
| 92 | |
| 93 // Set the thread task runner for the plugin thread so that timers and other | |
| 94 // code using |base::ThreadTaskRunnerHandle| could be used on the plugin | |
| 95 // thread. | |
| 96 // | |
| 97 // If component build is used, Chrome and the plugin may end up sharing base | |
| 98 // binary. This means that the instance of |base::ThreadTaskRunnerHandle| | |
| 99 // created by Chrome for the current thread is shared as well. This routinely | |
| 100 // happens in the development setting so the below check for | |
| 101 // |!base::ThreadTaskRunnerHandle::IsSet()| is a hack/workaround allowing this | |
| 102 // configuration to work. It lets the plugin to access Chrome's message loop | |
| 103 // directly via |base::ThreadTaskRunnerHandle|. This is safe as long as both | |
| 104 // Chrome and the plugin are built from the same version of the sources. | |
| 105 if (!base::ThreadTaskRunnerHandle::IsSet()) { | |
| 106 plugin_task_runner_handle_.reset( | |
| 107 new base::ThreadTaskRunnerHandle(plugin_task_runner_)); | |
| 108 } | |
| 109 | |
| 110 daemon_controller_ = DaemonController::Create(); | |
| 111 | |
| 112 ServiceUrls* service_urls = ServiceUrls::GetInstance(); | |
| 113 bool xmpp_server_valid = net::ParseHostAndPort( | |
| 114 service_urls->xmpp_server_address(), | |
| 115 &xmpp_server_config_.host, &xmpp_server_config_.port); | |
| 116 // For the plugin, this is always the default address, which must be valid. | |
| 117 DCHECK(xmpp_server_valid); | |
| 118 xmpp_server_config_.use_tls = service_urls->xmpp_server_use_tls(); | |
| 119 directory_bot_jid_ = service_urls->directory_bot_jid(); | |
| 120 | |
| 121 // Create worker thread for encryption key generation and loading the paired | |
| 122 // clients. | |
| 123 worker_thread_ = AutoThread::Create("ChromotingWorkerThread", | |
| 124 plugin_task_runner_); | |
| 125 | |
| 126 pairing_registry_ = CreatePairingRegistry(worker_thread_); | |
| 127 } | |
| 128 | |
| 129 HostNPScriptObject::~HostNPScriptObject() { | |
| 130 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 131 | |
| 132 HostLogHandler::UnregisterLoggingScriptObject(this); | |
| 133 | |
| 134 // Stop the It2Me host if the caller forgot to. | |
| 135 if (it2me_host_.get()) { | |
| 136 it2me_host_->Disconnect(); | |
| 137 it2me_host_ = NULL; | |
| 138 } | |
| 139 } | |
| 140 | |
| 141 bool HostNPScriptObject::HasMethod(const std::string& method_name) { | |
| 142 VLOG(2) << "HasMethod " << method_name; | |
| 143 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 144 return (method_name == kFuncNameConnect || | |
| 145 method_name == kFuncNameDisconnect || | |
| 146 method_name == kFuncNameLocalize || | |
| 147 method_name == kFuncNameClearPairedClients || | |
| 148 method_name == kFuncNameDeletePairedClient || | |
| 149 method_name == kFuncNameGetHostName || | |
| 150 method_name == kFuncNameGetPinHash || | |
| 151 method_name == kFuncNameGenerateKeyPair || | |
| 152 method_name == kFuncNameUpdateDaemonConfig || | |
| 153 method_name == kFuncNameGetDaemonConfig || | |
| 154 method_name == kFuncNameGetDaemonVersion || | |
| 155 method_name == kFuncNameGetPairedClients || | |
| 156 method_name == kFuncNameGetUsageStatsConsent || | |
| 157 method_name == kFuncNameInstallHost || | |
| 158 method_name == kFuncNameStartDaemon || | |
| 159 method_name == kFuncNameStopDaemon); | |
| 160 } | |
| 161 | |
| 162 bool HostNPScriptObject::InvokeDefault(const NPVariant* args, | |
| 163 uint32_t arg_count, | |
| 164 NPVariant* result) { | |
| 165 VLOG(2) << "InvokeDefault"; | |
| 166 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 167 SetException("exception during default invocation"); | |
| 168 return false; | |
| 169 } | |
| 170 | |
| 171 bool HostNPScriptObject::Invoke(const std::string& method_name, | |
| 172 const NPVariant* args, | |
| 173 uint32_t arg_count, | |
| 174 NPVariant* result) { | |
| 175 VLOG(2) << "Invoke " << method_name; | |
| 176 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 177 if (method_name == kFuncNameConnect) { | |
| 178 return Connect(args, arg_count, result); | |
| 179 } else if (method_name == kFuncNameDisconnect) { | |
| 180 return Disconnect(args, arg_count, result); | |
| 181 } else if (method_name == kFuncNameLocalize) { | |
| 182 return Localize(args, arg_count, result); | |
| 183 } else if (method_name == kFuncNameClearPairedClients) { | |
| 184 return ClearPairedClients(args, arg_count, result); | |
| 185 } else if (method_name == kFuncNameDeletePairedClient) { | |
| 186 return DeletePairedClient(args, arg_count, result); | |
| 187 } else if (method_name == kFuncNameGetHostName) { | |
| 188 return GetHostName(args, arg_count, result); | |
| 189 } else if (method_name == kFuncNameGetPinHash) { | |
| 190 return GetPinHash(args, arg_count, result); | |
| 191 } else if (method_name == kFuncNameGenerateKeyPair) { | |
| 192 return GenerateKeyPair(args, arg_count, result); | |
| 193 } else if (method_name == kFuncNameUpdateDaemonConfig) { | |
| 194 return UpdateDaemonConfig(args, arg_count, result); | |
| 195 } else if (method_name == kFuncNameGetDaemonConfig) { | |
| 196 return GetDaemonConfig(args, arg_count, result); | |
| 197 } else if (method_name == kFuncNameGetDaemonVersion) { | |
| 198 return GetDaemonVersion(args, arg_count, result); | |
| 199 } else if (method_name == kFuncNameGetPairedClients) { | |
| 200 return GetPairedClients(args, arg_count, result); | |
| 201 } else if (method_name == kFuncNameGetUsageStatsConsent) { | |
| 202 return GetUsageStatsConsent(args, arg_count, result); | |
| 203 } else if (method_name == kFuncNameInstallHost) { | |
| 204 return InstallHost(args, arg_count, result); | |
| 205 } else if (method_name == kFuncNameStartDaemon) { | |
| 206 return StartDaemon(args, arg_count, result); | |
| 207 } else if (method_name == kFuncNameStopDaemon) { | |
| 208 return StopDaemon(args, arg_count, result); | |
| 209 } else { | |
| 210 SetException("Invoke: unknown method " + method_name); | |
| 211 return false; | |
| 212 } | |
| 213 } | |
| 214 | |
| 215 bool HostNPScriptObject::HasProperty(const std::string& property_name) { | |
| 216 VLOG(2) << "HasProperty " << property_name; | |
| 217 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 218 return (property_name == kAttrNameAccessCode || | |
| 219 property_name == kAttrNameAccessCodeLifetime || | |
| 220 property_name == kAttrNameClient || | |
| 221 property_name == kAttrNameDaemonState || | |
| 222 property_name == kAttrNameState || | |
| 223 property_name == kAttrNameLogDebugInfo || | |
| 224 property_name == kAttrNameOnNatTraversalPolicyChanged || | |
| 225 property_name == kAttrNameOnStateChanged || | |
| 226 property_name == kAttrNameDisconnected || | |
| 227 property_name == kAttrNameStarting || | |
| 228 property_name == kAttrNameRequestedAccessCode || | |
| 229 property_name == kAttrNameReceivedAccessCode || | |
| 230 property_name == kAttrNameConnected || | |
| 231 property_name == kAttrNameDisconnecting || | |
| 232 property_name == kAttrNameError || | |
| 233 property_name == kAttrNameXmppServerAddress || | |
| 234 property_name == kAttrNameXmppServerUseTls || | |
| 235 property_name == kAttrNameDirectoryBotJid || | |
| 236 property_name == kAttrNameSupportedFeatures); | |
| 237 } | |
| 238 | |
| 239 bool HostNPScriptObject::GetProperty(const std::string& property_name, | |
| 240 NPVariant* result) { | |
| 241 VLOG(2) << "GetProperty " << property_name; | |
| 242 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 243 if (!result) { | |
| 244 SetException("GetProperty: NULL result"); | |
| 245 return false; | |
| 246 } | |
| 247 | |
| 248 if (property_name == kAttrNameOnNatTraversalPolicyChanged) { | |
| 249 OBJECT_TO_NPVARIANT(on_nat_traversal_policy_changed_func_.get(), *result); | |
| 250 return true; | |
| 251 } else if (property_name == kAttrNameOnStateChanged) { | |
| 252 OBJECT_TO_NPVARIANT(on_state_changed_func_.get(), *result); | |
| 253 return true; | |
| 254 } else if (property_name == kAttrNameLogDebugInfo) { | |
| 255 OBJECT_TO_NPVARIANT(log_debug_info_func_.get(), *result); | |
| 256 return true; | |
| 257 } else if (property_name == kAttrNameState) { | |
| 258 INT32_TO_NPVARIANT(state_, *result); | |
| 259 return true; | |
| 260 } else if (property_name == kAttrNameAccessCode) { | |
| 261 *result = NPVariantFromString(access_code_); | |
| 262 return true; | |
| 263 } else if (property_name == kAttrNameAccessCodeLifetime) { | |
| 264 INT32_TO_NPVARIANT(access_code_lifetime_.InSeconds(), *result); | |
| 265 return true; | |
| 266 } else if (property_name == kAttrNameClient) { | |
| 267 *result = NPVariantFromString(client_username_); | |
| 268 return true; | |
| 269 } else if (property_name == kAttrNameDaemonState) { | |
| 270 INT32_TO_NPVARIANT(daemon_controller_->GetState(), *result); | |
| 271 return true; | |
| 272 } else if (property_name == kAttrNameDisconnected) { | |
| 273 INT32_TO_NPVARIANT(kDisconnected, *result); | |
| 274 return true; | |
| 275 } else if (property_name == kAttrNameStarting) { | |
| 276 INT32_TO_NPVARIANT(kStarting, *result); | |
| 277 return true; | |
| 278 } else if (property_name == kAttrNameRequestedAccessCode) { | |
| 279 INT32_TO_NPVARIANT(kRequestedAccessCode, *result); | |
| 280 return true; | |
| 281 } else if (property_name == kAttrNameReceivedAccessCode) { | |
| 282 INT32_TO_NPVARIANT(kReceivedAccessCode, *result); | |
| 283 return true; | |
| 284 } else if (property_name == kAttrNameConnected) { | |
| 285 INT32_TO_NPVARIANT(kConnected, *result); | |
| 286 return true; | |
| 287 } else if (property_name == kAttrNameDisconnecting) { | |
| 288 INT32_TO_NPVARIANT(kDisconnecting, *result); | |
| 289 return true; | |
| 290 } else if (property_name == kAttrNameError) { | |
| 291 INT32_TO_NPVARIANT(kError, *result); | |
| 292 return true; | |
| 293 } else if (property_name == kAttrNameInvalidDomainError) { | |
| 294 INT32_TO_NPVARIANT(kInvalidDomainError, *result); | |
| 295 return true; | |
| 296 } else if (property_name == kAttrNameXmppServerAddress) { | |
| 297 *result = NPVariantFromString(base::StringPrintf( | |
| 298 "%s:%u", xmpp_server_config_.host.c_str(), xmpp_server_config_.port)); | |
| 299 return true; | |
| 300 } else if (property_name == kAttrNameXmppServerUseTls) { | |
| 301 BOOLEAN_TO_NPVARIANT(xmpp_server_config_.use_tls, *result); | |
| 302 return true; | |
| 303 } else if (property_name == kAttrNameDirectoryBotJid) { | |
| 304 *result = NPVariantFromString(directory_bot_jid_); | |
| 305 return true; | |
| 306 } else if (property_name == kAttrNameSupportedFeatures) { | |
| 307 *result = NPVariantFromString(kSupportedFeatures); | |
| 308 return true; | |
| 309 } else { | |
| 310 SetException("GetProperty: unsupported property " + property_name); | |
| 311 return false; | |
| 312 } | |
| 313 } | |
| 314 | |
| 315 bool HostNPScriptObject::SetProperty(const std::string& property_name, | |
| 316 const NPVariant* value) { | |
| 317 VLOG(2) << "SetProperty " << property_name; | |
| 318 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 319 | |
| 320 if (property_name == kAttrNameOnNatTraversalPolicyChanged) { | |
| 321 if (NPVARIANT_IS_OBJECT(*value)) { | |
| 322 on_nat_traversal_policy_changed_func_ = NPVARIANT_TO_OBJECT(*value); | |
| 323 if (it2me_host_.get()) { | |
| 324 // Ask the It2Me host to notify the web-app of the policy. | |
| 325 it2me_host_->RequestNatPolicy(); | |
| 326 } | |
| 327 return true; | |
| 328 } else { | |
| 329 SetException("SetProperty: unexpected type for property " + | |
| 330 property_name); | |
| 331 } | |
| 332 return false; | |
| 333 } | |
| 334 | |
| 335 if (property_name == kAttrNameOnStateChanged) { | |
| 336 if (NPVARIANT_IS_OBJECT(*value)) { | |
| 337 on_state_changed_func_ = NPVARIANT_TO_OBJECT(*value); | |
| 338 return true; | |
| 339 } else { | |
| 340 SetException("SetProperty: unexpected type for property " + | |
| 341 property_name); | |
| 342 } | |
| 343 return false; | |
| 344 } | |
| 345 | |
| 346 if (property_name == kAttrNameLogDebugInfo) { | |
| 347 if (NPVARIANT_IS_OBJECT(*value)) { | |
| 348 log_debug_info_func_ = NPVARIANT_TO_OBJECT(*value); | |
| 349 HostLogHandler::RegisterLoggingScriptObject(this); | |
| 350 return true; | |
| 351 } else { | |
| 352 SetException("SetProperty: unexpected type for property " + | |
| 353 property_name); | |
| 354 } | |
| 355 return false; | |
| 356 } | |
| 357 | |
| 358 #if !defined(NDEBUG) | |
| 359 if (property_name == kAttrNameXmppServerAddress) { | |
| 360 if (NPVARIANT_IS_STRING(*value)) { | |
| 361 std::string address = StringFromNPVariant(*value); | |
| 362 bool xmpp_server_valid = net::ParseHostAndPort( | |
| 363 address, &xmpp_server_config_.host, &xmpp_server_config_.port); | |
| 364 if (xmpp_server_valid) { | |
| 365 return true; | |
| 366 } else { | |
| 367 SetException("SetProperty: invalid value for property " + | |
| 368 property_name); | |
| 369 } | |
| 370 } else { | |
| 371 SetException("SetProperty: unexpected type for property " + | |
| 372 property_name); | |
| 373 } | |
| 374 return false; | |
| 375 } | |
| 376 | |
| 377 if (property_name == kAttrNameXmppServerUseTls) { | |
| 378 if (NPVARIANT_IS_BOOLEAN(*value)) { | |
| 379 xmpp_server_config_.use_tls = NPVARIANT_TO_BOOLEAN(*value); | |
| 380 return true; | |
| 381 } else { | |
| 382 SetException("SetProperty: unexpected type for property " + | |
| 383 property_name); | |
| 384 } | |
| 385 return false; | |
| 386 } | |
| 387 | |
| 388 if (property_name == kAttrNameDirectoryBotJid) { | |
| 389 if (NPVARIANT_IS_STRING(*value)) { | |
| 390 directory_bot_jid_ = StringFromNPVariant(*value); | |
| 391 return true; | |
| 392 } else { | |
| 393 SetException("SetProperty: unexpected type for property " + | |
| 394 property_name); | |
| 395 } | |
| 396 return false; | |
| 397 } | |
| 398 #endif // !defined(NDEBUG) | |
| 399 | |
| 400 return false; | |
| 401 } | |
| 402 | |
| 403 bool HostNPScriptObject::RemoveProperty(const std::string& property_name) { | |
| 404 VLOG(2) << "RemoveProperty " << property_name; | |
| 405 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 406 return false; | |
| 407 } | |
| 408 | |
| 409 bool HostNPScriptObject::Enumerate(std::vector<std::string>* values) { | |
| 410 VLOG(2) << "Enumerate"; | |
| 411 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 412 const char* entries[] = { | |
| 413 kAttrNameAccessCode, | |
| 414 kAttrNameState, | |
| 415 kAttrNameLogDebugInfo, | |
| 416 kAttrNameOnStateChanged, | |
| 417 kAttrNameDisconnected, | |
| 418 kAttrNameStarting, | |
| 419 kAttrNameRequestedAccessCode, | |
| 420 kAttrNameReceivedAccessCode, | |
| 421 kAttrNameConnected, | |
| 422 kAttrNameDisconnecting, | |
| 423 kAttrNameError, | |
| 424 kAttrNameXmppServerAddress, | |
| 425 kAttrNameXmppServerUseTls, | |
| 426 kAttrNameDirectoryBotJid, | |
| 427 kFuncNameConnect, | |
| 428 kFuncNameDisconnect, | |
| 429 kFuncNameLocalize, | |
| 430 kFuncNameClearPairedClients, | |
| 431 kFuncNameDeletePairedClient, | |
| 432 kFuncNameGetHostName, | |
| 433 kFuncNameGetPinHash, | |
| 434 kFuncNameGenerateKeyPair, | |
| 435 kFuncNameUpdateDaemonConfig, | |
| 436 kFuncNameGetDaemonConfig, | |
| 437 kFuncNameGetDaemonVersion, | |
| 438 kFuncNameGetPairedClients, | |
| 439 kFuncNameGetUsageStatsConsent, | |
| 440 kFuncNameInstallHost, | |
| 441 kFuncNameStartDaemon, | |
| 442 kFuncNameStopDaemon | |
| 443 }; | |
| 444 for (size_t i = 0; i < arraysize(entries); ++i) { | |
| 445 values->push_back(entries[i]); | |
| 446 } | |
| 447 return true; | |
| 448 } | |
| 449 | |
| 450 // string username, string auth_token | |
| 451 bool HostNPScriptObject::Connect(const NPVariant* args, | |
| 452 uint32_t arg_count, | |
| 453 NPVariant* result) { | |
| 454 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 455 | |
| 456 HOST_LOG << "Connecting..."; | |
| 457 | |
| 458 if (arg_count != 2) { | |
| 459 SetException("connect: bad number of arguments"); | |
| 460 return false; | |
| 461 } | |
| 462 | |
| 463 if (it2me_host_.get()) { | |
| 464 SetException("connect: can be called only when disconnected"); | |
| 465 return false; | |
| 466 } | |
| 467 | |
| 468 XmppSignalStrategy::XmppServerConfig xmpp_config = xmpp_server_config_; | |
| 469 | |
| 470 xmpp_config.username = StringFromNPVariant(args[0]); | |
| 471 if (xmpp_config.username.empty()) { | |
| 472 SetException("connect: bad username argument"); | |
| 473 return false; | |
| 474 } | |
| 475 | |
| 476 std::string auth_service_with_token = StringFromNPVariant(args[1]); | |
| 477 ParseAuthTokenWithService(auth_service_with_token, &xmpp_config.auth_token, | |
| 478 &xmpp_config.auth_service); | |
| 479 if (xmpp_config.auth_token.empty()) { | |
| 480 SetException("connect: auth_service_with_token argument has empty token"); | |
| 481 return false; | |
| 482 } | |
| 483 | |
| 484 // Create a host context to manage the threads for the it2me host. | |
| 485 // The plugin, rather than the It2MeHost object, owns and maintains the | |
| 486 // lifetime of the host context. | |
| 487 host_context_.reset( | |
| 488 ChromotingHostContext::Create(plugin_task_runner_).release()); | |
| 489 if (!host_context_) { | |
| 490 SetException("connect: failed to start threads"); | |
| 491 return false; | |
| 492 } | |
| 493 | |
| 494 // Create the It2Me host and start connecting. | |
| 495 scoped_ptr<It2MeHostFactory> factory(new It2MeHostFactory()); | |
| 496 it2me_host_ = factory->CreateIt2MeHost( | |
| 497 host_context_.get(), plugin_task_runner_, weak_ptr_, | |
| 498 xmpp_config, directory_bot_jid_); | |
| 499 it2me_host_->Connect(); | |
| 500 | |
| 501 return true; | |
| 502 } | |
| 503 | |
| 504 bool HostNPScriptObject::Disconnect(const NPVariant* args, | |
| 505 uint32_t arg_count, | |
| 506 NPVariant* result) { | |
| 507 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 508 if (arg_count != 0) { | |
| 509 SetException("disconnect: bad number of arguments"); | |
| 510 return false; | |
| 511 } | |
| 512 | |
| 513 if (it2me_host_.get()) { | |
| 514 it2me_host_->Disconnect(); | |
| 515 it2me_host_ = NULL; | |
| 516 } | |
| 517 | |
| 518 return true; | |
| 519 } | |
| 520 | |
| 521 bool HostNPScriptObject::Localize(const NPVariant* args, | |
| 522 uint32_t arg_count, | |
| 523 NPVariant* result) { | |
| 524 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 525 if (arg_count != 1) { | |
| 526 SetException("localize: bad number of arguments"); | |
| 527 return false; | |
| 528 } | |
| 529 | |
| 530 if (NPVARIANT_IS_OBJECT(args[0])) { | |
| 531 ScopedRefNPObject localize_func(NPVARIANT_TO_OBJECT(args[0])); | |
| 532 LocalizeStrings(localize_func.get()); | |
| 533 return true; | |
| 534 } else { | |
| 535 SetException("localize: unexpected type for argument 1"); | |
| 536 return false; | |
| 537 } | |
| 538 } | |
| 539 | |
| 540 bool HostNPScriptObject::ClearPairedClients(const NPVariant* args, | |
| 541 uint32_t arg_count, | |
| 542 NPVariant* result) { | |
| 543 if (arg_count != 1) { | |
| 544 SetException("clearPairedClients: bad number of arguments"); | |
| 545 return false; | |
| 546 } | |
| 547 | |
| 548 if (!NPVARIANT_IS_OBJECT(args[0])) { | |
| 549 SetException("clearPairedClients: invalid callback parameter"); | |
| 550 return false; | |
| 551 } | |
| 552 | |
| 553 scoped_ptr<ScopedRefNPObject> callback_obj( | |
| 554 new ScopedRefNPObject(ObjectFromNPVariant(args[0]))); | |
| 555 if (pairing_registry_) { | |
| 556 pairing_registry_->ClearAllPairings( | |
| 557 base::Bind(&HostNPScriptObject::InvokeBooleanCallback, weak_ptr_, | |
| 558 base::Passed(&callback_obj))); | |
| 559 } else { | |
| 560 InvokeBooleanCallback(callback_obj.Pass(), false); | |
| 561 } | |
| 562 | |
| 563 return true; | |
| 564 } | |
| 565 | |
| 566 bool HostNPScriptObject::DeletePairedClient(const NPVariant* args, | |
| 567 uint32_t arg_count, | |
| 568 NPVariant* result) { | |
| 569 if (arg_count != 2) { | |
| 570 SetException("deletePairedClient: bad number of arguments"); | |
| 571 return false; | |
| 572 } | |
| 573 | |
| 574 if (!NPVARIANT_IS_STRING(args[0])) { | |
| 575 SetException("deletePairedClient: bad clientId parameter"); | |
| 576 return false; | |
| 577 } | |
| 578 | |
| 579 if (!NPVARIANT_IS_OBJECT(args[1])) { | |
| 580 SetException("deletePairedClient: invalid callback parameter"); | |
| 581 return false; | |
| 582 } | |
| 583 | |
| 584 std::string client_id = StringFromNPVariant(args[0]); | |
| 585 scoped_ptr<ScopedRefNPObject> callback_obj( | |
| 586 new ScopedRefNPObject(ObjectFromNPVariant(args[1]))); | |
| 587 if (pairing_registry_) { | |
| 588 pairing_registry_->DeletePairing( | |
| 589 client_id, | |
| 590 base::Bind(&HostNPScriptObject::InvokeBooleanCallback, | |
| 591 weak_ptr_, base::Passed(&callback_obj))); | |
| 592 } else { | |
| 593 InvokeBooleanCallback(callback_obj.Pass(), false); | |
| 594 } | |
| 595 | |
| 596 return true; | |
| 597 } | |
| 598 | |
| 599 bool HostNPScriptObject::GetHostName(const NPVariant* args, | |
| 600 uint32_t arg_count, | |
| 601 NPVariant* result) { | |
| 602 if (arg_count != 1) { | |
| 603 SetException("getHostName: bad number of arguments"); | |
| 604 return false; | |
| 605 } | |
| 606 | |
| 607 ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0])); | |
| 608 if (!callback_obj.get()) { | |
| 609 SetException("getHostName: invalid callback parameter"); | |
| 610 return false; | |
| 611 } | |
| 612 | |
| 613 NPVariant host_name_val = NPVariantFromString(net::GetHostName()); | |
| 614 InvokeAndIgnoreResult(callback_obj, &host_name_val, 1); | |
| 615 g_npnetscape_funcs->releasevariantvalue(&host_name_val); | |
| 616 | |
| 617 return true; | |
| 618 } | |
| 619 | |
| 620 bool HostNPScriptObject::GetPinHash(const NPVariant* args, | |
| 621 uint32_t arg_count, | |
| 622 NPVariant* result) { | |
| 623 if (arg_count != 3) { | |
| 624 SetException("getPinHash: bad number of arguments"); | |
| 625 return false; | |
| 626 } | |
| 627 | |
| 628 std::string host_id = StringFromNPVariant(args[0]); | |
| 629 if (host_id.empty()) { | |
| 630 SetException("getPinHash: bad hostId parameter"); | |
| 631 return false; | |
| 632 } | |
| 633 | |
| 634 if (!NPVARIANT_IS_STRING(args[1])) { | |
| 635 SetException("getPinHash: bad pin parameter"); | |
| 636 return false; | |
| 637 } | |
| 638 std::string pin = StringFromNPVariant(args[1]); | |
| 639 | |
| 640 ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[2])); | |
| 641 if (!callback_obj.get()) { | |
| 642 SetException("getPinHash: invalid callback parameter"); | |
| 643 return false; | |
| 644 } | |
| 645 | |
| 646 NPVariant pin_hash_val = NPVariantFromString( | |
| 647 remoting::MakeHostPinHash(host_id, pin)); | |
| 648 InvokeAndIgnoreResult(callback_obj, &pin_hash_val, 1); | |
| 649 g_npnetscape_funcs->releasevariantvalue(&pin_hash_val); | |
| 650 | |
| 651 return true; | |
| 652 } | |
| 653 | |
| 654 bool HostNPScriptObject::GenerateKeyPair(const NPVariant* args, | |
| 655 uint32_t arg_count, | |
| 656 NPVariant* result) { | |
| 657 if (arg_count != 1) { | |
| 658 SetException("generateKeyPair: bad number of arguments"); | |
| 659 return false; | |
| 660 } | |
| 661 | |
| 662 scoped_ptr<ScopedRefNPObject> callback_obj( | |
| 663 new ScopedRefNPObject(ObjectFromNPVariant(args[0]))); | |
| 664 if (!callback_obj->get()) { | |
| 665 SetException("generateKeyPair: invalid callback parameter"); | |
| 666 return false; | |
| 667 } | |
| 668 | |
| 669 base::Callback<void (const std::string&, | |
| 670 const std::string&)> wrapped_callback = | |
| 671 base::Bind(&HostNPScriptObject::InvokeGenerateKeyPairCallback, weak_ptr_, | |
| 672 base::Passed(&callback_obj)); | |
| 673 worker_thread_->PostTask( | |
| 674 FROM_HERE, base::Bind(&HostNPScriptObject::DoGenerateKeyPair, | |
| 675 plugin_task_runner_, wrapped_callback)); | |
| 676 return true; | |
| 677 } | |
| 678 | |
| 679 bool HostNPScriptObject::UpdateDaemonConfig(const NPVariant* args, | |
| 680 uint32_t arg_count, | |
| 681 NPVariant* result) { | |
| 682 if (arg_count != 2) { | |
| 683 SetException("updateDaemonConfig: bad number of arguments"); | |
| 684 return false; | |
| 685 } | |
| 686 | |
| 687 std::string config_str = StringFromNPVariant(args[0]); | |
| 688 scoped_ptr<base::Value> config( | |
| 689 base::JSONReader::Read(config_str, base::JSON_ALLOW_TRAILING_COMMAS)); | |
| 690 if (config_str.empty() || !config.get() || | |
| 691 !config->IsType(base::Value::TYPE_DICTIONARY)) { | |
| 692 SetException("updateDaemonConfig: bad config parameter"); | |
| 693 return false; | |
| 694 } | |
| 695 scoped_ptr<base::DictionaryValue> config_dict( | |
| 696 reinterpret_cast<base::DictionaryValue*>(config.release())); | |
| 697 | |
| 698 scoped_ptr<ScopedRefNPObject> callback_obj( | |
| 699 new ScopedRefNPObject(ObjectFromNPVariant(args[1]))); | |
| 700 if (!callback_obj->get()) { | |
| 701 SetException("updateDaemonConfig: invalid callback parameter"); | |
| 702 return false; | |
| 703 } | |
| 704 | |
| 705 if (config_dict->HasKey(kHostIdConfigPath) || | |
| 706 config_dict->HasKey(kXmppLoginConfigPath)) { | |
| 707 SetException("updateDaemonConfig: trying to update immutable config " | |
| 708 "parameters"); | |
| 709 return false; | |
| 710 } | |
| 711 | |
| 712 daemon_controller_->UpdateConfig( | |
| 713 config_dict.Pass(), | |
| 714 base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback, weak_ptr_, | |
| 715 base::Passed(&callback_obj))); | |
| 716 return true; | |
| 717 } | |
| 718 | |
| 719 bool HostNPScriptObject::GetDaemonConfig(const NPVariant* args, | |
| 720 uint32_t arg_count, | |
| 721 NPVariant* result) { | |
| 722 if (arg_count != 1) { | |
| 723 SetException("getDaemonConfig: bad number of arguments"); | |
| 724 return false; | |
| 725 } | |
| 726 | |
| 727 scoped_ptr<ScopedRefNPObject> callback_obj( | |
| 728 new ScopedRefNPObject(ObjectFromNPVariant(args[0]))); | |
| 729 if (!callback_obj->get()) { | |
| 730 SetException("getDaemonConfig: invalid callback parameter"); | |
| 731 return false; | |
| 732 } | |
| 733 | |
| 734 daemon_controller_->GetConfig( | |
| 735 base::Bind(&HostNPScriptObject::InvokeGetDaemonConfigCallback, weak_ptr_, | |
| 736 base::Passed(&callback_obj))); | |
| 737 return true; | |
| 738 } | |
| 739 | |
| 740 bool HostNPScriptObject::GetDaemonVersion(const NPVariant* args, | |
| 741 uint32_t arg_count, | |
| 742 NPVariant* result) { | |
| 743 if (arg_count != 1) { | |
| 744 SetException("getDaemonVersion: bad number of arguments"); | |
| 745 return false; | |
| 746 } | |
| 747 | |
| 748 scoped_ptr<ScopedRefNPObject> callback_obj( | |
| 749 new ScopedRefNPObject(ObjectFromNPVariant(args[0]))); | |
| 750 if (!callback_obj->get()) { | |
| 751 SetException("getDaemonVersion: invalid callback parameter"); | |
| 752 return false; | |
| 753 } | |
| 754 | |
| 755 daemon_controller_->GetVersion( | |
| 756 base::Bind(&HostNPScriptObject::InvokeGetDaemonVersionCallback, weak_ptr_, | |
| 757 base::Passed(&callback_obj))); | |
| 758 | |
| 759 return true; | |
| 760 } | |
| 761 | |
| 762 bool HostNPScriptObject::GetPairedClients(const NPVariant* args, | |
| 763 uint32_t arg_count, | |
| 764 NPVariant* result) { | |
| 765 if (arg_count != 1) { | |
| 766 SetException("getPairedClients: bad number of arguments"); | |
| 767 return false; | |
| 768 } | |
| 769 | |
| 770 scoped_ptr<ScopedRefNPObject> callback_obj( | |
| 771 new ScopedRefNPObject(ObjectFromNPVariant(args[0]))); | |
| 772 if (!callback_obj->get()) { | |
| 773 SetException("getPairedClients: invalid callback parameter"); | |
| 774 return false; | |
| 775 } | |
| 776 | |
| 777 if (pairing_registry_) { | |
| 778 pairing_registry_->GetAllPairings( | |
| 779 base::Bind(&HostNPScriptObject::InvokeGetPairedClientsCallback, | |
| 780 weak_ptr_, base::Passed(&callback_obj))); | |
| 781 } else { | |
| 782 scoped_ptr<base::ListValue> no_paired_clients(new base::ListValue); | |
| 783 InvokeGetPairedClientsCallback(callback_obj.Pass(), | |
| 784 no_paired_clients.Pass()); | |
| 785 } | |
| 786 return true; | |
| 787 } | |
| 788 | |
| 789 bool HostNPScriptObject::GetUsageStatsConsent(const NPVariant* args, | |
| 790 uint32_t arg_count, | |
| 791 NPVariant* result) { | |
| 792 if (arg_count != 1) { | |
| 793 SetException("getUsageStatsConsent: bad number of arguments"); | |
| 794 return false; | |
| 795 } | |
| 796 | |
| 797 scoped_ptr<ScopedRefNPObject> callback_obj( | |
| 798 new ScopedRefNPObject(ObjectFromNPVariant(args[0]))); | |
| 799 if (!callback_obj->get()) { | |
| 800 SetException("getUsageStatsConsent: invalid callback parameter"); | |
| 801 return false; | |
| 802 } | |
| 803 | |
| 804 daemon_controller_->GetUsageStatsConsent( | |
| 805 base::Bind(&HostNPScriptObject::InvokeGetUsageStatsConsentCallback, | |
| 806 weak_ptr_, base::Passed(&callback_obj))); | |
| 807 return true; | |
| 808 } | |
| 809 | |
| 810 bool HostNPScriptObject::InstallHost(const NPVariant* args, | |
| 811 uint32_t arg_count, | |
| 812 NPVariant* result) { | |
| 813 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 814 | |
| 815 if (arg_count != 1) { | |
| 816 SetException("installHost: bad number of arguments"); | |
| 817 return false; | |
| 818 } | |
| 819 | |
| 820 scoped_ptr<ScopedRefNPObject> callback_obj( | |
| 821 new ScopedRefNPObject(ObjectFromNPVariant(args[0]))); | |
| 822 if (!callback_obj->get()) { | |
| 823 SetException("installHost: invalid callback parameter"); | |
| 824 return false; | |
| 825 } | |
| 826 | |
| 827 daemon_controller_->InstallHost( | |
| 828 base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback, weak_ptr_, | |
| 829 base::Passed(&callback_obj))); | |
| 830 return true; | |
| 831 } | |
| 832 | |
| 833 bool HostNPScriptObject::StartDaemon(const NPVariant* args, | |
| 834 uint32_t arg_count, | |
| 835 NPVariant* result) { | |
| 836 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 837 | |
| 838 if (arg_count != 3) { | |
| 839 SetException("startDaemon: bad number of arguments"); | |
| 840 return false; | |
| 841 } | |
| 842 | |
| 843 std::string config_str = StringFromNPVariant(args[0]); | |
| 844 scoped_ptr<base::Value> config( | |
| 845 base::JSONReader::Read(config_str, base::JSON_ALLOW_TRAILING_COMMAS)); | |
| 846 if (config_str.empty() || !config.get() || | |
| 847 !config->IsType(base::Value::TYPE_DICTIONARY)) { | |
| 848 SetException("startDaemon: bad config parameter"); | |
| 849 return false; | |
| 850 } | |
| 851 scoped_ptr<base::DictionaryValue> config_dict( | |
| 852 reinterpret_cast<base::DictionaryValue*>(config.release())); | |
| 853 | |
| 854 if (!NPVARIANT_IS_BOOLEAN(args[1])) { | |
| 855 SetException("startDaemon: invalid consent parameter"); | |
| 856 return false; | |
| 857 } | |
| 858 | |
| 859 scoped_ptr<ScopedRefNPObject> callback_obj( | |
| 860 new ScopedRefNPObject(ObjectFromNPVariant(args[2]))); | |
| 861 if (!callback_obj->get()) { | |
| 862 SetException("startDaemon: invalid callback parameter"); | |
| 863 return false; | |
| 864 } | |
| 865 | |
| 866 daemon_controller_->SetConfigAndStart( | |
| 867 config_dict.Pass(), | |
| 868 NPVARIANT_TO_BOOLEAN(args[1]), | |
| 869 base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback, weak_ptr_, | |
| 870 base::Passed(&callback_obj))); | |
| 871 return true; | |
| 872 } | |
| 873 | |
| 874 bool HostNPScriptObject::StopDaemon(const NPVariant* args, | |
| 875 uint32_t arg_count, | |
| 876 NPVariant* result) { | |
| 877 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 878 | |
| 879 if (arg_count != 1) { | |
| 880 SetException("stopDaemon: bad number of arguments"); | |
| 881 return false; | |
| 882 } | |
| 883 | |
| 884 scoped_ptr<ScopedRefNPObject> callback_obj( | |
| 885 new ScopedRefNPObject(ObjectFromNPVariant(args[0]))); | |
| 886 if (!callback_obj->get()) { | |
| 887 SetException("stopDaemon: invalid callback parameter"); | |
| 888 return false; | |
| 889 } | |
| 890 | |
| 891 daemon_controller_->Stop( | |
| 892 base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback, weak_ptr_, | |
| 893 base::Passed(&callback_obj))); | |
| 894 return true; | |
| 895 } | |
| 896 | |
| 897 void HostNPScriptObject::OnStateChanged(It2MeHostState state) { | |
| 898 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 899 | |
| 900 state_ = state; | |
| 901 | |
| 902 if (state_ == kDisconnected) | |
| 903 client_username_.clear(); | |
| 904 | |
| 905 if (on_state_changed_func_.get()) { | |
| 906 NPVariant state_var; | |
| 907 INT32_TO_NPVARIANT(state, state_var); | |
| 908 InvokeAndIgnoreResult(on_state_changed_func_, &state_var, 1); | |
| 909 } | |
| 910 } | |
| 911 | |
| 912 void HostNPScriptObject::OnNatPolicyChanged(bool nat_traversal_enabled) { | |
| 913 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 914 | |
| 915 if (on_nat_traversal_policy_changed_func_.get()) { | |
| 916 NPVariant policy; | |
| 917 BOOLEAN_TO_NPVARIANT(nat_traversal_enabled, policy); | |
| 918 InvokeAndIgnoreResult(on_nat_traversal_policy_changed_func_, | |
| 919 &policy, 1); | |
| 920 } | |
| 921 } | |
| 922 | |
| 923 // Stores the Access Code for the web-app to query. | |
| 924 void HostNPScriptObject::OnStoreAccessCode( | |
| 925 const std::string& access_code, base::TimeDelta access_code_lifetime) { | |
| 926 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 927 | |
| 928 access_code_ = access_code; | |
| 929 access_code_lifetime_ = access_code_lifetime; | |
| 930 } | |
| 931 | |
| 932 // Stores the client user's name for the web-app to query. | |
| 933 void HostNPScriptObject::OnClientAuthenticated( | |
| 934 const std::string& client_username) { | |
| 935 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 936 | |
| 937 client_username_ = client_username; | |
| 938 } | |
| 939 | |
| 940 void HostNPScriptObject::PostLogDebugInfo(const std::string& message) { | |
| 941 if (plugin_task_runner_->BelongsToCurrentThread()) { | |
| 942 // Make sure we're not currently processing a log message. | |
| 943 // We only need to check this if we're on the plugin thread. | |
| 944 if (am_currently_logging_) | |
| 945 return; | |
| 946 } | |
| 947 | |
| 948 // Always post (even if we're already on the correct thread) so that debug | |
| 949 // log messages are shown in the correct order. | |
| 950 plugin_task_runner_->PostTask( | |
| 951 FROM_HERE, base::Bind(&HostNPScriptObject::LogDebugInfo, | |
| 952 weak_ptr_, message)); | |
| 953 } | |
| 954 | |
| 955 void HostNPScriptObject::SetWindow(NPWindow* np_window) { | |
| 956 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 957 | |
| 958 daemon_controller_->SetWindow(np_window->window); | |
| 959 } | |
| 960 | |
| 961 void HostNPScriptObject::LocalizeStrings(NPObject* localize_func) { | |
| 962 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 963 | |
| 964 // Reload resources for the current locale. The default UI locale is used on | |
| 965 // Windows. | |
| 966 #if !defined(OS_WIN) | |
| 967 base::string16 ui_locale; | |
| 968 LocalizeString(localize_func, "@@ui_locale", &ui_locale); | |
| 969 remoting::LoadResources(base::UTF16ToUTF8(ui_locale)); | |
| 970 #endif // !defined(OS_WIN) | |
| 971 } | |
| 972 | |
| 973 bool HostNPScriptObject::LocalizeString(NPObject* localize_func, | |
| 974 const char* tag, | |
| 975 base::string16* result) { | |
| 976 return LocalizeStringWithSubstitution(localize_func, tag, NULL, result); | |
| 977 } | |
| 978 | |
| 979 bool HostNPScriptObject::LocalizeStringWithSubstitution( | |
| 980 NPObject* localize_func, | |
| 981 const char* tag, | |
| 982 const char* substitution, | |
| 983 base::string16* result) { | |
| 984 int argc = substitution ? 2 : 1; | |
| 985 scoped_ptr<NPVariant[]> args(new NPVariant[argc]); | |
| 986 STRINGZ_TO_NPVARIANT(tag, args[0]); | |
| 987 if (substitution) { | |
| 988 STRINGZ_TO_NPVARIANT(substitution, args[1]); | |
| 989 } | |
| 990 NPVariant np_result; | |
| 991 bool is_good = g_npnetscape_funcs->invokeDefault( | |
| 992 plugin_, localize_func, args.get(), argc, &np_result); | |
| 993 if (!is_good) { | |
| 994 LOG(ERROR) << "Localization failed for " << tag; | |
| 995 return false; | |
| 996 } | |
| 997 std::string translation = StringFromNPVariant(np_result); | |
| 998 g_npnetscape_funcs->releasevariantvalue(&np_result); | |
| 999 if (translation.empty()) { | |
| 1000 LOG(ERROR) << "Missing translation for " << tag; | |
| 1001 return false; | |
| 1002 } | |
| 1003 *result = base::UTF8ToUTF16(translation); | |
| 1004 return true; | |
| 1005 } | |
| 1006 | |
| 1007 // static | |
| 1008 void HostNPScriptObject::DoGenerateKeyPair( | |
| 1009 const scoped_refptr<AutoThreadTaskRunner>& plugin_task_runner, | |
| 1010 const base::Callback<void (const std::string&, | |
| 1011 const std::string&)>& callback) { | |
| 1012 scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::Generate(); | |
| 1013 plugin_task_runner->PostTask(FROM_HERE, | |
| 1014 base::Bind(callback, key_pair->ToString(), | |
| 1015 key_pair->GetPublicKey())); | |
| 1016 } | |
| 1017 | |
| 1018 void HostNPScriptObject::InvokeGenerateKeyPairCallback( | |
| 1019 scoped_ptr<ScopedRefNPObject> callback, | |
| 1020 const std::string& private_key, | |
| 1021 const std::string& public_key) { | |
| 1022 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 1023 | |
| 1024 NPVariant params[2]; | |
| 1025 params[0] = NPVariantFromString(private_key); | |
| 1026 params[1] = NPVariantFromString(public_key); | |
| 1027 InvokeAndIgnoreResult(*callback, params, arraysize(params)); | |
| 1028 g_npnetscape_funcs->releasevariantvalue(&(params[0])); | |
| 1029 g_npnetscape_funcs->releasevariantvalue(&(params[1])); | |
| 1030 } | |
| 1031 | |
| 1032 void HostNPScriptObject::InvokeAsyncResultCallback( | |
| 1033 scoped_ptr<ScopedRefNPObject> callback, | |
| 1034 DaemonController::AsyncResult result) { | |
| 1035 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 1036 | |
| 1037 NPVariant result_var; | |
| 1038 INT32_TO_NPVARIANT(static_cast<int32>(result), result_var); | |
| 1039 InvokeAndIgnoreResult(*callback, &result_var, 1); | |
| 1040 g_npnetscape_funcs->releasevariantvalue(&result_var); | |
| 1041 } | |
| 1042 | |
| 1043 void HostNPScriptObject::InvokeBooleanCallback( | |
| 1044 scoped_ptr<ScopedRefNPObject> callback, bool result) { | |
| 1045 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 1046 | |
| 1047 NPVariant result_var; | |
| 1048 BOOLEAN_TO_NPVARIANT(result, result_var); | |
| 1049 InvokeAndIgnoreResult(*callback, &result_var, 1); | |
| 1050 g_npnetscape_funcs->releasevariantvalue(&result_var); | |
| 1051 } | |
| 1052 | |
| 1053 void HostNPScriptObject::InvokeGetDaemonConfigCallback( | |
| 1054 scoped_ptr<ScopedRefNPObject> callback, | |
| 1055 scoped_ptr<base::DictionaryValue> config) { | |
| 1056 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 1057 | |
| 1058 // There is no easy way to create a dictionary from an NPAPI plugin | |
| 1059 // so we have to serialize the dictionary to pass it to JavaScript. | |
| 1060 std::string config_str; | |
| 1061 if (config.get()) | |
| 1062 base::JSONWriter::Write(config.get(), &config_str); | |
| 1063 | |
| 1064 NPVariant config_val = NPVariantFromString(config_str); | |
| 1065 InvokeAndIgnoreResult(*callback, &config_val, 1); | |
| 1066 g_npnetscape_funcs->releasevariantvalue(&config_val); | |
| 1067 } | |
| 1068 | |
| 1069 void HostNPScriptObject::InvokeGetDaemonVersionCallback( | |
| 1070 scoped_ptr<ScopedRefNPObject> callback, const std::string& version) { | |
| 1071 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 1072 | |
| 1073 NPVariant version_val = NPVariantFromString(version); | |
| 1074 InvokeAndIgnoreResult(*callback, &version_val, 1); | |
| 1075 g_npnetscape_funcs->releasevariantvalue(&version_val); | |
| 1076 } | |
| 1077 | |
| 1078 void HostNPScriptObject::InvokeGetPairedClientsCallback( | |
| 1079 scoped_ptr<ScopedRefNPObject> callback, | |
| 1080 scoped_ptr<base::ListValue> paired_clients) { | |
| 1081 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 1082 | |
| 1083 std::string paired_clients_json; | |
| 1084 base::JSONWriter::Write(paired_clients.get(), &paired_clients_json); | |
| 1085 | |
| 1086 NPVariant paired_clients_val = NPVariantFromString(paired_clients_json); | |
| 1087 InvokeAndIgnoreResult(*callback, &paired_clients_val, 1); | |
| 1088 g_npnetscape_funcs->releasevariantvalue(&paired_clients_val); | |
| 1089 } | |
| 1090 | |
| 1091 void HostNPScriptObject::InvokeGetUsageStatsConsentCallback( | |
| 1092 scoped_ptr<ScopedRefNPObject> callback, | |
| 1093 const DaemonController::UsageStatsConsent& consent) { | |
| 1094 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 1095 | |
| 1096 NPVariant params[3]; | |
| 1097 BOOLEAN_TO_NPVARIANT(consent.supported, params[0]); | |
| 1098 BOOLEAN_TO_NPVARIANT(consent.allowed, params[1]); | |
| 1099 BOOLEAN_TO_NPVARIANT(consent.set_by_policy, params[2]); | |
| 1100 InvokeAndIgnoreResult(*callback, params, arraysize(params)); | |
| 1101 g_npnetscape_funcs->releasevariantvalue(&(params[0])); | |
| 1102 g_npnetscape_funcs->releasevariantvalue(&(params[1])); | |
| 1103 g_npnetscape_funcs->releasevariantvalue(&(params[2])); | |
| 1104 } | |
| 1105 | |
| 1106 void HostNPScriptObject::LogDebugInfo(const std::string& message) { | |
| 1107 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 1108 | |
| 1109 if (log_debug_info_func_.get()) { | |
| 1110 am_currently_logging_ = true; | |
| 1111 NPVariant log_message; | |
| 1112 STRINGZ_TO_NPVARIANT(message.c_str(), log_message); | |
| 1113 bool is_good = InvokeAndIgnoreResult(log_debug_info_func_, | |
| 1114 &log_message, 1); | |
| 1115 if (!is_good) { | |
| 1116 LOG(ERROR) << "ERROR - LogDebugInfo failed\n"; | |
| 1117 } | |
| 1118 am_currently_logging_ = false; | |
| 1119 } | |
| 1120 } | |
| 1121 | |
| 1122 bool HostNPScriptObject::InvokeAndIgnoreResult(const ScopedRefNPObject& func, | |
| 1123 const NPVariant* args, | |
| 1124 uint32_t arg_count) { | |
| 1125 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 1126 | |
| 1127 NPVariant np_result; | |
| 1128 bool is_good = g_npnetscape_funcs->invokeDefault(plugin_, func.get(), args, | |
| 1129 arg_count, &np_result); | |
| 1130 if (is_good) | |
| 1131 g_npnetscape_funcs->releasevariantvalue(&np_result); | |
| 1132 | |
| 1133 return is_good; | |
| 1134 } | |
| 1135 | |
| 1136 void HostNPScriptObject::SetException(const std::string& exception_string) { | |
| 1137 DCHECK(plugin_task_runner_->BelongsToCurrentThread()); | |
| 1138 | |
| 1139 g_npnetscape_funcs->setexception(parent_, exception_string.c_str()); | |
| 1140 HOST_LOG << exception_string; | |
| 1141 } | |
| 1142 | |
| 1143 } // namespace remoting | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 342583002:
Remove NPAPI plugin from chromoting webapp. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src