Follow up cleanups for r222162.

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/message_loop/message_loop.h"
@@ skipping 1084 matching lines @@
   if (arg_count != 1) {
     SetException("clearPairedClients: bad number of arguments");
     return false;
   }
 
   if (!NPVARIANT_IS_OBJECT(args[0])) {
     SetException("clearPairedClients: invalid callback parameter");
     return false;
   }
 
-  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
+  scoped_ptr<ScopedRefNPObject> callback_obj(
+      new ScopedRefNPObject(ObjectFromNPVariant(args[0])));
   if (pairing_registry_) {
     pairing_registry_->ClearAllPairings(
         base::Bind(&HostNPScriptObject::InvokeBooleanCallback, weak_ptr_,
-                   callback_obj));
+                   base::Passed(&callback_obj)));
   } else {
-    InvokeBooleanCallback(callback_obj, false);
+    InvokeBooleanCallback(callback_obj.Pass(), false);
   }
 
   return true;
 }
 
 bool HostNPScriptObject::DeletePairedClient(const NPVariant* args,
                                             uint32_t arg_count,
                                             NPVariant* result) {
   if (arg_count != 2) {
     SetException("deletePairedClient: bad number of arguments");
     return false;
   }
 
   if (!NPVARIANT_IS_STRING(args[0])) {
     SetException("deletePairedClient: bad clientId parameter");
     return false;
   }
 
   if (!NPVARIANT_IS_OBJECT(args[1])) {
     SetException("deletePairedClient: invalid callback parameter");
     return false;
   }
 
   std::string client_id = StringFromNPVariant(args[0]);
-  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[1]));
+  scoped_ptr<ScopedRefNPObject> callback_obj(
+      new ScopedRefNPObject(ObjectFromNPVariant(args[1])));
   if (pairing_registry_) {
     pairing_registry_->DeletePairing(
         client_id,
         base::Bind(&HostNPScriptObject::InvokeBooleanCallback,
-                   weak_ptr_, callback_obj));
+                   weak_ptr_, base::Passed(&callback_obj)));
   } else {
-    InvokeBooleanCallback(callback_obj, false);
+    InvokeBooleanCallback(callback_obj.Pass(), false);
   }
 
   return true;
 }
 
 bool HostNPScriptObject::GetHostName(const NPVariant* args,
                                      uint32_t arg_count,
                                      NPVariant* result) {
   if (arg_count != 1) {
     SetException("getHostName: bad number of arguments");
     return false;
   }
 
   ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
   if (!callback_obj.get()) {
     SetException("getHostName: invalid callback parameter");
     return false;
   }
 
   NPVariant host_name_val = NPVariantFromString(net::GetHostName());
-  InvokeAndIgnoreResult(callback_obj.get(), &host_name_val, 1);
+  InvokeAndIgnoreResult(callback_obj, &host_name_val, 1);
   g_npnetscape_funcs->releasevariantvalue(&host_name_val);
 
   return true;
 }
 
 bool HostNPScriptObject::GetPinHash(const NPVariant* args,
                                     uint32_t arg_count,
                                     NPVariant* result) {
   if (arg_count != 3) {
     SetException("getPinHash: bad number of arguments");
@@ skipping 13 matching lines @@
   std::string pin = StringFromNPVariant(args[1]);
 
   ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[2]));
   if (!callback_obj.get()) {
     SetException("getPinHash: invalid callback parameter");
     return false;
   }
 
   NPVariant pin_hash_val = NPVariantFromString(
       remoting::MakeHostPinHash(host_id, pin));
-  InvokeAndIgnoreResult(callback_obj.get(), &pin_hash_val, 1);
+  InvokeAndIgnoreResult(callback_obj, &pin_hash_val, 1);
   g_npnetscape_funcs->releasevariantvalue(&pin_hash_val);
 
   return true;
 }
 
 bool HostNPScriptObject::GenerateKeyPair(const NPVariant* args,
                                          uint32_t arg_count,
                                          NPVariant* result) {
   if (arg_count != 1) {
     SetException("generateKeyPair: bad number of arguments");
     return false;
   }
 
-  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
-  if (!callback_obj.get()) {
+  scoped_ptr<ScopedRefNPObject> callback_obj(
+      new ScopedRefNPObject(ObjectFromNPVariant(args[0])));
+  if (!callback_obj->get()) {
     SetException("generateKeyPair: invalid callback parameter");
     return false;
   }
 
-  // TODO(wez): HostNPScriptObject needn't be touched on worker
-  // thread, so make DoGenerateKeyPair static and pass it a callback
-  // to run (crbug.com/156257).
+  base::Callback<void (const std::string&,
+                       const std::string&)> wrapped_callback =
+      base::Bind(&HostNPScriptObject::InvokeGenerateKeyPairCallback, weak_ptr_,
+                 base::Passed(&callback_obj));
   worker_thread_->PostTask(
       FROM_HERE, base::Bind(&HostNPScriptObject::DoGenerateKeyPair,
-                            base::Unretained(this), callback_obj));
+                            plugin_task_runner_, wrapped_callback));
   return true;
 }
 
 bool HostNPScriptObject::UpdateDaemonConfig(const NPVariant* args,
                                             uint32_t arg_count,
                                             NPVariant* result) {
   if (arg_count != 2) {
     SetException("updateDaemonConfig: bad number of arguments");
     return false;
   }
 
   std::string config_str = StringFromNPVariant(args[0]);
   scoped_ptr<base::Value> config(
       base::JSONReader::Read(config_str, base::JSON_ALLOW_TRAILING_COMMAS));
   if (config_str.empty() || !config.get() ||
       !config->IsType(base::Value::TYPE_DICTIONARY)) {
     SetException("updateDaemonConfig: bad config parameter");
     return false;
   }
   scoped_ptr<base::DictionaryValue> config_dict(
       reinterpret_cast<base::DictionaryValue*>(config.release()));
 
-  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[1]));
-  if (!callback_obj.get()) {
+  scoped_ptr<ScopedRefNPObject> callback_obj(
+      new ScopedRefNPObject(ObjectFromNPVariant(args[1])));
+  if (!callback_obj->get()) {
     SetException("updateDaemonConfig: invalid callback parameter");
     return false;
   }
 
   if (config_dict->HasKey(kHostIdConfigPath) ||
       config_dict->HasKey(kXmppLoginConfigPath)) {
     SetException("updateDaemonConfig: trying to update immutable config "
                  "parameters");
     return false;
   }
 
   daemon_controller_->UpdateConfig(
       config_dict.Pass(),
-      base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback,
-                 base::Unretained(this), callback_obj));
+      base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback, weak_ptr_,
+                 base::Passed(&callback_obj)));
   return true;
 }
 
 bool HostNPScriptObject::GetDaemonConfig(const NPVariant* args,
                                          uint32_t arg_count,
                                          NPVariant* result) {
   if (arg_count != 1) {
     SetException("getDaemonConfig: bad number of arguments");
     return false;
   }
 
-  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
-  if (!callback_obj.get()) {
+  scoped_ptr<ScopedRefNPObject> callback_obj(
+      new ScopedRefNPObject(ObjectFromNPVariant(args[0])));
+  if (!callback_obj->get()) {
     SetException("getDaemonConfig: invalid callback parameter");
     return false;
   }
 
   daemon_controller_->GetConfig(
-      base::Bind(&HostNPScriptObject::InvokeGetDaemonConfigCallback,
-                 base::Unretained(this), callback_obj));
-
+      base::Bind(&HostNPScriptObject::InvokeGetDaemonConfigCallback, weak_ptr_,
+                 base::Passed(&callback_obj)));
   return true;
 }
 
 bool HostNPScriptObject::GetDaemonVersion(const NPVariant* args,
                                           uint32_t arg_count,
                                           NPVariant* result) {
   if (arg_count != 1) {
     SetException("getDaemonVersion: bad number of arguments");
     return false;
   }
 
-  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
-  if (!callback_obj.get()) {
+  scoped_ptr<ScopedRefNPObject> callback_obj(
+      new ScopedRefNPObject(ObjectFromNPVariant(args[0])));
+  if (!callback_obj->get()) {
     SetException("getDaemonVersion: invalid callback parameter");
     return false;
   }
 
   daemon_controller_->GetVersion(
-      base::Bind(&HostNPScriptObject::InvokeGetDaemonVersionCallback,
-                 base::Unretained(this), callback_obj));
+      base::Bind(&HostNPScriptObject::InvokeGetDaemonVersionCallback, weak_ptr_,
+                 base::Passed(&callback_obj)));
 
   return true;
 }
 
 bool HostNPScriptObject::GetPairedClients(const NPVariant* args,
                                           uint32_t arg_count,
                                           NPVariant* result) {
   if (arg_count != 1) {
     SetException("getPairedClients: bad number of arguments");
     return false;
   }
 
-  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
-  if (!callback_obj.get()) {
+  scoped_ptr<ScopedRefNPObject> callback_obj(
+      new ScopedRefNPObject(ObjectFromNPVariant(args[0])));
+  if (!callback_obj->get()) {
     SetException("getPairedClients: invalid callback parameter");
     return false;
   }
 
   if (pairing_registry_) {
     pairing_registry_->GetAllPairings(
         base::Bind(&HostNPScriptObject::InvokeGetPairedClientsCallback,
-                   weak_ptr_, callback_obj));
+                   weak_ptr_, base::Passed(&callback_obj)));
   } else {
     scoped_ptr<base::ListValue> no_paired_clients(new base::ListValue);
-    InvokeGetPairedClientsCallback(callback_obj, no_paired_clients.Pass());
+    InvokeGetPairedClientsCallback(callback_obj.Pass(),
+                                   no_paired_clients.Pass());
   }
   return true;
 }
 
 bool HostNPScriptObject::GetUsageStatsConsent(const NPVariant* args,
                                               uint32_t arg_count,
                                               NPVariant* result) {
   if (arg_count != 1) {
     SetException("getUsageStatsConsent: bad number of arguments");
     return false;
   }
 
-  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
-  if (!callback_obj.get()) {
+  scoped_ptr<ScopedRefNPObject> callback_obj(
+      new ScopedRefNPObject(ObjectFromNPVariant(args[0])));
+  if (!callback_obj->get()) {
     SetException("getUsageStatsConsent: invalid callback parameter");
     return false;
   }
 
   daemon_controller_->GetUsageStatsConsent(
       base::Bind(&HostNPScriptObject::InvokeGetUsageStatsConsentCallback,
-                 base::Unretained(this), callback_obj));
+                 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;
   }
 
   std::string config_str = StringFromNPVariant(args[0]);
   scoped_ptr<base::Value> config(
       base::JSONReader::Read(config_str, base::JSON_ALLOW_TRAILING_COMMAS));
   if (config_str.empty() || !config.get() ||
       !config->IsType(base::Value::TYPE_DICTIONARY)) {
     SetException("startDaemon: bad config parameter");
     return false;
   }
   scoped_ptr<base::DictionaryValue> config_dict(
       reinterpret_cast<base::DictionaryValue*>(config.release()));
 
   if (!NPVARIANT_IS_BOOLEAN(args[1])) {
     SetException("startDaemon: invalid consent parameter");
     return false;
   }
 
-  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[2]));
-  if (!callback_obj.get()) {
+  scoped_ptr<ScopedRefNPObject> callback_obj(
+      new ScopedRefNPObject(ObjectFromNPVariant(args[2])));
+  if (!callback_obj->get()) {
     SetException("startDaemon: invalid callback parameter");
     return false;
   }
 
   daemon_controller_->SetConfigAndStart(
       config_dict.Pass(),
       NPVARIANT_TO_BOOLEAN(args[1]),
-      base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback,
-                 base::Unretained(this), callback_obj));
+      base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback, weak_ptr_,
+                 base::Passed(&callback_obj)));
   return true;
 }
 
 bool HostNPScriptObject::StopDaemon(const NPVariant* args,
                                     uint32_t arg_count,
                                     NPVariant* result) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   if (arg_count != 1) {
     SetException("stopDaemon: bad number of arguments");
     return false;
   }
 
-  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
-  if (!callback_obj.get()) {
+  scoped_ptr<ScopedRefNPObject> callback_obj(
+      new ScopedRefNPObject(ObjectFromNPVariant(args[0])));
+  if (!callback_obj->get()) {
     SetException("stopDaemon: invalid callback parameter");
     return false;
   }
 
   daemon_controller_->Stop(
-      base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback,
-                 base::Unretained(this), callback_obj));
+      base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback, weak_ptr_,
+                 base::Passed(&callback_obj)));
   return true;
 }
 
 void HostNPScriptObject::NotifyStateChanged(State state) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   state_ = state;
 
   if (on_state_changed_func_.get()) {
     NPVariant state_var;
     INT32_TO_NPVARIANT(state, state_var);
-    InvokeAndIgnoreResult(on_state_changed_func_.get(), &state_var, 1);
+    InvokeAndIgnoreResult(on_state_changed_func_, &state_var, 1);
   }
 }
 
 void HostNPScriptObject::NotifyNatPolicyChanged(bool nat_traversal_enabled) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   if (on_nat_traversal_policy_changed_func_.get()) {
     NPVariant policy;
     BOOLEAN_TO_NPVARIANT(nat_traversal_enabled, policy);
-    InvokeAndIgnoreResult(on_nat_traversal_policy_changed_func_.get(),
+    InvokeAndIgnoreResult(on_nat_traversal_policy_changed_func_,
                           &policy, 1);
   }
 }
 
 // Stores the Access Code for the web-app to query.
 void HostNPScriptObject::StoreAccessCode(const std::string& access_code,
                                          base::TimeDelta access_code_lifetime) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   access_code_ = access_code;
@@ skipping 67 matching lines @@
   std::string translation = StringFromNPVariant(np_result);
   g_npnetscape_funcs->releasevariantvalue(&np_result);
   if (translation.empty()) {
     LOG(ERROR) << "Missing translation for " << tag;
     return false;
   }
   *result = UTF8ToUTF16(translation);
   return true;
 }
 
-void HostNPScriptObject::DoGenerateKeyPair(const ScopedRefNPObject& callback) {
+// static
+void HostNPScriptObject::DoGenerateKeyPair(
+    const scoped_refptr<AutoThreadTaskRunner>& plugin_task_runner,
+    const base::Callback<void (const std::string&,
+                               const std::string&)>& callback) {
   scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::Generate();
-  InvokeGenerateKeyPairCallback(callback, key_pair->ToString(),
-                                key_pair->GetPublicKey());
+  plugin_task_runner->PostTask(FROM_HERE,
+                               base::Bind(callback, key_pair->ToString(),
+                                          key_pair->GetPublicKey()));
 }
 
 void HostNPScriptObject::InvokeGenerateKeyPairCallback(
-    const ScopedRefNPObject& callback,
+    scoped_ptr<ScopedRefNPObject> callback,
     const std::string& private_key,
     const std::string& public_key) {
-  if (!plugin_task_runner_->BelongsToCurrentThread()) {
-    plugin_task_runner_->PostTask(
-        FROM_HERE, base::Bind(
-            &HostNPScriptObject::InvokeGenerateKeyPairCallback,
-            weak_ptr_, callback, private_key, public_key));
-    return;
-  }
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   NPVariant params[2];
   params[0] = NPVariantFromString(private_key);
   params[1] = NPVariantFromString(public_key);
-  InvokeAndIgnoreResult(callback.get(), params, arraysize(params));
+  InvokeAndIgnoreResult(*callback, params, arraysize(params));
   g_npnetscape_funcs->releasevariantvalue(&(params[0]));
   g_npnetscape_funcs->releasevariantvalue(&(params[1]));
 }
 
 void HostNPScriptObject::InvokeAsyncResultCallback(
-    const ScopedRefNPObject& callback,
+    scoped_ptr<ScopedRefNPObject> callback,
     DaemonController::AsyncResult result) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   NPVariant result_var;
   INT32_TO_NPVARIANT(static_cast<int32>(result), result_var);
-  InvokeAndIgnoreResult(callback.get(), &result_var, 1);
+  InvokeAndIgnoreResult(*callback, &result_var, 1);
   g_npnetscape_funcs->releasevariantvalue(&result_var);
 }
 
 void HostNPScriptObject::InvokeBooleanCallback(
-    const ScopedRefNPObject& callback, bool result) {
-  if (!plugin_task_runner_->BelongsToCurrentThread()) {
-    plugin_task_runner_->PostTask(
-        FROM_HERE, base::Bind(
-            &HostNPScriptObject::InvokeBooleanCallback,
-            weak_ptr_, callback, result));
-    return;
-  }
+    scoped_ptr<ScopedRefNPObject> callback, bool result) {
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   NPVariant result_var;
   BOOLEAN_TO_NPVARIANT(result, result_var);
-  InvokeAndIgnoreResult(callback.get(), &result_var, 1);
+  InvokeAndIgnoreResult(*callback, &result_var, 1);
   g_npnetscape_funcs->releasevariantvalue(&result_var);
 }
 
 void HostNPScriptObject::InvokeGetDaemonConfigCallback(
-    const ScopedRefNPObject& callback,
+    scoped_ptr<ScopedRefNPObject> callback,
     scoped_ptr<base::DictionaryValue> config) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   // There is no easy way to create a dictionary from an NPAPI plugin
   // so we have to serialize the dictionary to pass it to JavaScript.
   std::string config_str;
   if (config.get())
     base::JSONWriter::Write(config.get(), &config_str);
 
   NPVariant config_val = NPVariantFromString(config_str);
-  InvokeAndIgnoreResult(callback.get(), &config_val, 1);
+  InvokeAndIgnoreResult(*callback, &config_val, 1);
   g_npnetscape_funcs->releasevariantvalue(&config_val);
 }
 
 void HostNPScriptObject::InvokeGetDaemonVersionCallback(
-    const ScopedRefNPObject& callback, const std::string& version) {
+    scoped_ptr<ScopedRefNPObject> callback, const std::string& version) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   NPVariant version_val = NPVariantFromString(version);
-  InvokeAndIgnoreResult(callback.get(), &version_val, 1);
+  InvokeAndIgnoreResult(*callback, &version_val, 1);
   g_npnetscape_funcs->releasevariantvalue(&version_val);
 }
 
 void HostNPScriptObject::InvokeGetPairedClientsCallback(
-    const ScopedRefNPObject& callback,
+    scoped_ptr<ScopedRefNPObject> callback,
     scoped_ptr<base::ListValue> paired_clients) {
-  if (!plugin_task_runner_->BelongsToCurrentThread()) {
-    plugin_task_runner_->PostTask(
-        FROM_HERE, base::Bind(
-            &HostNPScriptObject::InvokeGetPairedClientsCallback,
-            weak_ptr_, callback, base::Passed(&paired_clients)));
-    return;
-  }
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   std::string paired_clients_json;
   base::JSONWriter::Write(paired_clients.get(), &paired_clients_json);
 
   NPVariant paired_clients_val = NPVariantFromString(paired_clients_json);
-  InvokeAndIgnoreResult(callback.get(), &paired_clients_val, 1);
+  InvokeAndIgnoreResult(*callback, &paired_clients_val, 1);
   g_npnetscape_funcs->releasevariantvalue(&paired_clients_val);
 }
 
 void HostNPScriptObject::InvokeGetUsageStatsConsentCallback(
-    const ScopedRefNPObject& callback,
+    scoped_ptr<ScopedRefNPObject> callback,
     const DaemonController::UsageStatsConsent& consent) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   NPVariant params[3];
   BOOLEAN_TO_NPVARIANT(consent.supported, params[0]);
   BOOLEAN_TO_NPVARIANT(consent.allowed, params[1]);
   BOOLEAN_TO_NPVARIANT(consent.set_by_policy, params[2]);
-  InvokeAndIgnoreResult(callback.get(), params, arraysize(params));
+  InvokeAndIgnoreResult(*callback, params, arraysize(params));
   g_npnetscape_funcs->releasevariantvalue(&(params[0]));
   g_npnetscape_funcs->releasevariantvalue(&(params[1]));
   g_npnetscape_funcs->releasevariantvalue(&(params[2]));
 }
 
 void HostNPScriptObject::LogDebugInfo(const std::string& message) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   if (log_debug_info_func_.get()) {
     am_currently_logging_ = true;
     NPVariant log_message;
     STRINGZ_TO_NPVARIANT(message.c_str(), log_message);
-    bool is_good = InvokeAndIgnoreResult(log_debug_info_func_.get(),
+    bool is_good = InvokeAndIgnoreResult(log_debug_info_func_,
                                          &log_message, 1);
     if (!is_good) {
       LOG(ERROR) << "ERROR - LogDebugInfo failed\n";
     }
     am_currently_logging_ = false;
   }
 }
 
-bool HostNPScriptObject::InvokeAndIgnoreResult(NPObject* func,
+bool HostNPScriptObject::InvokeAndIgnoreResult(const ScopedRefNPObject& func,
                                                const NPVariant* args,
                                                uint32_t arg_count) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   NPVariant np_result;
-  bool is_good = g_npnetscape_funcs->invokeDefault(plugin_, func, args,
+  bool is_good = g_npnetscape_funcs->invokeDefault(plugin_, func.get(), args,
                                                    arg_count, &np_result);
   if (is_good)
       g_npnetscape_funcs->releasevariantvalue(&np_result);
 
   return is_good;
 }
 
 void HostNPScriptObject::SetException(const std::string& exception_string) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   g_npnetscape_funcs->setexception(parent_, exception_string.c_str());
   LOG(INFO) << exception_string;
 }
 
 }  // namespace remoting