ppapi/shared_impl/var_value_conversions_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/shared_impl/var_value_conversions.h"
   6
   7 #include <cmath>
   8 #include <cstring>
   9
  10 #include "base/logging.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/values.h"
  14 #include "ppapi/c/pp_bool.h"
  15 #include "ppapi/c/pp_var.h"
  16 #include "ppapi/shared_impl/array_var.h"
  17 #include "ppapi/shared_impl/dictionary_var.h"
  18 #include "ppapi/shared_impl/ppapi_globals.h"
  19 #include "ppapi/shared_impl/proxy_lock.h"
  20 #include "ppapi/shared_impl/scoped_pp_var.h"
  21 #include "ppapi/shared_impl/test_globals.h"
  22 #include "ppapi/shared_impl/var.h"
  23 #include "ppapi/shared_impl/var_tracker.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25
  26 namespace ppapi {
  27 namespace {
  28
  29 bool Equals(const base::Value& value, const PP_Var& var) {
  30   switch (value.GetType()) {
  31     case base::Value::TYPE_NULL: {
  32       return var.type == PP_VARTYPE_NULL || var.type == PP_VARTYPE_UNDEFINED;
  33     }
  34     case base::Value::TYPE_BOOLEAN: {
  35       bool result = false;
  36       return var.type == PP_VARTYPE_BOOL &&
  37              value.GetAsBoolean(&result) &&
  38              result == PP_ToBool(var.value.as_bool);
  39     }
  40     case base::Value::TYPE_INTEGER: {
  41       int result = 0;
  42       return var.type == PP_VARTYPE_INT32 &&
  43              value.GetAsInteger(&result) &&
  44              result == var.value.as_int;
  45     }
  46     case base::Value::TYPE_DOUBLE: {
  47       double result = 0;
  48       return var.type == PP_VARTYPE_DOUBLE &&
  49              value.GetAsDouble(&result) &&
  50              fabs(result - var.value.as_double) < 1.0e-4;
  51     }
  52     case base::Value::TYPE_STRING: {
  53       std::string result;
  54       StringVar* string_var = StringVar::FromPPVar(var);
  55       return string_var &&
  56              value.GetAsString(&result) &&
  57              result == string_var->value();
  58     }
  59     case base::Value::TYPE_BINARY: {
  60       const base::BinaryValue& binary_value =
  61           static_cast<const base::BinaryValue&>(value);
  62       ArrayBufferVar* array_buffer_var = ArrayBufferVar::FromPPVar(var);
  63       if (!array_buffer_var ||
  64           binary_value.GetSize() != array_buffer_var->ByteLength()) {
  65         return false;
  66       }
  67
  68       bool result = !memcmp(binary_value.GetBuffer(), array_buffer_var->Map(),
  69                             binary_value.GetSize());
  70       array_buffer_var->Unmap();
  71       return result;
  72     }
  73     case base::Value::TYPE_DICTIONARY: {
  74       const base::DictionaryValue& dict_value =
  75           static_cast<const base::DictionaryValue&>(value);
  76       DictionaryVar* dict_var = DictionaryVar::FromPPVar(var);
  77       if (!dict_var)
  78         return false;
  79
  80       size_t count = 0;
  81       for (DictionaryVar::KeyValueMap::const_iterator iter =
  82                dict_var->key_value_map().begin();
  83            iter != dict_var->key_value_map().end();
  84            ++iter) {
  85         if (iter->second.get().type == PP_VARTYPE_UNDEFINED ||
  86             iter->second.get().type == PP_VARTYPE_NULL) {
  87           continue;
  88         }
  89
  90         ++count;
  91         const base::Value* sub_value = NULL;
  92         if (!dict_value.GetWithoutPathExpansion(iter->first, &sub_value) ||
  93             !Equals(*sub_value, iter->second.get())) {
  94           return false;
  95         }
  96       }
  97       return count == dict_value.size();
  98     }
  99     case base::Value::TYPE_LIST: {
 100       const base::ListValue& list_value =
 101           static_cast<const base::ListValue&>(value);
 102       ArrayVar* array_var = ArrayVar::FromPPVar(var);
 103       if (!array_var || list_value.GetSize() != array_var->elements().size())
 104         return false;
 105
 106       base::ListValue::const_iterator value_iter = list_value.begin();
 107       ArrayVar::ElementVector::const_iterator var_iter =
 108           array_var->elements().begin();
 109       for (; value_iter != list_value.end() &&
 110                  var_iter != array_var->elements().end();
 111            ++value_iter, ++var_iter) {
 112         if (!Equals(**value_iter, var_iter->get()))
 113           return false;
 114       }
 115       return true;
 116     }
 117   }
 118   NOTREACHED();
 119   return false;
 120 }
 121
 122 bool ConvertVarAndVerify(const PP_Var& var) {
 123   scoped_ptr<base::Value> value(CreateValueFromVar(var));
 124   if (value.get())
 125     return Equals(*value, var);
 126   return false;
 127 }
 128
 129 bool ConvertValueAndVerify(const base::Value& value) {
 130   ScopedPPVar var(ScopedPPVar::PassRef(), CreateVarFromValue(value));
 131   if (var.get().type != PP_VARTYPE_UNDEFINED)
 132     return Equals(value, var.get());
 133   return false;
 134 }
 135
 136 class VarValueConversionsTest : public testing::Test {
 137  public:
 138   VarValueConversionsTest() {
 139   }
 140   virtual ~VarValueConversionsTest() {
 141   }
 142
 143   // testing::Test implementation.
 144   virtual void SetUp() {
 145     ProxyLock::EnableLockingOnThreadForTest();
 146     ProxyLock::Acquire();
 147   }
 148   virtual void TearDown() {
 149     ASSERT_TRUE(PpapiGlobals::Get()->GetVarTracker()->GetLiveVars().empty());
 150     ProxyLock::Release();
 151   }
 152
 153  private:
 154   TestGlobals globals_;
 155 };
 156
 157 }  // namespace
 158
 159 TEST_F(VarValueConversionsTest, CreateValueFromVar) {
 160   {
 161     // Var holding a ref to itself is not a valid input.
 162     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
 163     ScopedPPVar var_1(ScopedPPVar::PassRef(), dict_var->GetPPVar());
 164     scoped_refptr<ArrayVar> array_var(new ArrayVar());
 165     ScopedPPVar var_2(ScopedPPVar::PassRef(), array_var->GetPPVar());
 166
 167     ASSERT_TRUE(dict_var->SetWithStringKey("key_1", var_2.get()));
 168     ASSERT_TRUE(ConvertVarAndVerify(var_1.get()));
 169
 170     ASSERT_TRUE(array_var->Set(0, var_1.get()));
 171     scoped_ptr<base::Value> value(CreateValueFromVar(var_1.get()));
 172     ASSERT_EQ(NULL, value.get());
 173
 174     // Make sure |var_1| doesn't indirectly hold a ref to itself, otherwise it
 175     // is leaked.
 176     dict_var->DeleteWithStringKey("key_1");
 177   }
 178
 179   // Vars of null or undefined type are converted to null values.
 180   {
 181     ASSERT_TRUE(ConvertVarAndVerify(PP_MakeNull()));
 182     ASSERT_TRUE(ConvertVarAndVerify(PP_MakeUndefined()));
 183   }
 184
 185   {
 186     // Test empty dictionary.
 187     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
 188     ScopedPPVar var(ScopedPPVar::PassRef(), dict_var->GetPPVar());
 189
 190     ASSERT_TRUE(ConvertVarAndVerify(var.get()));
 191   }
 192
 193   {
 194     // Key-value pairs whose value is undefined or null are ignored.
 195     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
 196     ASSERT_TRUE(dict_var->SetWithStringKey("key_1", PP_MakeUndefined()));
 197     ASSERT_TRUE(dict_var->SetWithStringKey("key_2", PP_MakeInt32(1)));
 198     ASSERT_TRUE(dict_var->SetWithStringKey("key_3", PP_MakeNull()));
 199     ScopedPPVar var(ScopedPPVar::PassRef(), dict_var->GetPPVar());
 200
 201     ASSERT_TRUE(ConvertVarAndVerify(var.get()));
 202   }
 203
 204   {
 205     // The same PP_Var is allowed to appear multiple times.
 206     scoped_refptr<DictionaryVar> dict_var_1(new DictionaryVar());
 207     ScopedPPVar dict_pp_var_1(ScopedPPVar::PassRef(), dict_var_1->GetPPVar());
 208     scoped_refptr<DictionaryVar> dict_var_2(new DictionaryVar());
 209     ScopedPPVar dict_pp_var_2(ScopedPPVar::PassRef(), dict_var_2->GetPPVar());
 210     scoped_refptr<StringVar> string_var(new StringVar("string_value"));
 211     ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());
 212
 213     ASSERT_TRUE(dict_var_1->SetWithStringKey("key_1", dict_pp_var_2.get()));
 214     ASSERT_TRUE(dict_var_1->SetWithStringKey("key_2", dict_pp_var_2.get()));
 215     ASSERT_TRUE(dict_var_1->SetWithStringKey("key_3", string_pp_var.get()));
 216     ASSERT_TRUE(dict_var_2->SetWithStringKey("key_4", string_pp_var.get()));
 217
 218     ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var_1.get()));
 219   }
 220
 221   {
 222     // Test basic cases for array.
 223     scoped_refptr<ArrayVar> array_var(new ArrayVar());
 224     ScopedPPVar var(ScopedPPVar::PassRef(), array_var->GetPPVar());
 225
 226     ASSERT_TRUE(ConvertVarAndVerify(var.get()));
 227
 228     ASSERT_TRUE(array_var->Set(0, PP_MakeDouble(1)));
 229
 230     ASSERT_TRUE(ConvertVarAndVerify(var.get()));
 231   }
 232
 233   {
 234     // Test more complex inputs.
 235     scoped_refptr<DictionaryVar> dict_var_1(new DictionaryVar());
 236     ScopedPPVar dict_pp_var_1(ScopedPPVar::PassRef(), dict_var_1->GetPPVar());
 237     scoped_refptr<DictionaryVar> dict_var_2(new DictionaryVar());
 238     ScopedPPVar dict_pp_var_2(ScopedPPVar::PassRef(), dict_var_2->GetPPVar());
 239     scoped_refptr<ArrayVar> array_var(new ArrayVar());
 240     ScopedPPVar array_pp_var(ScopedPPVar::PassRef(), array_var->GetPPVar());
 241     scoped_refptr<StringVar> string_var(new StringVar("string_value"));
 242     ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());
 243
 244     ASSERT_TRUE(dict_var_1->SetWithStringKey("null_key", PP_MakeNull()));
 245     ASSERT_TRUE(dict_var_1->SetWithStringKey("string_key",
 246                                              string_pp_var.get()));
 247     ASSERT_TRUE(dict_var_1->SetWithStringKey("dict_key", dict_pp_var_2.get()));
 248
 249     ASSERT_TRUE(dict_var_2->SetWithStringKey("undefined_key",
 250                                              PP_MakeUndefined()));
 251     ASSERT_TRUE(dict_var_2->SetWithStringKey("double_key", PP_MakeDouble(1)));
 252     ASSERT_TRUE(dict_var_2->SetWithStringKey("array_key", array_pp_var.get()));
 253
 254     ASSERT_TRUE(array_var->Set(0, PP_MakeInt32(2)));
 255     ASSERT_TRUE(array_var->Set(1, PP_MakeBool(PP_TRUE)));
 256     ASSERT_TRUE(array_var->SetLength(4));
 257
 258     ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var_1.get()));
 259   }
 260
 261   {
 262     // Test that dictionary keys containing '.' are handled correctly.
 263     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
 264     ScopedPPVar dict_pp_var(ScopedPPVar::PassRef(), dict_var->GetPPVar());
 265
 266     ASSERT_TRUE(dict_var->SetWithStringKey("double.key", PP_MakeDouble(1)));
 267     ASSERT_TRUE(dict_var->SetWithStringKey("int.key..name", PP_MakeInt32(2)));
 268
 269     ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var.get()));
 270   }
 271 }
 272
 273 TEST_F(VarValueConversionsTest, CreateVarFromValue) {
 274   {
 275     // Test basic cases for dictionary.
 276     base::DictionaryValue dict_value;
 277     ASSERT_TRUE(ConvertValueAndVerify(dict_value));
 278
 279     dict_value.SetInteger("int_key", 1);
 280     ASSERT_TRUE(ConvertValueAndVerify(dict_value));
 281   }
 282
 283   {
 284     // Test basic cases for array.
 285     base::ListValue list_value;
 286     ASSERT_TRUE(ConvertValueAndVerify(list_value));
 287
 288     list_value.AppendInteger(1);
 289     ASSERT_TRUE(ConvertValueAndVerify(list_value));
 290   }
 291
 292   {
 293     // Test more complex inputs.
 294     base::DictionaryValue dict_value;
 295     dict_value.SetString("string_key", "string_value");
 296     dict_value.SetDouble("dict_key.double_key", 1);
 297
 298     scoped_ptr<base::ListValue> list_value(new base::ListValue());
 299     list_value->AppendInteger(2);
 300     list_value->AppendBoolean(true);
 301     list_value->Append(base::Value::CreateNullValue());
 302
 303     dict_value.Set("dict_key.array_key", list_value.release());
 304
 305     ASSERT_TRUE(ConvertValueAndVerify(dict_value));
 306   }
 307 }
 308
 309 TEST_F(VarValueConversionsTest, CreateListValueFromVarVector) {
 310   {
 311     // Test empty var vector.
 312     scoped_ptr<base::ListValue> list_value(
 313         CreateListValueFromVarVector(std::vector<PP_Var>()));
 314     ASSERT_TRUE(list_value.get());
 315     ASSERT_EQ(0u, list_value->GetSize());
 316   }
 317
 318   {
 319     // Test more complex inputs.
 320     scoped_refptr<StringVar> string_var(new StringVar("string_value"));
 321     ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());
 322
 323     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
 324     ScopedPPVar dict_pp_var(ScopedPPVar::PassRef(), dict_var->GetPPVar());
 325     ASSERT_TRUE(dict_var->SetWithStringKey("null_key", PP_MakeNull()));
 326     ASSERT_TRUE(dict_var->SetWithStringKey("string_key", string_pp_var.get()));
 327
 328     scoped_refptr<ArrayVar> array_var(new ArrayVar());
 329     ScopedPPVar array_pp_var(ScopedPPVar::PassRef(), array_var->GetPPVar());
 330     ASSERT_TRUE(array_var->Set(0, PP_MakeInt32(2)));
 331     ASSERT_TRUE(array_var->Set(1, PP_MakeBool(PP_TRUE)));
 332     ASSERT_TRUE(array_var->SetLength(4));
 333
 334     std::vector<PP_Var> vars;
 335     vars.push_back(dict_pp_var.get());
 336     vars.push_back(string_pp_var.get());
 337     vars.push_back(array_pp_var.get());
 338     vars.push_back(PP_MakeDouble(1));
 339     vars.push_back(PP_MakeUndefined());
 340     vars.push_back(PP_MakeNull());
 341
 342     scoped_ptr<base::ListValue> list_value(CreateListValueFromVarVector(vars));
 343
 344     ASSERT_TRUE(list_value.get());
 345     ASSERT_EQ(vars.size(), list_value->GetSize());
 346
 347     for (size_t i = 0; i < list_value->GetSize(); ++i) {
 348       const base::Value* value = NULL;
 349       ASSERT_TRUE(list_value->Get(i, &value));
 350       ASSERT_TRUE(Equals(*value, vars[i]));
 351     }
 352   }
 353 }
 354
 355 TEST_F(VarValueConversionsTest, CreateVarVectorFromListValue) {
 356   {
 357     // Test empty list.
 358     base::ListValue list_value;
 359     std::vector<PP_Var> vars;
 360     ASSERT_TRUE(CreateVarVectorFromListValue(list_value, &vars));
 361     ASSERT_EQ(0u, vars.size());
 362   }
 363
 364   {
 365     // Test more complex inputs.
 366     base::ListValue list_value;
 367
 368     scoped_ptr<base::DictionaryValue> dict_value(new base::DictionaryValue());
 369     dict_value->SetString("string_key", "string_value");
 370
 371     scoped_ptr<base::ListValue> sub_list_value(new base::ListValue());
 372     sub_list_value->AppendInteger(2);
 373     sub_list_value->AppendBoolean(true);
 374
 375     list_value.Append(dict_value.release());
 376     list_value.AppendString("string_value");
 377     list_value.Append(sub_list_value.release());
 378     list_value.AppendDouble(1);
 379     list_value.Append(base::Value::CreateNullValue());
 380
 381     std::vector<PP_Var> vars;
 382     ASSERT_TRUE(CreateVarVectorFromListValue(list_value, &vars));
 383
 384     ASSERT_EQ(list_value.GetSize(), vars.size());
 385
 386     for (size_t i = 0; i < list_value.GetSize(); ++i) {
 387       const base::Value* value = NULL;
 388       ASSERT_TRUE(list_value.Get(i, &value));
 389       ASSERT_TRUE(Equals(*value, vars[i]));
 390
 391       PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(vars[i]);
 392     }
 393   }
 394 }
 395
 396 }  // namespace ppapi