ppapi/shared_impl/var_value_conversions_unittest.cc - platform/external/chromium_org - Git at Google

 // Copyright (c) 2013 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 "ppapi/shared_impl/var_value_conversions.h"

 #include <cmath>
 #include <cstring>

 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/shared_impl/array_var.h"
 #include "ppapi/shared_impl/dictionary_var.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/shared_impl/test_globals.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace ppapi {
 namespace {

 bool Equals(const base::Value& value, const PP_Var& var) {
   switch (value.GetType()) {
     case base::Value::TYPE_NULL: {
       return var.type == PP_VARTYPE_NULL || var.type == PP_VARTYPE_UNDEFINED;
     }
     case base::Value::TYPE_BOOLEAN: {
       bool result = false;
       return var.type == PP_VARTYPE_BOOL &&
              value.GetAsBoolean(&result) &&
              result == PP_ToBool(var.value.as_bool);
     }
     case base::Value::TYPE_INTEGER: {
       int result = 0;
       return var.type == PP_VARTYPE_INT32 &&
              value.GetAsInteger(&result) &&
              result == var.value.as_int;
     }
     case base::Value::TYPE_DOUBLE: {
       double result = 0;
       return var.type == PP_VARTYPE_DOUBLE &&
              value.GetAsDouble(&result) &&
              fabs(result - var.value.as_double) < 1.0e-4;
     }
     case base::Value::TYPE_STRING: {
       std::string result;
       StringVar* string_var = StringVar::FromPPVar(var);
       return string_var &&
              value.GetAsString(&result) &&
              result == string_var->value();
     }
     case base::Value::TYPE_BINARY: {
       const base::BinaryValue& binary_value =
           static_cast<const base::BinaryValue&>(value);
       ArrayBufferVar* array_buffer_var = ArrayBufferVar::FromPPVar(var);
       if (!array_buffer_var ||
           binary_value.GetSize() != array_buffer_var->ByteLength()) {
         return false;
       }

       bool result = !memcmp(binary_value.GetBuffer(), array_buffer_var->Map(),
                             binary_value.GetSize());
       array_buffer_var->Unmap();
       return result;
     }
     case base::Value::TYPE_DICTIONARY: {
       const base::DictionaryValue& dict_value =
           static_cast<const base::DictionaryValue&>(value);
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(var);
       if (!dict_var)
         return false;

       size_t count = 0;
       for (DictionaryVar::KeyValueMap::const_iterator iter =
                dict_var->key_value_map().begin();
            iter != dict_var->key_value_map().end();
            ++iter) {
         if (iter->second.get().type == PP_VARTYPE_UNDEFINED ||
             iter->second.get().type == PP_VARTYPE_NULL) {
           continue;
         }

         ++count;
         const base::Value* sub_value = NULL;
         if (!dict_value.GetWithoutPathExpansion(iter->first, &sub_value) ||
             !Equals(*sub_value, iter->second.get())) {
           return false;
         }
       }
       return count == dict_value.size();
     }
     case base::Value::TYPE_LIST: {
       const base::ListValue& list_value =
           static_cast<const base::ListValue&>(value);
       ArrayVar* array_var = ArrayVar::FromPPVar(var);
       if (!array_var || list_value.GetSize() != array_var->elements().size())
         return false;

       base::ListValue::const_iterator value_iter = list_value.begin();
       ArrayVar::ElementVector::const_iterator var_iter =
           array_var->elements().begin();
       for (; value_iter != list_value.end() &&
                  var_iter != array_var->elements().end();
            ++value_iter, ++var_iter) {
         if (!Equals(**value_iter, var_iter->get()))
           return false;
       }
       return true;
     }
   }
   NOTREACHED();
   return false;
 }

 bool ConvertVarAndVerify(const PP_Var& var) {
   scoped_ptr<base::Value> value(CreateValueFromVar(var));
   if (value.get())
     return Equals(*value, var);
   return false;
 }

 bool ConvertValueAndVerify(const base::Value& value) {
   ScopedPPVar var(ScopedPPVar::PassRef(), CreateVarFromValue(value));
   if (var.get().type != PP_VARTYPE_UNDEFINED)
     return Equals(value, var.get());
   return false;
 }

 class VarValueConversionsTest : public testing::Test {
  public:
   VarValueConversionsTest() {
   }
   virtual ~VarValueConversionsTest() {
   }

   // testing::Test implementation.
   virtual void SetUp() {
     ProxyLock::Acquire();
   }
   virtual void TearDown() {
     ASSERT_TRUE(PpapiGlobals::Get()->GetVarTracker()->GetLiveVars().empty());
     ProxyLock::Release();
   }

  private:
   TestGlobals globals_;
 };

 }  // namespace

 TEST_F(VarValueConversionsTest, CreateValueFromVar) {
   {
     // Var holding a ref to itself is not a valid input.
     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
     ScopedPPVar var_1(ScopedPPVar::PassRef(), dict_var->GetPPVar());
     scoped_refptr<ArrayVar> array_var(new ArrayVar());
     ScopedPPVar var_2(ScopedPPVar::PassRef(), array_var->GetPPVar());

     ASSERT_TRUE(dict_var->SetWithStringKey("key_1", var_2.get()));
     ASSERT_TRUE(ConvertVarAndVerify(var_1.get()));

     ASSERT_TRUE(array_var->Set(0, var_1.get()));
     scoped_ptr<base::Value> value(CreateValueFromVar(var_1.get()));
     ASSERT_EQ(NULL, value.get());

     // Make sure |var_1| doesn't indirectly hold a ref to itself, otherwise it
     // is leaked.
     dict_var->DeleteWithStringKey("key_1");
   }

   // Vars of null or undefined type are converted to null values.
   {
     ASSERT_TRUE(ConvertVarAndVerify(PP_MakeNull()));
     ASSERT_TRUE(ConvertVarAndVerify(PP_MakeUndefined()));
   }

   {
     // Test empty dictionary.
     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
     ScopedPPVar var(ScopedPPVar::PassRef(), dict_var->GetPPVar());

     ASSERT_TRUE(ConvertVarAndVerify(var.get()));
   }

   {
     // Key-value pairs whose value is undefined or null are ignored.
     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
     ASSERT_TRUE(dict_var->SetWithStringKey("key_1", PP_MakeUndefined()));
     ASSERT_TRUE(dict_var->SetWithStringKey("key_2", PP_MakeInt32(1)));
     ASSERT_TRUE(dict_var->SetWithStringKey("key_3", PP_MakeNull()));
     ScopedPPVar var(ScopedPPVar::PassRef(), dict_var->GetPPVar());

     ASSERT_TRUE(ConvertVarAndVerify(var.get()));
   }

   {
     // The same PP_Var is allowed to appear multiple times.
     scoped_refptr<DictionaryVar> dict_var_1(new DictionaryVar());
     ScopedPPVar dict_pp_var_1(ScopedPPVar::PassRef(), dict_var_1->GetPPVar());
     scoped_refptr<DictionaryVar> dict_var_2(new DictionaryVar());
     ScopedPPVar dict_pp_var_2(ScopedPPVar::PassRef(), dict_var_2->GetPPVar());
     scoped_refptr<StringVar> string_var(new StringVar("string_value"));
     ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());

     ASSERT_TRUE(dict_var_1->SetWithStringKey("key_1", dict_pp_var_2.get()));
     ASSERT_TRUE(dict_var_1->SetWithStringKey("key_2", dict_pp_var_2.get()));
     ASSERT_TRUE(dict_var_1->SetWithStringKey("key_3", string_pp_var.get()));
     ASSERT_TRUE(dict_var_2->SetWithStringKey("key_4", string_pp_var.get()));

     ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var_1.get()));
   }

   {
     // Test basic cases for array.
     scoped_refptr<ArrayVar> array_var(new ArrayVar());
     ScopedPPVar var(ScopedPPVar::PassRef(), array_var->GetPPVar());

     ASSERT_TRUE(ConvertVarAndVerify(var.get()));

     ASSERT_TRUE(array_var->Set(0, PP_MakeDouble(1)));

     ASSERT_TRUE(ConvertVarAndVerify(var.get()));
   }

   {
     // Test more complex inputs.
     scoped_refptr<DictionaryVar> dict_var_1(new DictionaryVar());
     ScopedPPVar dict_pp_var_1(ScopedPPVar::PassRef(), dict_var_1->GetPPVar());
     scoped_refptr<DictionaryVar> dict_var_2(new DictionaryVar());
     ScopedPPVar dict_pp_var_2(ScopedPPVar::PassRef(), dict_var_2->GetPPVar());
     scoped_refptr<ArrayVar> array_var(new ArrayVar());
     ScopedPPVar array_pp_var(ScopedPPVar::PassRef(), array_var->GetPPVar());
     scoped_refptr<StringVar> string_var(new StringVar("string_value"));
     ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());

     ASSERT_TRUE(dict_var_1->SetWithStringKey("null_key", PP_MakeNull()));
     ASSERT_TRUE(dict_var_1->SetWithStringKey("string_key",
                                              string_pp_var.get()));
     ASSERT_TRUE(dict_var_1->SetWithStringKey("dict_key", dict_pp_var_2.get()));

     ASSERT_TRUE(dict_var_2->SetWithStringKey("undefined_key",
                                              PP_MakeUndefined()));
     ASSERT_TRUE(dict_var_2->SetWithStringKey("double_key", PP_MakeDouble(1)));
     ASSERT_TRUE(dict_var_2->SetWithStringKey("array_key", array_pp_var.get()));

     ASSERT_TRUE(array_var->Set(0, PP_MakeInt32(2)));
     ASSERT_TRUE(array_var->Set(1, PP_MakeBool(PP_TRUE)));
     ASSERT_TRUE(array_var->SetLength(4));

     ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var_1.get()));
   }

   {
     // Test that dictionary keys containing '.' are handled correctly.
     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
     ScopedPPVar dict_pp_var(ScopedPPVar::PassRef(), dict_var->GetPPVar());

     ASSERT_TRUE(dict_var->SetWithStringKey("double.key", PP_MakeDouble(1)));
     ASSERT_TRUE(dict_var->SetWithStringKey("int.key..name", PP_MakeInt32(2)));

     ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var.get()));
   }
 }

 TEST_F(VarValueConversionsTest, CreateVarFromValue) {
   {
     // Test basic cases for dictionary.
     base::DictionaryValue dict_value;
     ASSERT_TRUE(ConvertValueAndVerify(dict_value));

     dict_value.SetInteger("int_key", 1);
     ASSERT_TRUE(ConvertValueAndVerify(dict_value));
   }

   {
     // Test basic cases for array.
     base::ListValue list_value;
     ASSERT_TRUE(ConvertValueAndVerify(list_value));

     list_value.AppendInteger(1);
     ASSERT_TRUE(ConvertValueAndVerify(list_value));
   }

   {
     // Test more complex inputs.
     base::DictionaryValue dict_value;
     dict_value.SetString("string_key", "string_value");
     dict_value.SetDouble("dict_key.double_key", 1);

     scoped_ptr<base::ListValue> list_value(new base::ListValue());
     list_value->AppendInteger(2);
     list_value->AppendBoolean(true);
     list_value->Append(base::Value::CreateNullValue());

     dict_value.Set("dict_key.array_key", list_value.release());

     ASSERT_TRUE(ConvertValueAndVerify(dict_value));
   }
 }

 TEST_F(VarValueConversionsTest, CreateListValueFromVarVector) {
   {
     // Test empty var vector.
     scoped_ptr<base::ListValue> list_value(
         CreateListValueFromVarVector(std::vector<PP_Var>()));
     ASSERT_TRUE(list_value.get());
     ASSERT_EQ(0u, list_value->GetSize());
   }

   {
     // Test more complex inputs.
     scoped_refptr<StringVar> string_var(new StringVar("string_value"));
     ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());

     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
     ScopedPPVar dict_pp_var(ScopedPPVar::PassRef(), dict_var->GetPPVar());
     ASSERT_TRUE(dict_var->SetWithStringKey("null_key", PP_MakeNull()));
     ASSERT_TRUE(dict_var->SetWithStringKey("string_key", string_pp_var.get()));

     scoped_refptr<ArrayVar> array_var(new ArrayVar());
     ScopedPPVar array_pp_var(ScopedPPVar::PassRef(), array_var->GetPPVar());
     ASSERT_TRUE(array_var->Set(0, PP_MakeInt32(2)));
     ASSERT_TRUE(array_var->Set(1, PP_MakeBool(PP_TRUE)));
     ASSERT_TRUE(array_var->SetLength(4));

     std::vector<PP_Var> vars;
     vars.push_back(dict_pp_var.get());
     vars.push_back(string_pp_var.get());
     vars.push_back(array_pp_var.get());
     vars.push_back(PP_MakeDouble(1));
     vars.push_back(PP_MakeUndefined());
     vars.push_back(PP_MakeNull());

     scoped_ptr<base::ListValue> list_value(CreateListValueFromVarVector(vars));

     ASSERT_TRUE(list_value.get());
     ASSERT_EQ(vars.size(), list_value->GetSize());

     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       const base::Value* value = NULL;
       ASSERT_TRUE(list_value->Get(i, &value));
       ASSERT_TRUE(Equals(*value, vars[i]));
     }
   }
 }

 TEST_F(VarValueConversionsTest, CreateVarVectorFromListValue) {
   {
     // Test empty list.
     base::ListValue list_value;
     std::vector<PP_Var> vars;
     ASSERT_TRUE(CreateVarVectorFromListValue(list_value, &vars));
     ASSERT_EQ(0u, vars.size());
   }

   {
     // Test more complex inputs.
     base::ListValue list_value;

     scoped_ptr<base::DictionaryValue> dict_value(new base::DictionaryValue());
     dict_value->SetString("string_key", "string_value");

     scoped_ptr<base::ListValue> sub_list_value(new base::ListValue());
     sub_list_value->AppendInteger(2);
     sub_list_value->AppendBoolean(true);

     list_value.Append(dict_value.release());
     list_value.AppendString("string_value");
     list_value.Append(sub_list_value.release());
     list_value.AppendDouble(1);
     list_value.Append(base::Value::CreateNullValue());

     std::vector<PP_Var> vars;
     ASSERT_TRUE(CreateVarVectorFromListValue(list_value, &vars));

     ASSERT_EQ(list_value.GetSize(), vars.size());

     for (size_t i = 0; i < list_value.GetSize(); ++i) {
       const base::Value* value = NULL;
       ASSERT_TRUE(list_value.Get(i, &value));
       ASSERT_TRUE(Equals(*value, vars[i]));

       PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(vars[i]);
     }
   }
 }

 }  // namespace ppapi
	// Copyright (c) 2013 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 "ppapi/shared_impl/var_value_conversions.h"

	#include <cmath>
	#include <cstring>

	#include "base/logging.h"
	#include "base/memory/ref_counted.h"
	#include "base/memory/scoped_ptr.h"
	#include "base/values.h"
	#include "ppapi/c/pp_bool.h"
	#include "ppapi/c/pp_var.h"
	#include "ppapi/shared_impl/array_var.h"
	#include "ppapi/shared_impl/dictionary_var.h"
	#include "ppapi/shared_impl/ppapi_globals.h"
	#include "ppapi/shared_impl/proxy_lock.h"
	#include "ppapi/shared_impl/scoped_pp_var.h"
	#include "ppapi/shared_impl/test_globals.h"
	#include "ppapi/shared_impl/var.h"
	#include "ppapi/shared_impl/var_tracker.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace ppapi {
	namespace {

	bool Equals(const base::Value& value, const PP_Var& var) {
	switch (value.GetType()) {
	case base::Value::TYPE_NULL: {
	return var.type == PP_VARTYPE_NULL \|\| var.type == PP_VARTYPE_UNDEFINED;
	}
	case base::Value::TYPE_BOOLEAN: {
	bool result = false;
	return var.type == PP_VARTYPE_BOOL &&
	value.GetAsBoolean(&result) &&
	result == PP_ToBool(var.value.as_bool);
	}
	case base::Value::TYPE_INTEGER: {
	int result = 0;
	return var.type == PP_VARTYPE_INT32 &&
	value.GetAsInteger(&result) &&
	result == var.value.as_int;
	}
	case base::Value::TYPE_DOUBLE: {
	double result = 0;
	return var.type == PP_VARTYPE_DOUBLE &&
	value.GetAsDouble(&result) &&
	fabs(result - var.value.as_double) < 1.0e-4;
	}
	case base::Value::TYPE_STRING: {
	std::string result;
	StringVar* string_var = StringVar::FromPPVar(var);
	return string_var &&
	value.GetAsString(&result) &&
	result == string_var->value();
	}
	case base::Value::TYPE_BINARY: {
	const base::BinaryValue& binary_value =
	static_cast<const base::BinaryValue&>(value);
	ArrayBufferVar* array_buffer_var = ArrayBufferVar::FromPPVar(var);
	if (!array_buffer_var \|\|
	binary_value.GetSize() != array_buffer_var->ByteLength()) {
	return false;
	}

	bool result = !memcmp(binary_value.GetBuffer(), array_buffer_var->Map(),
	binary_value.GetSize());
	array_buffer_var->Unmap();
	return result;
	}
	case base::Value::TYPE_DICTIONARY: {
	const base::DictionaryValue& dict_value =
	static_cast<const base::DictionaryValue&>(value);
	DictionaryVar* dict_var = DictionaryVar::FromPPVar(var);
	if (!dict_var)
	return false;

	size_t count = 0;
	for (DictionaryVar::KeyValueMap::const_iterator iter =
	dict_var->key_value_map().begin();
	iter != dict_var->key_value_map().end();
	++iter) {
	if (iter->second.get().type == PP_VARTYPE_UNDEFINED \|\|
	iter->second.get().type == PP_VARTYPE_NULL) {
	continue;
	}

	++count;
	const base::Value* sub_value = NULL;
	if (!dict_value.GetWithoutPathExpansion(iter->first, &sub_value) \|\|
	!Equals(*sub_value, iter->second.get())) {
	return false;
	}
	}
	return count == dict_value.size();
	}
	case base::Value::TYPE_LIST: {
	const base::ListValue& list_value =
	static_cast<const base::ListValue&>(value);
	ArrayVar* array_var = ArrayVar::FromPPVar(var);
	if (!array_var \|\| list_value.GetSize() != array_var->elements().size())
	return false;

	base::ListValue::const_iterator value_iter = list_value.begin();
	ArrayVar::ElementVector::const_iterator var_iter =
	array_var->elements().begin();
	for (; value_iter != list_value.end() &&
	var_iter != array_var->elements().end();
	++value_iter, ++var_iter) {
	if (!Equals(**value_iter, var_iter->get()))
	return false;
	}
	return true;
	}
	}
	NOTREACHED();
	return false;
	}

	bool ConvertVarAndVerify(const PP_Var& var) {
	scoped_ptr<base::Value> value(CreateValueFromVar(var));
	if (value.get())
	return Equals(*value, var);
	return false;
	}

	bool ConvertValueAndVerify(const base::Value& value) {
	ScopedPPVar var(ScopedPPVar::PassRef(), CreateVarFromValue(value));
	if (var.get().type != PP_VARTYPE_UNDEFINED)
	return Equals(value, var.get());
	return false;
	}

	class VarValueConversionsTest : public testing::Test {
	public:
	VarValueConversionsTest() {
	}
	virtual ~VarValueConversionsTest() {
	}

	// testing::Test implementation.
	virtual void SetUp() {
	ProxyLock::Acquire();
	}
	virtual void TearDown() {
	ASSERT_TRUE(PpapiGlobals::Get()->GetVarTracker()->GetLiveVars().empty());
	ProxyLock::Release();
	}

	private:
	TestGlobals globals_;
	};

	} // namespace

	TEST_F(VarValueConversionsTest, CreateValueFromVar) {
	{
	// Var holding a ref to itself is not a valid input.
	scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
	ScopedPPVar var_1(ScopedPPVar::PassRef(), dict_var->GetPPVar());
	scoped_refptr<ArrayVar> array_var(new ArrayVar());
	ScopedPPVar var_2(ScopedPPVar::PassRef(), array_var->GetPPVar());

	ASSERT_TRUE(dict_var->SetWithStringKey("key_1", var_2.get()));
	ASSERT_TRUE(ConvertVarAndVerify(var_1.get()));

	ASSERT_TRUE(array_var->Set(0, var_1.get()));
	scoped_ptr<base::Value> value(CreateValueFromVar(var_1.get()));
	ASSERT_EQ(NULL, value.get());

	// Make sure \|var_1\| doesn't indirectly hold a ref to itself, otherwise it
	// is leaked.
	dict_var->DeleteWithStringKey("key_1");
	}

	// Vars of null or undefined type are converted to null values.
	{
	ASSERT_TRUE(ConvertVarAndVerify(PP_MakeNull()));
	ASSERT_TRUE(ConvertVarAndVerify(PP_MakeUndefined()));
	}

	{
	// Test empty dictionary.
	scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
	ScopedPPVar var(ScopedPPVar::PassRef(), dict_var->GetPPVar());

	ASSERT_TRUE(ConvertVarAndVerify(var.get()));
	}

	{
	// Key-value pairs whose value is undefined or null are ignored.
	scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
	ASSERT_TRUE(dict_var->SetWithStringKey("key_1", PP_MakeUndefined()));
	ASSERT_TRUE(dict_var->SetWithStringKey("key_2", PP_MakeInt32(1)));
	ASSERT_TRUE(dict_var->SetWithStringKey("key_3", PP_MakeNull()));
	ScopedPPVar var(ScopedPPVar::PassRef(), dict_var->GetPPVar());

	ASSERT_TRUE(ConvertVarAndVerify(var.get()));
	}

	{
	// The same PP_Var is allowed to appear multiple times.
	scoped_refptr<DictionaryVar> dict_var_1(new DictionaryVar());
	ScopedPPVar dict_pp_var_1(ScopedPPVar::PassRef(), dict_var_1->GetPPVar());
	scoped_refptr<DictionaryVar> dict_var_2(new DictionaryVar());
	ScopedPPVar dict_pp_var_2(ScopedPPVar::PassRef(), dict_var_2->GetPPVar());
	scoped_refptr<StringVar> string_var(new StringVar("string_value"));
	ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());

	ASSERT_TRUE(dict_var_1->SetWithStringKey("key_1", dict_pp_var_2.get()));
	ASSERT_TRUE(dict_var_1->SetWithStringKey("key_2", dict_pp_var_2.get()));
	ASSERT_TRUE(dict_var_1->SetWithStringKey("key_3", string_pp_var.get()));
	ASSERT_TRUE(dict_var_2->SetWithStringKey("key_4", string_pp_var.get()));

	ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var_1.get()));
	}

	{
	// Test basic cases for array.
	scoped_refptr<ArrayVar> array_var(new ArrayVar());
	ScopedPPVar var(ScopedPPVar::PassRef(), array_var->GetPPVar());

	ASSERT_TRUE(ConvertVarAndVerify(var.get()));

	ASSERT_TRUE(array_var->Set(0, PP_MakeDouble(1)));

	ASSERT_TRUE(ConvertVarAndVerify(var.get()));
	}

	{
	// Test more complex inputs.
	scoped_refptr<DictionaryVar> dict_var_1(new DictionaryVar());
	ScopedPPVar dict_pp_var_1(ScopedPPVar::PassRef(), dict_var_1->GetPPVar());
	scoped_refptr<DictionaryVar> dict_var_2(new DictionaryVar());
	ScopedPPVar dict_pp_var_2(ScopedPPVar::PassRef(), dict_var_2->GetPPVar());
	scoped_refptr<ArrayVar> array_var(new ArrayVar());
	ScopedPPVar array_pp_var(ScopedPPVar::PassRef(), array_var->GetPPVar());
	scoped_refptr<StringVar> string_var(new StringVar("string_value"));
	ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());

	ASSERT_TRUE(dict_var_1->SetWithStringKey("null_key", PP_MakeNull()));
	ASSERT_TRUE(dict_var_1->SetWithStringKey("string_key",
	string_pp_var.get()));
	ASSERT_TRUE(dict_var_1->SetWithStringKey("dict_key", dict_pp_var_2.get()));

	ASSERT_TRUE(dict_var_2->SetWithStringKey("undefined_key",
	PP_MakeUndefined()));
	ASSERT_TRUE(dict_var_2->SetWithStringKey("double_key", PP_MakeDouble(1)));
	ASSERT_TRUE(dict_var_2->SetWithStringKey("array_key", array_pp_var.get()));

	ASSERT_TRUE(array_var->Set(0, PP_MakeInt32(2)));
	ASSERT_TRUE(array_var->Set(1, PP_MakeBool(PP_TRUE)));
	ASSERT_TRUE(array_var->SetLength(4));

	ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var_1.get()));
	}

	{
	// Test that dictionary keys containing '.' are handled correctly.
	scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
	ScopedPPVar dict_pp_var(ScopedPPVar::PassRef(), dict_var->GetPPVar());

	ASSERT_TRUE(dict_var->SetWithStringKey("double.key", PP_MakeDouble(1)));
	ASSERT_TRUE(dict_var->SetWithStringKey("int.key..name", PP_MakeInt32(2)));

	ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var.get()));
	}
	}

	TEST_F(VarValueConversionsTest, CreateVarFromValue) {
	{
	// Test basic cases for dictionary.
	base::DictionaryValue dict_value;
	ASSERT_TRUE(ConvertValueAndVerify(dict_value));

	dict_value.SetInteger("int_key", 1);
	ASSERT_TRUE(ConvertValueAndVerify(dict_value));
	}

	{
	// Test basic cases for array.
	base::ListValue list_value;
	ASSERT_TRUE(ConvertValueAndVerify(list_value));

	list_value.AppendInteger(1);
	ASSERT_TRUE(ConvertValueAndVerify(list_value));
	}

	{
	// Test more complex inputs.
	base::DictionaryValue dict_value;
	dict_value.SetString("string_key", "string_value");
	dict_value.SetDouble("dict_key.double_key", 1);

	scoped_ptr<base::ListValue> list_value(new base::ListValue());
	list_value->AppendInteger(2);
	list_value->AppendBoolean(true);
	list_value->Append(base::Value::CreateNullValue());

	dict_value.Set("dict_key.array_key", list_value.release());

	ASSERT_TRUE(ConvertValueAndVerify(dict_value));
	}
	}

	TEST_F(VarValueConversionsTest, CreateListValueFromVarVector) {
	{
	// Test empty var vector.
	scoped_ptr<base::ListValue> list_value(
	CreateListValueFromVarVector(std::vector<PP_Var>()));
	ASSERT_TRUE(list_value.get());
	ASSERT_EQ(0u, list_value->GetSize());
	}

	{
	// Test more complex inputs.
	scoped_refptr<StringVar> string_var(new StringVar("string_value"));
	ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());

	scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
	ScopedPPVar dict_pp_var(ScopedPPVar::PassRef(), dict_var->GetPPVar());
	ASSERT_TRUE(dict_var->SetWithStringKey("null_key", PP_MakeNull()));
	ASSERT_TRUE(dict_var->SetWithStringKey("string_key", string_pp_var.get()));

	scoped_refptr<ArrayVar> array_var(new ArrayVar());
	ScopedPPVar array_pp_var(ScopedPPVar::PassRef(), array_var->GetPPVar());
	ASSERT_TRUE(array_var->Set(0, PP_MakeInt32(2)));
	ASSERT_TRUE(array_var->Set(1, PP_MakeBool(PP_TRUE)));
	ASSERT_TRUE(array_var->SetLength(4));

	std::vector<PP_Var> vars;
	vars.push_back(dict_pp_var.get());
	vars.push_back(string_pp_var.get());
	vars.push_back(array_pp_var.get());
	vars.push_back(PP_MakeDouble(1));
	vars.push_back(PP_MakeUndefined());
	vars.push_back(PP_MakeNull());

	scoped_ptr<base::ListValue> list_value(CreateListValueFromVarVector(vars));

	ASSERT_TRUE(list_value.get());
	ASSERT_EQ(vars.size(), list_value->GetSize());

	for (size_t i = 0; i < list_value->GetSize(); ++i) {
	const base::Value* value = NULL;
	ASSERT_TRUE(list_value->Get(i, &value));
	ASSERT_TRUE(Equals(*value, vars[i]));
	}
	}
	}

	TEST_F(VarValueConversionsTest, CreateVarVectorFromListValue) {
	{
	// Test empty list.
	base::ListValue list_value;
	std::vector<PP_Var> vars;
	ASSERT_TRUE(CreateVarVectorFromListValue(list_value, &vars));
	ASSERT_EQ(0u, vars.size());
	}

	{
	// Test more complex inputs.
	base::ListValue list_value;

	scoped_ptr<base::DictionaryValue> dict_value(new base::DictionaryValue());
	dict_value->SetString("string_key", "string_value");

	scoped_ptr<base::ListValue> sub_list_value(new base::ListValue());
	sub_list_value->AppendInteger(2);
	sub_list_value->AppendBoolean(true);

	list_value.Append(dict_value.release());
	list_value.AppendString("string_value");
	list_value.Append(sub_list_value.release());
	list_value.AppendDouble(1);
	list_value.Append(base::Value::CreateNullValue());

	std::vector<PP_Var> vars;
	ASSERT_TRUE(CreateVarVectorFromListValue(list_value, &vars));

	ASSERT_EQ(list_value.GetSize(), vars.size());

	for (size_t i = 0; i < list_value.GetSize(); ++i) {
	const base::Value* value = NULL;
	ASSERT_TRUE(list_value.Get(i, &value));
	ASSERT_TRUE(Equals(*value, vars[i]));

	PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(vars[i]);
	}
	}
	}

	} // namespace ppapi