Use ScopedRefNPObject to pass NPObjects in the host 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/base64.h"
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 639 matching lines @@
 }
 
 bool HostNPScriptObject::GenerateKeyPair(const NPVariant* args,
                                          uint32_t arg_count,
                                          NPVariant* result) {
   if (arg_count != 1) {
     SetException("generateKeyPair: bad number of arguments");
     return false;
   }
 
-  NPObject* callback_obj = ObjectFromNPVariant(args[0]);
-  if (!callback_obj) {
+  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
+  if (!callback_obj.get()) {
     SetException("generateKeyPair: invalid callback parameter");
     return false;
   }
 
-  callback_obj = g_npnetscape_funcs->retainobject(callback_obj);
-
   worker_thread_.message_loop_proxy()->PostTask(
       FROM_HERE, base::Bind(&HostNPScriptObject::DoGenerateKeyPair,
                             base::Unretained(this), callback_obj));
   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, true));
   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()));
 
-  NPObject* callback_obj = ObjectFromNPVariant(args[1]);
-  if (!callback_obj) {
+  ScopedRefNPObject callback_obj(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;
   }
 
-  callback_obj = g_npnetscape_funcs->retainobject(callback_obj);
-
   daemon_controller_->UpdateConfig(
       config_dict.Pass(),
       base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback,
                  base::Unretained(this), 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;
   }
 
-  NPObject* callback_obj = ObjectFromNPVariant(args[0]);
-  if (!callback_obj) {
+  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
+  if (!callback_obj.get()) {
     SetException("getDaemonConfig: invalid callback parameter");
     return false;
   }
 
-  callback_obj = g_npnetscape_funcs->retainobject(callback_obj);
-
   // We control lifetime of the |daemon_controller_| so it's safe to
   // use base::Unretained() here.
   daemon_controller_->GetConfig(
       base::Bind(&HostNPScriptObject::InvokeGetDaemonConfigCallback,
                  base::Unretained(this), callback_obj));
 
   return true;
 }
 
 bool HostNPScriptObject::StartDaemon(const NPVariant* args,
                                      uint32_t arg_count,
                                      NPVariant* result) {
   if (arg_count != 2) {
     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, true));
   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()));
 
-  NPObject* callback_obj = ObjectFromNPVariant(args[1]);
-  if (!callback_obj) {
+  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[1]));
+  if (!callback_obj.get()) {
     SetException("startDaemon: invalid callback parameter");
     return false;
   }
 
-  callback_obj = g_npnetscape_funcs->retainobject(callback_obj);
-
   daemon_controller_->SetConfigAndStart(
       config_dict.Pass(),
       base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback,
                  base::Unretained(this), callback_obj));
   return true;
 }
 
 bool HostNPScriptObject::StopDaemon(const NPVariant* args,
                                     uint32_t arg_count,
                                     NPVariant* result) {
   if (arg_count != 1) {
     SetException("stopDaemon: bad number of arguments");
     return false;
   }
 
-  NPObject* callback_obj = ObjectFromNPVariant(args[0]);
-  if (!callback_obj) {
+  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
+  if (!callback_obj.get()) {
     SetException("stopDaemon: invalid callback parameter");
     return false;
   }
 
-  callback_obj = g_npnetscape_funcs->retainobject(callback_obj);
-
   daemon_controller_->Stop(
       base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback,
                  base::Unretained(this), callback_obj));
   return true;
 }
 
 void HostNPScriptObject::DisconnectInternal() {
   if (!host_context_->network_message_loop()->BelongsToCurrentThread()) {
     host_context_->network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&HostNPScriptObject::DisconnectInternal,
@@ skipping 229 matching lines @@
     return;
   }
   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(),
                           &policy, 1);
   }
 }
 
-void HostNPScriptObject::DoGenerateKeyPair(NPObject* callback) {
+void HostNPScriptObject::DoGenerateKeyPair(const ScopedRefNPObject& callback) {
   HostKeyPair key_pair;
   key_pair.Generate();
   InvokeGenerateKeyPairCallback(callback, key_pair.GetAsString(),
                                 key_pair.GetPublicKey());
 }
 
 void HostNPScriptObject::InvokeGenerateKeyPairCallback(
-    NPObject* callback,
+    const ScopedRefNPObject& callback,
     const std::string& private_key,
     const std::string& public_key) {
   if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
     plugin_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(
             &HostNPScriptObject::InvokeGenerateKeyPairCallback,
             base::Unretained(this), callback, private_key, public_key));
     return;
   }
 
   NPVariant params[2];
   params[0] = NPVariantFromString(private_key);
   params[1] = NPVariantFromString(public_key);
-  InvokeAndIgnoreResult(callback, params, arraysize(params));
+  InvokeAndIgnoreResult(callback.get(), params, arraysize(params));
   g_npnetscape_funcs->releasevariantvalue(&(params[0]));
   g_npnetscape_funcs->releasevariantvalue(&(params[1]));
-  g_npnetscape_funcs->releaseobject(callback);
 }
 
 void HostNPScriptObject::InvokeAsyncResultCallback(
-    NPObject* callback,
+    const ScopedRefNPObject& callback,
     DaemonController::AsyncResult result) {
   if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
     plugin_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(
             &HostNPScriptObject::InvokeAsyncResultCallback,
             base::Unretained(this), callback, result));
     return;
   }
 
   NPVariant result_var;
   INT32_TO_NPVARIANT(static_cast<int32>(result), result_var);
-  InvokeAndIgnoreResult(callback, &result_var, 1);
+  InvokeAndIgnoreResult(callback.get(), &result_var, 1);
   g_npnetscape_funcs->releasevariantvalue(&result_var);
-  g_npnetscape_funcs->releaseobject(callback);
 }
 
 void HostNPScriptObject::InvokeGetDaemonConfigCallback(
-    NPObject* callback,
+    const ScopedRefNPObject& callback,
     scoped_ptr<base::DictionaryValue> config) {
   if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
     plugin_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(
             &HostNPScriptObject::InvokeGetDaemonConfigCallback,
             base::Unretained(this), callback, base::Passed(&config)));
     return;
   }
 
   // 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, &config_val, 1);
+  InvokeAndIgnoreResult(callback.get(), &config_val, 1);
   g_npnetscape_funcs->releasevariantvalue(&config_val);
-  g_npnetscape_funcs->releaseobject(callback);
 }
 
 void HostNPScriptObject::LogDebugInfo(const std::string& message) {
   DCHECK(plugin_message_loop_proxy_->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(),
                                          &log_message, 1);
@@ skipping 16 matching lines @@
   return is_good;
 }
 
 void HostNPScriptObject::SetException(const std::string& exception_string) {
   DCHECK(plugin_message_loop_proxy_->BelongsToCurrentThread());
   g_npnetscape_funcs->setexception(parent_, exception_string.c_str());
   LOG(INFO) << exception_string;
 }
 
 }  // namespace remoting