// 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.
#ifndef REMOTING_HOST_PLUGIN_HOST_SCRIPT_OBJECT_H_
#define REMOTING_HOST_PLUGIN_HOST_SCRIPT_OBJECT_H_
#include <string>
#include <vector>
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/thread_task_runner_handle.h"
#include "base/time/time.h"
#include "remoting/base/auto_thread_task_runner.h"
#include "remoting/host/it2me/it2me_host.h"
#include "remoting/host/plugin/host_plugin_utils.h"
#include "remoting/host/setup/daemon_controller.h"
#include "remoting/jingle_glue/xmpp_signal_strategy.h"
#include "remoting/protocol/pairing_registry.h"
namespace remoting {
// NPAPI plugin implementation for remoting host script object.
// HostNPScriptObject creates threads that are required to run
// ChromotingHost and starts/stops the host on those threads. When
// destroyed it synchronously shuts down the host and all threads.
class HostNPScriptObject : public It2MeHost::Observer {
public:
HostNPScriptObject(NPP plugin,
NPObject* parent,
scoped_refptr<AutoThreadTaskRunner> plugin_task_runner);
virtual ~HostNPScriptObject();
// Implementations used to implement the NPObject interface.
bool HasMethod(const std::string& method_name);
bool InvokeDefault(const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
bool Invoke(const std::string& method_name,
const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
bool HasProperty(const std::string& property_name);
bool GetProperty(const std::string& property_name, NPVariant* result);
bool SetProperty(const std::string& property_name, const NPVariant* value);
bool RemoveProperty(const std::string& property_name);
bool Enumerate(std::vector<std::string>* values);
// Post LogDebugInfo to the correct proxy (and thus, on the correct thread).
// This should only be called by HostLogHandler. To log to the UI, use the
// standard HOST_LOG and it will be sent to this method.
void PostLogDebugInfo(const std::string& message);
void SetWindow(NPWindow* np_window);
private:
//////////////////////////////////////////////////////////
// Plugin methods for It2Me host.
// Start connection. args are:
// string uid, string auth_token
// No result.
bool Connect(const NPVariant* args, uint32_t arg_count, NPVariant* result);
// Disconnect. No arguments or result.
bool Disconnect(const NPVariant* args, uint32_t arg_count, NPVariant* result);
// Localize strings. args are:
// localize_func - a callback function which returns a localized string for
// a given tag name.
// No result.
bool Localize(const NPVariant* args, uint32_t arg_count, NPVariant* result);
//////////////////////////////////////////////////////////
// Plugin methods for Me2Me host.
// Deletes all paired clients from the registry.
bool ClearPairedClients(const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
// Deletes a paired client referenced by client id.
bool DeletePairedClient(const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
// Fetches the host name, passing it to the supplied callback. Args are:
// function(string) callback
// Returns false if the parameters are invalid.
bool GetHostName(const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
// Calculates PIN hash value to be stored in the config. Args are:
// string hostId Host ID.
// string pin The PIN.
// function(string) callback
// Passes the resulting hash value base64-encoded to the callback.
// Returns false if the parameters are invalid.
bool GetPinHash(const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
// Generates new key pair to use for the host. The specified
// callback is called when when the key is generated. The key is
// returned in format understood by the host (PublicKeyInfo
// structure encoded with ASN.1 DER, and then BASE64). Args are:
// function(string) callback The callback to be called when done.
bool GenerateKeyPair(const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
// Update host config for Me2Me. Args are:
// string config
// function(number) done_callback
bool UpdateDaemonConfig(const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
// Loads daemon config. The first argument specifies the callback to be
// called once the config has been loaded. The config is passed as a JSON
// formatted string. Args are:
// function(string) callback
bool GetDaemonConfig(const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
// Retrieves daemon version. The first argument specifies the callback to be
// called with the obtained version. The version is passed as a dotted
// version string, described in daemon_controller.h.
bool GetDaemonVersion(const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
// Retrieves the list of paired clients as a JSON-encoded string.
bool GetPairedClients(const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
// Retrieves the user's consent to report crash dumps. The first argument
// specifies the callback to be called with the recorder consent. Possible
// consent codes are defined in remoting/host/breakpad.h.
bool GetUsageStatsConsent(const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
// Start the daemon process with the specified config. Args are:
// string config
// function(number) done_callback
bool StartDaemon(const NPVariant* args,
uint32_t arg_count,
NPVariant* result);
// Stop the daemon process. Args are:
// function(number) done_callback
bool StopDaemon(const NPVariant* args, uint32_t arg_count, NPVariant* result);
//////////////////////////////////////////////////////////
// Implementation of It2MeHost::Observer methods.
// Notifies OnStateChanged handler of a state change.
virtual void OnStateChanged(It2MeHostState state) OVERRIDE;
// If the web-app has registered a callback to be notified of changes to the
// NAT traversal policy, notify it.
virtual void OnNatPolicyChanged(bool nat_traversal_enabled) OVERRIDE;
// Stores the Access Code for the web-app to query.
virtual void OnStoreAccessCode(const std::string& access_code,
base::TimeDelta access_code_lifetime) OVERRIDE;
// Stores the client user's name for the web-app to query.
virtual void OnClientAuthenticated(
const std::string& client_username) OVERRIDE;
// Used to generate localized strings to pass to the It2Me host core.
void LocalizeStrings(NPObject* localize_func);
// Helper function for executing InvokeDefault on an NPObject that performs
// a string->string mapping without substitution. Stores the translation in
// |result| and returns true on success, or leaves it unchanged and returns
// false on failure.
bool LocalizeString(NPObject* localize_func, const char* tag,
base::string16* result);
// Helper function for executing InvokeDefault on an NPObject that performs
// a string->string mapping with one substitution. Stores the translation in
// |result| and returns true on success, or leaves it unchanged and returns
// false on failure.
bool LocalizeStringWithSubstitution(NPObject* localize_func,
const char* tag,
const char* substitution,
base::string16* result);
//////////////////////////////////////////////////////////
// Helper methods for Me2Me host.
// Helpers for GenerateKeyPair().
static void DoGenerateKeyPair(
const scoped_refptr<AutoThreadTaskRunner>& plugin_task_runner,
const base::Callback<void (const std::string&,
const std::string&)>& callback);
void InvokeGenerateKeyPairCallback(scoped_ptr<ScopedRefNPObject> callback,
const std::string& private_key,
const std::string& public_key);
// Callback handler for SetConfigAndStart(), Stop(), SetPin() and
// SetUsageStatsConsent() in DaemonController.
void InvokeAsyncResultCallback(scoped_ptr<ScopedRefNPObject> callback,
DaemonController::AsyncResult result);
// Callback handler for PairingRegistry methods that return a boolean
// success status.
void InvokeBooleanCallback(scoped_ptr<ScopedRefNPObject> callback,
bool result);
// Callback handler for DaemonController::GetConfig().
void InvokeGetDaemonConfigCallback(scoped_ptr<ScopedRefNPObject> callback,
scoped_ptr<base::DictionaryValue> config);
// Callback handler for DaemonController::GetVersion().
void InvokeGetDaemonVersionCallback(scoped_ptr<ScopedRefNPObject> callback,
const std::string& version);
// Callback handler for GetPairedClients().
void InvokeGetPairedClientsCallback(
scoped_ptr<ScopedRefNPObject> callback,
scoped_ptr<base::ListValue> paired_clients);
// Callback handler for DaemonController::GetUsageStatsConsent().
void InvokeGetUsageStatsConsentCallback(
scoped_ptr<ScopedRefNPObject> callback,
const DaemonController::UsageStatsConsent& consent);
//////////////////////////////////////////////////////////
// Basic helper methods used for both It2Me and Me2me.
// Call LogDebugInfo handler if there is one.
// This must be called on the correct thread.
void LogDebugInfo(const std::string& message);
// Helper function for executing InvokeDefault on an NPObject, and ignoring
// the return value.
bool InvokeAndIgnoreResult(const ScopedRefNPObject& func,
const NPVariant* args,
uint32_t arg_count);
// Set an exception for the current call.
void SetException(const std::string& exception_string);
//////////////////////////////////////////////////////////
// Plugin state variables shared between It2Me and Me2Me.
NPP plugin_;
NPObject* parent_;
scoped_refptr<AutoThreadTaskRunner> plugin_task_runner_;
scoped_ptr<base::ThreadTaskRunnerHandle> plugin_task_runner_handle_;
// True if we're in the middle of handling a log message.
bool am_currently_logging_;
ScopedRefNPObject log_debug_info_func_;
//////////////////////////////////////////////////////////
// It2Me host state.
// Internal implementation of the It2Me host function.
scoped_ptr<ChromotingHostContext> host_context_;
scoped_refptr<It2MeHost> it2me_host_;
// Cached, read-only copies of |it2me_host_| session state.
It2MeHostState state_;
std::string access_code_;
base::TimeDelta access_code_lifetime_;
std::string client_username_;
// IT2Me Talk server configuration used by |it2me_host_| to connect.
XmppSignalStrategy::XmppServerConfig xmpp_server_config_;
// Chromoting Bot JID used by |it2me_host_| to register the host.
std::string directory_bot_jid_;
// Callbacks to notify in response to |it2me_host_| events.
ScopedRefNPObject on_nat_traversal_policy_changed_func_;
ScopedRefNPObject on_state_changed_func_;
//////////////////////////////////////////////////////////
// Me2Me host state.
// Platform-specific installation & configuration implementation.
scoped_refptr<DaemonController> daemon_controller_;
// TODO(sergeyu): Replace this thread with
// SequencedWorkerPool. Problem is that SequencedWorkerPool relies
// on MessageLoopProxy::current().
scoped_refptr<AutoThreadTaskRunner> worker_thread_;
// Used to load and update the paired clients for this host.
scoped_refptr<protocol::PairingRegistry> pairing_registry_;
//////////////////////////////////////////////////////////
// Plugin state used for both Ir2Me and Me2Me.
// Used to cancel pending tasks for this object when it is destroyed.
base::WeakPtr<HostNPScriptObject> weak_ptr_;
base::WeakPtrFactory<HostNPScriptObject> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(HostNPScriptObject);
};
} // namespace remoting
#endif // REMOTING_HOST_PLUGIN_HOST_SCRIPT_OBJECT_H_