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::Acquire();
 146   }
 147   virtual void TearDown() {
 148     ASSERT_TRUE(PpapiGlobals::Get()->GetVarTracker()->GetLiveVars().empty());
 149     ProxyLock::Release();
 150   }
 151
 152  private:
 153   TestGlobals globals_;
 154 };
 155
 156 }  // namespace
 157
 158 TEST_F(VarValueConversionsTest, CreateValueFromVar) {
 159   {
 160     // Var holding a ref to itself is not a valid input.
 161     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
 162     ScopedPPVar var_1(ScopedPPVar::PassRef(), dict_var->GetPPVar());
 163     scoped_refptr<ArrayVar> array_var(new ArrayVar());
 164     ScopedPPVar var_2(ScopedPPVar::PassRef(), array_var->GetPPVar());
 165
 166     ASSERT_TRUE(dict_var->SetWithStringKey("key_1", var_2.get()));
 167     ASSERT_TRUE(ConvertVarAndVerify(var_1.get()));
 168
 169     ASSERT_TRUE(array_var->Set(0, var_1.get()));
 170     scoped_ptr<base::Value> value(CreateValueFromVar(var_1.get()));
 171     ASSERT_EQ(NULL, value.get());
 172
 173     // Make sure |var_1| doesn't indirectly hold a ref to itself, otherwise it
 174     // is leaked.
 175     dict_var->DeleteWithStringKey("key_1");
 176   }
 177
 178   // Vars of null or undefined type are converted to null values.
 179   {
 180     ASSERT_TRUE(ConvertVarAndVerify(PP_MakeNull()));
 181     ASSERT_TRUE(ConvertVarAndVerify(PP_MakeUndefined()));
 182   }
 183
 184   {
 185     // Test empty dictionary.
 186     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
 187     ScopedPPVar var(ScopedPPVar::PassRef(), dict_var->GetPPVar());
 188
 189     ASSERT_TRUE(ConvertVarAndVerify(var.get()));
 190   }
 191
 192   {
 193     // Key-value pairs whose value is undefined or null are ignored.
 194     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
 195     ASSERT_TRUE(dict_var->SetWithStringKey("key_1", PP_MakeUndefined()));
 196     ASSERT_TRUE(dict_var->SetWithStringKey("key_2", PP_MakeInt32(1)));
 197     ASSERT_TRUE(dict_var->SetWithStringKey("key_3", PP_MakeNull()));
 198     ScopedPPVar var(ScopedPPVar::PassRef(), dict_var->GetPPVar());
 199
 200     ASSERT_TRUE(ConvertVarAndVerify(var.get()));
 201   }
 202
 203   {
 204     // The same PP_Var is allowed to appear multiple times.
 205     scoped_refptr<DictionaryVar> dict_var_1(new DictionaryVar());
 206     ScopedPPVar dict_pp_var_1(ScopedPPVar::PassRef(), dict_var_1->GetPPVar());
 207     scoped_refptr<DictionaryVar> dict_var_2(new DictionaryVar());
 208     ScopedPPVar dict_pp_var_2(ScopedPPVar::PassRef(), dict_var_2->GetPPVar());
 209     scoped_refptr<StringVar> string_var(new StringVar("string_value"));
 210     ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());
 211
 212     ASSERT_TRUE(dict_var_1->SetWithStringKey("key_1", dict_pp_var_2.get()));
 213     ASSERT_TRUE(dict_var_1->SetWithStringKey("key_2", dict_pp_var_2.get()));
 214     ASSERT_TRUE(dict_var_1->SetWithStringKey("key_3", string_pp_var.get()));
 215     ASSERT_TRUE(dict_var_2->SetWithStringKey("key_4", string_pp_var.get()));
 216
 217     ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var_1.get()));
 218   }
 219
 220   {
 221     // Test basic cases for array.
 222     scoped_refptr<ArrayVar> array_var(new ArrayVar());
 223     ScopedPPVar var(ScopedPPVar::PassRef(), array_var->GetPPVar());
 224
 225     ASSERT_TRUE(ConvertVarAndVerify(var.get()));
 226
 227     ASSERT_TRUE(array_var->Set(0, PP_MakeDouble(1)));
 228
 229     ASSERT_TRUE(ConvertVarAndVerify(var.get()));
 230   }
 231
 232   {
 233     // Test more complex inputs.
 234     scoped_refptr<DictionaryVar> dict_var_1(new DictionaryVar());
 235     ScopedPPVar dict_pp_var_1(ScopedPPVar::PassRef(), dict_var_1->GetPPVar());
 236     scoped_refptr<DictionaryVar> dict_var_2(new DictionaryVar());
 237     ScopedPPVar dict_pp_var_2(ScopedPPVar::PassRef(), dict_var_2->GetPPVar());
 238     scoped_refptr<ArrayVar> array_var(new ArrayVar());
 239     ScopedPPVar array_pp_var(ScopedPPVar::PassRef(), array_var->GetPPVar());
 240     scoped_refptr<StringVar> string_var(new StringVar("string_value"));
 241     ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());
 242
 243     ASSERT_TRUE(dict_var_1->SetWithStringKey("null_key", PP_MakeNull()));
 244     ASSERT_TRUE(dict_var_1->SetWithStringKey("string_key",
 245                                              string_pp_var.get()));
 246     ASSERT_TRUE(dict_var_1->SetWithStringKey("dict_key", dict_pp_var_2.get()));
 247
 248     ASSERT_TRUE(dict_var_2->SetWithStringKey("undefined_key",
 249                                              PP_MakeUndefined()));
 250     ASSERT_TRUE(dict_var_2->SetWithStringKey("double_key", PP_MakeDouble(1)));
 251     ASSERT_TRUE(dict_var_2->SetWithStringKey("array_key", array_pp_var.get()));
 252
 253     ASSERT_TRUE(array_var->Set(0, PP_MakeInt32(2)));
 254     ASSERT_TRUE(array_var->Set(1, PP_MakeBool(PP_TRUE)));
 255     ASSERT_TRUE(array_var->SetLength(4));
 256
 257     ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var_1.get()));
 258   }
 259
 260   {
 261     // Test that dictionary keys containing '.' are handled correctly.
 262     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
 263     ScopedPPVar dict_pp_var(ScopedPPVar::PassRef(), dict_var->GetPPVar());
 264
 265     ASSERT_TRUE(dict_var->SetWithStringKey("double.key", PP_MakeDouble(1)));
 266     ASSERT_TRUE(dict_var->SetWithStringKey("int.key..name", PP_MakeInt32(2)));
 267
 268     ASSERT_TRUE(ConvertVarAndVerify(dict_pp_var.get()));
 269   }
 270 }
 271
 272 TEST_F(VarValueConversionsTest, CreateVarFromValue) {
 273   {
 274     // Test basic cases for dictionary.
 275     base::DictionaryValue dict_value;
 276     ASSERT_TRUE(ConvertValueAndVerify(dict_value));
 277
 278     dict_value.SetInteger("int_key", 1);
 279     ASSERT_TRUE(ConvertValueAndVerify(dict_value));
 280   }
 281
 282   {
 283     // Test basic cases for array.
 284     base::ListValue list_value;
 285     ASSERT_TRUE(ConvertValueAndVerify(list_value));
 286
 287     list_value.AppendInteger(1);
 288     ASSERT_TRUE(ConvertValueAndVerify(list_value));
 289   }
 290
 291   {
 292     // Test more complex inputs.
 293     base::DictionaryValue dict_value;
 294     dict_value.SetString("string_key", "string_value");
 295     dict_value.SetDouble("dict_key.double_key", 1);
 296
 297     scoped_ptr<base::ListValue> list_value(new base::ListValue());
 298     list_value->AppendInteger(2);
 299     list_value->AppendBoolean(true);
 300     list_value->Append(base::Value::CreateNullValue());
 301
 302     dict_value.Set("dict_key.array_key", list_value.release());
 303
 304     ASSERT_TRUE(ConvertValueAndVerify(dict_value));
 305   }
 306 }
 307
 308 TEST_F(VarValueConversionsTest, CreateListValueFromVarVector) {
 309   {
 310     // Test empty var vector.
 311     scoped_ptr<base::ListValue> list_value(
 312         CreateListValueFromVarVector(std::vector<PP_Var>()));
 313     ASSERT_TRUE(list_value.get());
 314     ASSERT_EQ(0u, list_value->GetSize());
 315   }
 316
 317   {
 318     // Test more complex inputs.
 319     scoped_refptr<StringVar> string_var(new StringVar("string_value"));
 320     ScopedPPVar string_pp_var(ScopedPPVar::PassRef(), string_var->GetPPVar());
 321
 322     scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
 323     ScopedPPVar dict_pp_var(ScopedPPVar::PassRef(), dict_var->GetPPVar());
 324     ASSERT_TRUE(dict_var->SetWithStringKey("null_key", PP_MakeNull()));
 325     ASSERT_TRUE(dict_var->SetWithStringKey("string_key", string_pp_var.get()));
 326
 327     scoped_refptr<ArrayVar> array_var(new ArrayVar());
 328     ScopedPPVar array_pp_var(ScopedPPVar::PassRef(), array_var->GetPPVar());
 329     ASSERT_TRUE(array_var->Set(0, PP_MakeInt32(2)));
 330     ASSERT_TRUE(array_var->Set(1, PP_MakeBool(PP_TRUE)));
 331     ASSERT_TRUE(array_var->SetLength(4));
 332
 333     std::vector<PP_Var> vars;
 334     vars.push_back(dict_pp_var.get());
 335     vars.push_back(string_pp_var.get());
 336     vars.push_back(array_pp_var.get());
 337     vars.push_back(PP_MakeDouble(1));
 338     vars.push_back(PP_MakeUndefined());
 339     vars.push_back(PP_MakeNull());
 340
 341     scoped_ptr<base::ListValue> list_value(CreateListValueFromVarVector(vars));
 342
 343     ASSERT_TRUE(list_value.get());
 344     ASSERT_EQ(vars.size(), list_value->GetSize());
 345
 346     for (size_t i = 0; i < list_value->GetSize(); ++i) {
 347       const base::Value* value = NULL;
 348       ASSERT_TRUE(list_value->Get(i, &value));
 349       ASSERT_TRUE(Equals(*value, vars[i]));
 350     }
 351   }
 352 }
 353
 354 TEST_F(VarValueConversionsTest, CreateVarVectorFromListValue) {
 355   {
 356     // Test empty list.
 357     base::ListValue list_value;
 358     std::vector<PP_Var> vars;
 359     ASSERT_TRUE(CreateVarVectorFromListValue(list_value, &vars));
 360     ASSERT_EQ(0u, vars.size());
 361   }
 362
 363   {
 364     // Test more complex inputs.
 365     base::ListValue list_value;
 366
 367     scoped_ptr<base::DictionaryValue> dict_value(new base::DictionaryValue());
 368     dict_value->SetString("string_key", "string_value");
 369
 370     scoped_ptr<base::ListValue> sub_list_value(new base::ListValue());
 371     sub_list_value->AppendInteger(2);
 372     sub_list_value->AppendBoolean(true);
 373
 374     list_value.Append(dict_value.release());
 375     list_value.AppendString("string_value");
 376     list_value.Append(sub_list_value.release());
 377     list_value.AppendDouble(1);
 378     list_value.Append(base::Value::CreateNullValue());
 379
 380     std::vector<PP_Var> vars;
 381     ASSERT_TRUE(CreateVarVectorFromListValue(list_value, &vars));
 382
 383     ASSERT_EQ(list_value.GetSize(), vars.size());
 384
 385     for (size_t i = 0; i < list_value.GetSize(); ++i) {
 386       const base::Value* value = NULL;
 387       ASSERT_TRUE(list_value.Get(i, &value));
 388       ASSERT_TRUE(Equals(*value, vars[i]));
 389
 390       PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(vars[i]);
 391     }
 392   }
 393 }
 394
 395 }  // namespace ppapi