ppapi/proxy/serialized_var_unittest.cc - chromium/src.git - Git at Google

 // 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 <stdint.h>

 #include "ppapi/proxy/ppapi_proxy_test.h"
 #include "ppapi/proxy/proxy_object_var.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/proxy_lock.h"

 namespace ppapi {
 namespace proxy {

 namespace {

 PP_Var MakeObjectVar(int64_t object_id) {
   PP_Var ret;
   ret.type = PP_VARTYPE_OBJECT;
   ret.value.as_id = object_id;
   return ret;
 }

 class SerializedVarTest : public PluginProxyTest {
  public:
   SerializedVarTest() {}
 };

 }  // namespace

 // Tests output arguments in the plugin. This is when the host calls into the
 // plugin and the plugin returns something via an out param, like an exception.
 TEST_F(SerializedVarTest, PluginSerializedVarInOutParam) {
   ProxyAutoLock lock;
   PP_Var host_object = MakeObjectVar(0x31337);

   PP_Var plugin_object;
   {
     // Receive the object param, we should be tracking it with no refcount, and
     // no messages sent.
     SerializedVarTestConstructor input(host_object);
     SerializedVarReceiveInput receive_input(input);
     plugin_object = receive_input.Get(plugin_dispatcher());
     EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_object));
     EXPECT_EQ(0u, sink().message_count());

     SerializedVar sv;
     {
       // The "OutParam" does its work in its destructor, it will write the
       // information to the SerializedVar we passed in the constructor.
       SerializedVarOutParam out_param(&sv);
       // An out-param needs to pass a reference to the caller, so it's the
       // responsibility of the plugin to bump the ref-count on an input
       // parameter.
       var_tracker().AddRefVar(plugin_object);
       EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
       // We should have informed the host that a reference was taken.
       EXPECT_EQ(1u, sink().message_count());
       *out_param.OutParam(plugin_dispatcher()) = plugin_object;
     }

     // The object should have transformed the plugin object back to the host
     // object ID. Nothing in the var tracker should have changed yet, and no
     // messages should have been sent.
     SerializedVarTestReader reader(sv);
     EXPECT_EQ(host_object.value.as_id, reader.GetVar().value.as_id);
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
     EXPECT_EQ(1u, sink().message_count());
   }

   // The out param should have done an "end receive caller owned" on the plugin
   // var serialization rules, which should have released the "track-with-no-
   // reference" count in the var tracker as well as the 1 reference we passed
   // back to the host, so the object should no longer be in the tracker. The
   // reference we added has been removed, so another message should be sent to
   // the host to tell it we're done with the object.
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
   EXPECT_EQ(2u, sink().message_count());
 }

 // Tests output strings in the plugin. This is when the host calls into the
 // plugin with a string and the plugin returns it via an out param.
 TEST_F(SerializedVarTest, PluginSerializedStringVarInOutParam) {
   ProxyAutoLock lock;
   PP_Var plugin_string;
   const std::string kTestString("elite");
   {
     // Receive the string param. We should track it with 1 refcount.
     SerializedVarTestConstructor input(kTestString);
     SerializedVarReceiveInput receive_input(input);
     plugin_string = receive_input.Get(plugin_dispatcher());
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_string));
     EXPECT_EQ(0u, sink().message_count());

     SerializedVar sv;
     {
       // The "OutParam" does its work in its destructor, it will write the
       // information to the SerializedVar we passed in the constructor.
       SerializedVarOutParam out_param(&sv);
       // An out-param needs to pass a reference to the caller, so it's the
       // responsibility of the plugin to bump the ref-count of an input
       // parameter.
       var_tracker().AddRefVar(plugin_string);
       EXPECT_EQ(2, var_tracker().GetRefCountForObject(plugin_string));
       EXPECT_EQ(0u, sink().message_count());
       *out_param.OutParam(plugin_dispatcher()) = plugin_string;
     }

     // The SerializedVar should have set the string value internally. Nothing in
     // the var tracker should have changed yet, and no messages should have been
     // sent.
     SerializedVarTestReader reader(sv);
     //EXPECT_EQ(kTestString, *reader.GetTrackerStringPtr());
     EXPECT_EQ(2, var_tracker().GetRefCountForObject(plugin_string));
     EXPECT_EQ(0u, sink().message_count());
   }
   // The reference the string had initially should be gone, and the reference we
   // passed to the host should also be gone, so the string should be removed.
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_string));
   EXPECT_EQ(0u, sink().message_count());
 }

 // Tests receiving an argument and passing it back to the browser as an output
 // parameter.
 TEST_F(SerializedVarTest, PluginSerializedVarOutParam) {
   ProxyAutoLock lock;
   PP_Var host_object = MakeObjectVar(0x31337);

   // Start tracking this object in the plugin.
   PP_Var plugin_object = var_tracker().ReceiveObjectPassRef(
       host_object, plugin_dispatcher());
   EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));

   {
     SerializedVar sv;
     {
       // The "OutParam" does its work in its destructor, it will write the
       // information to the SerializedVar we passed in the constructor.
       SerializedVarOutParam out_param(&sv);
       *out_param.OutParam(plugin_dispatcher()) = plugin_object;
     }

     // The object should have transformed the plugin object back to the host
     // object ID. Nothing in the var tracker should have changed yet, and no
     // messages should have been sent.
     SerializedVarTestReader reader(sv);
     EXPECT_EQ(host_object.value.as_id, reader.GetVar().value.as_id);
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
     EXPECT_EQ(0u, sink().message_count());
   }

   // The out param should have done an "end send pass ref" on the plugin
   // var serialization rules, which should have in turn released the reference
   // in the var tracker. Since we only had one reference, this should have sent
   // a release to the browser.
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
   EXPECT_EQ(1u, sink().message_count());

   // We don't bother validating that message since it's nontrivial and the
   // PluginVarTracker test has cases that cover that this message is correct.
 }

 // Tests the case that the plugin receives the same var twice as an input
 // parameter (not passing ownership).
 TEST_F(SerializedVarTest, PluginReceiveInput) {
   ProxyAutoLock lock;
   PP_Var host_object = MakeObjectVar(0x31337);

   PP_Var plugin_object;
   {
     // Receive the first param, we should be tracking it with no refcount, and
     // no messages sent.
     SerializedVarTestConstructor input1(host_object);
     SerializedVarReceiveInput receive_input(input1);
     plugin_object = receive_input.Get(plugin_dispatcher());
     EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_object));
     EXPECT_EQ(0u, sink().message_count());

     // Receive the second param, it should be resolved to the same plugin
     // object and there should still be no refcount.
     SerializedVarTestConstructor input2(host_object);
     SerializedVarReceiveInput receive_input2(input2);
     PP_Var plugin_object2 = receive_input2.Get(plugin_dispatcher());
     EXPECT_EQ(plugin_object.value.as_id, plugin_object2.value.as_id);
     EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_object));
     EXPECT_EQ(0u, sink().message_count());

     // Take a reference to the object, as if the plugin was using it, and then
     // release it, we should still be tracking the object since the
     // ReceiveInputs keep the "track_with_no_reference_count" alive until
     // they're destroyed.
     var_tracker().AddRefVar(plugin_object);
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
     var_tracker().ReleaseVar(plugin_object);
     EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_object));
     EXPECT_EQ(2u, sink().message_count());
   }

   // Since we didn't keep any refs to the objects, it should have freed the
   // object.
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
 }

 // Tests the case that the plugin receives the same vars twice as an input
 // parameter (not passing ownership) within a vector.
 TEST_F(SerializedVarTest, PluginVectorReceiveInput) {
   ProxyAutoLock lock;
   PP_Var host_object = MakeObjectVar(0x31337);

   std::vector<PP_Var> plugin_objects;
   std::vector<PP_Var> plugin_objects2;
   {
     // Receive the params. The object should be tracked with no refcount and
     // no messages sent. The string should is plugin-side only and should have
     // a reference-count of 1.
     std::vector<SerializedVar> input1;
     input1.push_back(SerializedVarTestConstructor(host_object));
     input1.push_back(SerializedVarTestConstructor("elite"));
     SerializedVarVectorReceiveInput receive_input(input1);
     uint32_t array_size = 0;
     PP_Var* plugin_objects_array =
         receive_input.Get(plugin_dispatcher(), &array_size);
     plugin_objects.insert(plugin_objects.begin(), plugin_objects_array,
                           plugin_objects_array + array_size);
     ASSERT_EQ(2u, array_size);
     EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_objects[0]));
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_objects[1]));
     EXPECT_EQ(0u, sink().message_count());

     // Receive the second param, it should be resolved to the same plugin
     // object and there should still be no refcount.
     std::vector<SerializedVar> input2;
     input2.push_back(SerializedVarTestConstructor(host_object));
     input2.push_back(SerializedVarTestConstructor("elite"));
     SerializedVarVectorReceiveInput receive_input2(input2);
     uint32_t array_size2 = 0;
     PP_Var* plugin_objects_array2 =
         receive_input2.Get(plugin_dispatcher(), &array_size2);
     plugin_objects2.insert(plugin_objects2.begin(), plugin_objects_array2,
                            plugin_objects_array2 + array_size2);
     ASSERT_EQ(2u, array_size2);
     EXPECT_EQ(plugin_objects[0].value.as_id, plugin_objects2[0].value.as_id);
     EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_objects[0]));
     // Strings get re-created with a new ID. We don't try to reuse strings in
     // the tracker, so the string should get a new ID.
     EXPECT_NE(plugin_objects[1].value.as_id, plugin_objects2[1].value.as_id);
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_objects2[1]));
     EXPECT_EQ(0u, sink().message_count());

     // Take a reference to the object, as if the plugin was using it, and then
     // release it, we should still be tracking the object since the
     // ReceiveInputs keep the "track_with_no_reference_count" alive until
     // they're destroyed.
     var_tracker().AddRefVar(plugin_objects[0]);
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_objects[0]));
     var_tracker().ReleaseVar(plugin_objects[0]);
     EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_objects[0]));
     EXPECT_EQ(2u, sink().message_count());

     // Take a reference to a string and then release it. Make sure no messages
     // are sent.
     uint32_t old_message_count = static_cast<uint32_t>(sink().message_count());
     var_tracker().AddRefVar(plugin_objects[1]);
     EXPECT_EQ(2, var_tracker().GetRefCountForObject(plugin_objects[1]));
     var_tracker().ReleaseVar(plugin_objects[1]);
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_objects[1]));
     EXPECT_EQ(old_message_count, sink().message_count());
   }

   // Since we didn't keep any refs to the objects or strings, so they should
   // have been freed.
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_objects[0]));
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_objects[1]));
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_objects2[1]));
 }

 // Tests the browser sending a String var as a return value to make sure we
 // ref-count the host side properly.
 typedef HostProxyTest HostSerializedVarTest;
 TEST_F(HostSerializedVarTest, PluginReceiveStringReturn) {
   {
     PP_Var string_var = StringVar::StringToPPVar("Hello");
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(string_var));
     GetDispatcher()->serialization_rules()->BeginSendPassRef(string_var);
     GetDispatcher()->serialization_rules()->EndSendPassRef(string_var);
     // It should be gone, so we should get -1 to indicate that.
     EXPECT_EQ(-1, var_tracker().GetRefCountForObject(string_var));
   }

   {
     // Note this is as little weird; we're testing the behavior of the host-
     // side of the proxy, but we use ProxyObjectVar, because this unit test
     // doesn't have access to stuff in content/renderer/pepper. The ref-counting
     // behavior should be the same, however. All we're really testing
     // is the code in ppapi/proxy (HostVarSerializationRules).
     scoped_refptr<Var> obj_var = new ProxyObjectVar(NULL, 1234);
     PP_Var obj_pp_var = obj_var->GetPPVar();
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(obj_pp_var));
     GetDispatcher()->serialization_rules()->BeginSendPassRef(obj_pp_var);
     GetDispatcher()->serialization_rules()->EndSendPassRef(obj_pp_var);
     // The host side for object vars always keeps 1 ref on behalf of the plugin.
     // See HostVarSerializationRules and PluginVarSerializationRules for an
     // explanation.
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(obj_pp_var));
     var_tracker().ReleaseVar(obj_pp_var);
   }
 }

 // Tests the plugin receiving a var as a return value from the browser
 // two different times (passing ownership).
 TEST_F(SerializedVarTest, PluginReceiveReturn) {
   ProxyAutoLock lock;
   PP_Var host_object = MakeObjectVar(0x31337);

   PP_Var plugin_object;
   {
     // Receive the first param, we should be tracking it with a refcount of 1.
     SerializedVarTestConstructor input1(host_object);
     ReceiveSerializedVarReturnValue receive_input(input1);
     plugin_object = receive_input.Return(plugin_dispatcher());
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
     EXPECT_EQ(0u, sink().message_count());

     // Receive the second param, it should be resolved to the same plugin
     // object and there should be a plugin refcount of 2. There should have
     // been an IPC message sent that released the duplicated ref in the browser
     // (so both of our refs are represented by one in the browser).
     SerializedVarTestConstructor input2(host_object);
     ReceiveSerializedVarReturnValue receive_input2(input2);
     PP_Var plugin_object2 = receive_input2.Return(plugin_dispatcher());
     EXPECT_EQ(plugin_object.value.as_id, plugin_object2.value.as_id);
     EXPECT_EQ(2, var_tracker().GetRefCountForObject(plugin_object));
     EXPECT_EQ(1u, sink().message_count());
   }

   // The ReceiveSerializedVarReturnValue destructor shouldn't have affected
   // the refcount or sent any messages.
   EXPECT_EQ(2, var_tracker().GetRefCountForObject(plugin_object));
   EXPECT_EQ(1u, sink().message_count());

   // Manually release one refcount, it shouldn't have sent any more messages.
   var_tracker().ReleaseVar(plugin_object);
   EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
   EXPECT_EQ(1u, sink().message_count());

   // Manually release the last refcount, it should have freed it and sent a
   // release message to the browser.
   var_tracker().ReleaseVar(plugin_object);
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
   EXPECT_EQ(2u, sink().message_count());
 }

 // Returns a value from the browser to the plugin, then return that one ref
 // back to the browser.
 TEST_F(SerializedVarTest, PluginReturnValue) {
   ProxyAutoLock lock;
   PP_Var host_object = MakeObjectVar(0x31337);

   PP_Var plugin_object;
   {
     // Receive the param in the plugin.
     SerializedVarTestConstructor input1(host_object);
     ReceiveSerializedVarReturnValue receive_input(input1);
     plugin_object = receive_input.Return(plugin_dispatcher());
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
     EXPECT_EQ(0u, sink().message_count());
   }

   {
     // Now return to the browser.
     SerializedVar output;
     SerializedVarReturnValue return_output(&output);
     return_output.Return(plugin_dispatcher(), plugin_object);

     // The ref in the plugin should be alive until the ReturnValue goes out of
     // scope, since the release needs to be after the browser processes the
     // message.
     EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
   }

   // When the ReturnValue object goes out of scope, it should have sent a
   // release message to the browser.
   EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
   EXPECT_EQ(1u, sink().message_count());
 }

 }  // namespace proxy
 }  // namespace ppapi
	// 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 <stdint.h>

	#include "ppapi/proxy/ppapi_proxy_test.h"
	#include "ppapi/proxy/proxy_object_var.h"
	#include "ppapi/proxy/serialized_var.h"
	#include "ppapi/shared_impl/proxy_lock.h"

	namespace ppapi {
	namespace proxy {

	namespace {

	PP_Var MakeObjectVar(int64_t object_id) {
	PP_Var ret;
	ret.type = PP_VARTYPE_OBJECT;
	ret.value.as_id = object_id;
	return ret;
	}

	class SerializedVarTest : public PluginProxyTest {
	public:
	SerializedVarTest() {}
	};

	} // namespace

	// Tests output arguments in the plugin. This is when the host calls into the
	// plugin and the plugin returns something via an out param, like an exception.
	TEST_F(SerializedVarTest, PluginSerializedVarInOutParam) {
	ProxyAutoLock lock;
	PP_Var host_object = MakeObjectVar(0x31337);

	PP_Var plugin_object;
	{
	// Receive the object param, we should be tracking it with no refcount, and
	// no messages sent.
	SerializedVarTestConstructor input(host_object);
	SerializedVarReceiveInput receive_input(input);
	plugin_object = receive_input.Get(plugin_dispatcher());
	EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(0u, sink().message_count());

	SerializedVar sv;
	{
	// The "OutParam" does its work in its destructor, it will write the
	// information to the SerializedVar we passed in the constructor.
	SerializedVarOutParam out_param(&sv);
	// An out-param needs to pass a reference to the caller, so it's the
	// responsibility of the plugin to bump the ref-count on an input
	// parameter.
	var_tracker().AddRefVar(plugin_object);
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
	// We should have informed the host that a reference was taken.
	EXPECT_EQ(1u, sink().message_count());
	*out_param.OutParam(plugin_dispatcher()) = plugin_object;
	}

	// The object should have transformed the plugin object back to the host
	// object ID. Nothing in the var tracker should have changed yet, and no
	// messages should have been sent.
	SerializedVarTestReader reader(sv);
	EXPECT_EQ(host_object.value.as_id, reader.GetVar().value.as_id);
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(1u, sink().message_count());
	}

	// The out param should have done an "end receive caller owned" on the plugin
	// var serialization rules, which should have released the "track-with-no-
	// reference" count in the var tracker as well as the 1 reference we passed
	// back to the host, so the object should no longer be in the tracker. The
	// reference we added has been removed, so another message should be sent to
	// the host to tell it we're done with the object.
	EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(2u, sink().message_count());
	}

	// Tests output strings in the plugin. This is when the host calls into the
	// plugin with a string and the plugin returns it via an out param.
	TEST_F(SerializedVarTest, PluginSerializedStringVarInOutParam) {
	ProxyAutoLock lock;
	PP_Var plugin_string;
	const std::string kTestString("elite");
	{
	// Receive the string param. We should track it with 1 refcount.
	SerializedVarTestConstructor input(kTestString);
	SerializedVarReceiveInput receive_input(input);
	plugin_string = receive_input.Get(plugin_dispatcher());
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_string));
	EXPECT_EQ(0u, sink().message_count());

	SerializedVar sv;
	{
	// The "OutParam" does its work in its destructor, it will write the
	// information to the SerializedVar we passed in the constructor.
	SerializedVarOutParam out_param(&sv);
	// An out-param needs to pass a reference to the caller, so it's the
	// responsibility of the plugin to bump the ref-count of an input
	// parameter.
	var_tracker().AddRefVar(plugin_string);
	EXPECT_EQ(2, var_tracker().GetRefCountForObject(plugin_string));
	EXPECT_EQ(0u, sink().message_count());
	*out_param.OutParam(plugin_dispatcher()) = plugin_string;
	}

	// The SerializedVar should have set the string value internally. Nothing in
	// the var tracker should have changed yet, and no messages should have been
	// sent.
	SerializedVarTestReader reader(sv);
	//EXPECT_EQ(kTestString, *reader.GetTrackerStringPtr());
	EXPECT_EQ(2, var_tracker().GetRefCountForObject(plugin_string));
	EXPECT_EQ(0u, sink().message_count());
	}
	// The reference the string had initially should be gone, and the reference we
	// passed to the host should also be gone, so the string should be removed.
	EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_string));
	EXPECT_EQ(0u, sink().message_count());
	}

	// Tests receiving an argument and passing it back to the browser as an output
	// parameter.
	TEST_F(SerializedVarTest, PluginSerializedVarOutParam) {
	ProxyAutoLock lock;
	PP_Var host_object = MakeObjectVar(0x31337);

	// Start tracking this object in the plugin.
	PP_Var plugin_object = var_tracker().ReceiveObjectPassRef(
	host_object, plugin_dispatcher());
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));

	{
	SerializedVar sv;
	{
	// The "OutParam" does its work in its destructor, it will write the
	// information to the SerializedVar we passed in the constructor.
	SerializedVarOutParam out_param(&sv);
	*out_param.OutParam(plugin_dispatcher()) = plugin_object;
	}

	// The object should have transformed the plugin object back to the host
	// object ID. Nothing in the var tracker should have changed yet, and no
	// messages should have been sent.
	SerializedVarTestReader reader(sv);
	EXPECT_EQ(host_object.value.as_id, reader.GetVar().value.as_id);
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(0u, sink().message_count());
	}

	// The out param should have done an "end send pass ref" on the plugin
	// var serialization rules, which should have in turn released the reference
	// in the var tracker. Since we only had one reference, this should have sent
	// a release to the browser.
	EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(1u, sink().message_count());

	// We don't bother validating that message since it's nontrivial and the
	// PluginVarTracker test has cases that cover that this message is correct.
	}

	// Tests the case that the plugin receives the same var twice as an input
	// parameter (not passing ownership).
	TEST_F(SerializedVarTest, PluginReceiveInput) {
	ProxyAutoLock lock;
	PP_Var host_object = MakeObjectVar(0x31337);

	PP_Var plugin_object;
	{
	// Receive the first param, we should be tracking it with no refcount, and
	// no messages sent.
	SerializedVarTestConstructor input1(host_object);
	SerializedVarReceiveInput receive_input(input1);
	plugin_object = receive_input.Get(plugin_dispatcher());
	EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(0u, sink().message_count());

	// Receive the second param, it should be resolved to the same plugin
	// object and there should still be no refcount.
	SerializedVarTestConstructor input2(host_object);
	SerializedVarReceiveInput receive_input2(input2);
	PP_Var plugin_object2 = receive_input2.Get(plugin_dispatcher());
	EXPECT_EQ(plugin_object.value.as_id, plugin_object2.value.as_id);
	EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(0u, sink().message_count());

	// Take a reference to the object, as if the plugin was using it, and then
	// release it, we should still be tracking the object since the
	// ReceiveInputs keep the "track_with_no_reference_count" alive until
	// they're destroyed.
	var_tracker().AddRefVar(plugin_object);
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
	var_tracker().ReleaseVar(plugin_object);
	EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(2u, sink().message_count());
	}

	// Since we didn't keep any refs to the objects, it should have freed the
	// object.
	EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
	}

	// Tests the case that the plugin receives the same vars twice as an input
	// parameter (not passing ownership) within a vector.
	TEST_F(SerializedVarTest, PluginVectorReceiveInput) {
	ProxyAutoLock lock;
	PP_Var host_object = MakeObjectVar(0x31337);

	std::vector<PP_Var> plugin_objects;
	std::vector<PP_Var> plugin_objects2;
	{
	// Receive the params. The object should be tracked with no refcount and
	// no messages sent. The string should is plugin-side only and should have
	// a reference-count of 1.
	std::vector<SerializedVar> input1;
	input1.push_back(SerializedVarTestConstructor(host_object));
	input1.push_back(SerializedVarTestConstructor("elite"));
	SerializedVarVectorReceiveInput receive_input(input1);
	uint32_t array_size = 0;
	PP_Var* plugin_objects_array =
	receive_input.Get(plugin_dispatcher(), &array_size);
	plugin_objects.insert(plugin_objects.begin(), plugin_objects_array,
	plugin_objects_array + array_size);
	ASSERT_EQ(2u, array_size);
	EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_objects[0]));
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_objects[1]));
	EXPECT_EQ(0u, sink().message_count());

	// Receive the second param, it should be resolved to the same plugin
	// object and there should still be no refcount.
	std::vector<SerializedVar> input2;
	input2.push_back(SerializedVarTestConstructor(host_object));
	input2.push_back(SerializedVarTestConstructor("elite"));
	SerializedVarVectorReceiveInput receive_input2(input2);
	uint32_t array_size2 = 0;
	PP_Var* plugin_objects_array2 =
	receive_input2.Get(plugin_dispatcher(), &array_size2);
	plugin_objects2.insert(plugin_objects2.begin(), plugin_objects_array2,
	plugin_objects_array2 + array_size2);
	ASSERT_EQ(2u, array_size2);
	EXPECT_EQ(plugin_objects[0].value.as_id, plugin_objects2[0].value.as_id);
	EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_objects[0]));
	// Strings get re-created with a new ID. We don't try to reuse strings in
	// the tracker, so the string should get a new ID.
	EXPECT_NE(plugin_objects[1].value.as_id, plugin_objects2[1].value.as_id);
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_objects2[1]));
	EXPECT_EQ(0u, sink().message_count());

	// Take a reference to the object, as if the plugin was using it, and then
	// release it, we should still be tracking the object since the
	// ReceiveInputs keep the "track_with_no_reference_count" alive until
	// they're destroyed.
	var_tracker().AddRefVar(plugin_objects[0]);
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_objects[0]));
	var_tracker().ReleaseVar(plugin_objects[0]);
	EXPECT_EQ(0, var_tracker().GetRefCountForObject(plugin_objects[0]));
	EXPECT_EQ(2u, sink().message_count());

	// Take a reference to a string and then release it. Make sure no messages
	// are sent.
	uint32_t old_message_count = static_cast<uint32_t>(sink().message_count());
	var_tracker().AddRefVar(plugin_objects[1]);
	EXPECT_EQ(2, var_tracker().GetRefCountForObject(plugin_objects[1]));
	var_tracker().ReleaseVar(plugin_objects[1]);
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_objects[1]));
	EXPECT_EQ(old_message_count, sink().message_count());
	}

	// Since we didn't keep any refs to the objects or strings, so they should
	// have been freed.
	EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_objects[0]));
	EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_objects[1]));
	EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_objects2[1]));
	}

	// Tests the browser sending a String var as a return value to make sure we
	// ref-count the host side properly.
	typedef HostProxyTest HostSerializedVarTest;
	TEST_F(HostSerializedVarTest, PluginReceiveStringReturn) {
	{
	PP_Var string_var = StringVar::StringToPPVar("Hello");
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(string_var));
	GetDispatcher()->serialization_rules()->BeginSendPassRef(string_var);
	GetDispatcher()->serialization_rules()->EndSendPassRef(string_var);
	// It should be gone, so we should get -1 to indicate that.
	EXPECT_EQ(-1, var_tracker().GetRefCountForObject(string_var));
	}

	{
	// Note this is as little weird; we're testing the behavior of the host-
	// side of the proxy, but we use ProxyObjectVar, because this unit test
	// doesn't have access to stuff in content/renderer/pepper. The ref-counting
	// behavior should be the same, however. All we're really testing
	// is the code in ppapi/proxy (HostVarSerializationRules).
	scoped_refptr<Var> obj_var = new ProxyObjectVar(NULL, 1234);
	PP_Var obj_pp_var = obj_var->GetPPVar();
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(obj_pp_var));
	GetDispatcher()->serialization_rules()->BeginSendPassRef(obj_pp_var);
	GetDispatcher()->serialization_rules()->EndSendPassRef(obj_pp_var);
	// The host side for object vars always keeps 1 ref on behalf of the plugin.
	// See HostVarSerializationRules and PluginVarSerializationRules for an
	// explanation.
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(obj_pp_var));
	var_tracker().ReleaseVar(obj_pp_var);
	}
	}

	// Tests the plugin receiving a var as a return value from the browser
	// two different times (passing ownership).
	TEST_F(SerializedVarTest, PluginReceiveReturn) {
	ProxyAutoLock lock;
	PP_Var host_object = MakeObjectVar(0x31337);

	PP_Var plugin_object;
	{
	// Receive the first param, we should be tracking it with a refcount of 1.
	SerializedVarTestConstructor input1(host_object);
	ReceiveSerializedVarReturnValue receive_input(input1);
	plugin_object = receive_input.Return(plugin_dispatcher());
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(0u, sink().message_count());

	// Receive the second param, it should be resolved to the same plugin
	// object and there should be a plugin refcount of 2. There should have
	// been an IPC message sent that released the duplicated ref in the browser
	// (so both of our refs are represented by one in the browser).
	SerializedVarTestConstructor input2(host_object);
	ReceiveSerializedVarReturnValue receive_input2(input2);
	PP_Var plugin_object2 = receive_input2.Return(plugin_dispatcher());
	EXPECT_EQ(plugin_object.value.as_id, plugin_object2.value.as_id);
	EXPECT_EQ(2, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(1u, sink().message_count());
	}

	// The ReceiveSerializedVarReturnValue destructor shouldn't have affected
	// the refcount or sent any messages.
	EXPECT_EQ(2, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(1u, sink().message_count());

	// Manually release one refcount, it shouldn't have sent any more messages.
	var_tracker().ReleaseVar(plugin_object);
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(1u, sink().message_count());

	// Manually release the last refcount, it should have freed it and sent a
	// release message to the browser.
	var_tracker().ReleaseVar(plugin_object);
	EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(2u, sink().message_count());
	}

	// Returns a value from the browser to the plugin, then return that one ref
	// back to the browser.
	TEST_F(SerializedVarTest, PluginReturnValue) {
	ProxyAutoLock lock;
	PP_Var host_object = MakeObjectVar(0x31337);

	PP_Var plugin_object;
	{
	// Receive the param in the plugin.
	SerializedVarTestConstructor input1(host_object);
	ReceiveSerializedVarReturnValue receive_input(input1);
	plugin_object = receive_input.Return(plugin_dispatcher());
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(0u, sink().message_count());
	}

	{
	// Now return to the browser.
	SerializedVar output;
	SerializedVarReturnValue return_output(&output);
	return_output.Return(plugin_dispatcher(), plugin_object);

	// The ref in the plugin should be alive until the ReturnValue goes out of
	// scope, since the release needs to be after the browser processes the
	// message.
	EXPECT_EQ(1, var_tracker().GetRefCountForObject(plugin_object));
	}

	// When the ReturnValue object goes out of scope, it should have sent a
	// release message to the browser.
	EXPECT_EQ(-1, var_tracker().GetRefCountForObject(plugin_object));
	EXPECT_EQ(1u, sink().message_count());
	}

	} // namespace proxy
	} // namespace ppapi