ppapi/tests/test_var_deprecated.cc

   1 // Copyright (c) 2011 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/tests/test_var_deprecated.h"
   6
   7 #include <string.h>
   8
   9 #include <limits>
  10
  11 #include "ppapi/c/pp_var.h"
  12 #include "ppapi/c/dev/ppb_testing_dev.h"
  13 #include "ppapi/c/dev/ppb_var_deprecated.h"
  14 #include "ppapi/cpp/dev/scriptable_object_deprecated.h"
  15 #include "ppapi/cpp/instance.h"
  16 #include "ppapi/cpp/module.h"
  17 #include "ppapi/cpp/private/var_private.h"
  18 #include "ppapi/cpp/var.h"
  19 #include "ppapi/tests/testing_instance.h"
  20
  21 namespace {
  22
  23 uint32_t kInvalidLength = static_cast<uint32_t>(-1);
  24
  25 static const char kSetValueFunction[] = "SetValue";
  26
  27 // ScriptableObject used by the var tests.
  28 class VarScriptableObject : public pp::deprecated::ScriptableObject {
  29  public:
  30   VarScriptableObject(TestVarDeprecated* v) : test_var_deprecated_(v) {}
  31
  32   // pp::deprecated::ScriptableObject overrides.
  33   bool HasMethod(const pp::Var& name, pp::Var* exception);
  34   pp::Var Call(const pp::Var& name,
  35                const std::vector<pp::Var>& args,
  36                pp::Var* exception);
  37
  38  private:
  39   TestVarDeprecated* test_var_deprecated_;
  40 };
  41
  42 bool VarScriptableObject::HasMethod(const pp::Var& name, pp::Var* exception) {
  43   if (!name.is_string())
  44     return false;
  45   return name.AsString() == kSetValueFunction;
  46 }
  47
  48 pp::Var VarScriptableObject::Call(const pp::Var& method_name,
  49                                   const std::vector<pp::Var>& args,
  50                                   pp::Var* exception) {
  51   if (!method_name.is_string())
  52     return false;
  53   std::string name = method_name.AsString();
  54
  55   if (name == kSetValueFunction) {
  56     if (args.size() != 1)
  57       *exception = pp::Var("Bad argument to SetValue(<value>)");
  58     else
  59       test_var_deprecated_->set_var_from_page(pp::VarPrivate(args[0]));
  60   }
  61
  62   return pp::Var();
  63 }
  64
  65 }  // namespace
  66
  67 REGISTER_TEST_CASE(VarDeprecated);
  68
  69 bool TestVarDeprecated::Init() {
  70   var_interface_ = static_cast<const PPB_Var_Deprecated*>(
  71       pp::Module::Get()->GetBrowserInterface(PPB_VAR_DEPRECATED_INTERFACE));
  72   return var_interface_ && CheckTestingInterface();
  73 }
  74
  75 void TestVarDeprecated::RunTests(const std::string& filter) {
  76   RUN_TEST(BasicString, filter);
  77   RUN_TEST(InvalidAndEmpty, filter);
  78   RUN_TEST(InvalidUtf8, filter);
  79   RUN_TEST(NullInputInUtf8Conversion, filter);
  80   RUN_TEST(ValidUtf8, filter);
  81   RUN_TEST(Utf8WithEmbeddedNulls, filter);
  82   RUN_TEST(VarToUtf8ForWrongType, filter);
  83   RUN_TEST(HasPropertyAndMethod, filter);
  84   RUN_TEST(PassReference, filter);
  85 }
  86
  87 pp::deprecated::ScriptableObject* TestVarDeprecated::CreateTestObject() {
  88   return new VarScriptableObject(this);
  89 }
  90
  91 std::string TestVarDeprecated::TestBasicString() {
  92   uint32_t before_object = testing_interface_->GetLiveObjectsForInstance(
  93       instance_->pp_instance());
  94   {
  95     const char kStr[] = "Hello";
  96     const uint32_t kStrLen(sizeof(kStr) - 1);
  97     PP_Var str = var_interface_->VarFromUtf8(pp::Module::Get()->pp_module(),
  98                                              kStr, kStrLen);
  99     ASSERT_EQ(PP_VARTYPE_STRING, str.type);
 100
 101     // Reading back the string should work.
 102     uint32_t len = 0;
 103     const char* result = var_interface_->VarToUtf8(str, &len);
 104     ASSERT_EQ(kStrLen, len);
 105     ASSERT_EQ(0, strncmp(kStr, result, kStrLen));
 106
 107     // Destroy the string, readback should now fail.
 108     var_interface_->Release(str);
 109     result = var_interface_->VarToUtf8(str, &len);
 110     ASSERT_EQ(0, len);
 111     ASSERT_EQ(NULL, result);
 112   }
 113
 114   // Make sure nothing leaked.
 115   ASSERT_TRUE(testing_interface_->GetLiveObjectsForInstance(
 116       instance_->pp_instance()) == before_object);
 117
 118   PASS();
 119 }
 120
 121 std::string TestVarDeprecated::TestInvalidAndEmpty() {
 122   PP_Var invalid_string;
 123   invalid_string.type = PP_VARTYPE_STRING;
 124   invalid_string.value.as_id = 31415926;
 125
 126   // Invalid strings should give NULL as the return value.
 127   uint32_t len = std::numeric_limits<uint32_t>::max();
 128   const char* result = var_interface_->VarToUtf8(invalid_string, &len);
 129   ASSERT_EQ(0, len);
 130   ASSERT_EQ(NULL, result);
 131
 132   // Same with vars that are not strings.
 133   len = std::numeric_limits<uint32_t>::max();
 134   pp::Var int_var(42);
 135   result = var_interface_->VarToUtf8(int_var.pp_var(), &len);
 136   ASSERT_EQ(0, len);
 137   ASSERT_EQ(NULL, result);
 138
 139   // Empty strings should return non-NULL.
 140   pp::Var empty_string("");
 141   len = std::numeric_limits<uint32_t>::max();
 142   result = var_interface_->VarToUtf8(empty_string.pp_var(), &len);
 143   ASSERT_EQ(0, len);
 144   ASSERT_NE(NULL, result);
 145
 146   PASS();
 147 }
 148
 149 std::string TestVarDeprecated::TestInvalidUtf8() {
 150   // utf8じゃない (japanese for "is not utf8") in shift-jis encoding.
 151   static const char kSjisString[] = "utf8\x82\xb6\x82\xe1\x82\xc8\x82\xa2";
 152   pp::Var sjis(kSjisString);
 153   if (!sjis.is_null())
 154     return "Non-UTF8 string was permitted erroneously.";
 155
 156   PASS();
 157 }
 158
 159 std::string TestVarDeprecated::TestNullInputInUtf8Conversion() {
 160   // This test talks directly to the C interface to access edge cases that
 161   // cannot be exercised via the C++ interface.
 162   PP_Var converted_string;
 163
 164   // 0-length string should not dereference input string, and should produce
 165   // an empty string.
 166   converted_string = var_interface_->VarFromUtf8(
 167       pp::Module::Get()->pp_module(), NULL, 0);
 168   if (converted_string.type != PP_VARTYPE_STRING) {
 169     return "Expected 0 length to return empty string.";
 170   }
 171
 172   // Now convert it back.
 173   uint32_t length = kInvalidLength;
 174   const char* result = NULL;
 175   result = var_interface_->VarToUtf8(converted_string, &length);
 176   if (length != 0) {
 177     return "Expected 0 length string on conversion.";
 178   }
 179   if (result == NULL) {
 180     return "Expected a non-null result for 0-lengthed string from VarToUtf8.";
 181   }
 182   var_interface_->Release(converted_string);
 183
 184   // Should not crash, and make an empty string.
 185   const char* null_string = NULL;
 186   pp::Var null_var(null_string);
 187   if (!null_var.is_string() || null_var.AsString() != "") {
 188     return "Expected NULL input to make an empty string Var.";
 189   }
 190
 191   PASS();
 192 }
 193
 194 std::string TestVarDeprecated::TestValidUtf8() {
 195   // From UTF8 string -> PP_Var.
 196   // Chinese for "I am utf8."
 197   static const char kValidUtf8[] = "\xe6\x88\x91\xe6\x98\xafutf8.";
 198   pp::Var converted_string(kValidUtf8);
 199
 200   if (converted_string.is_null())
 201     return "Unable to convert valid utf8 to var.";
 202
 203   // Since we're already here, test PP_Var back to UTF8 string.
 204   std::string returned_string = converted_string.AsString();
 205
 206   // We need to check against 1 less than sizeof because the resulting string
 207   // is technically not NULL terminated by API design.
 208   if (returned_string.size() != sizeof(kValidUtf8) - 1) {
 209     return "Unable to convert utf8 string back from var.";
 210   }
 211   if (returned_string != kValidUtf8) {
 212     return "String mismatches on conversion back from PP_Var.";
 213   }
 214
 215   PASS();
 216 }
 217
 218 std::string TestVarDeprecated::TestUtf8WithEmbeddedNulls() {
 219   // From UTF8 string with embedded nulls -> PP_Var.
 220   // Chinese for "also utf8."
 221   static const char kUtf8WithEmbededNull[] = "\xe6\xb9\x9f\xe6\x98\xaf\0utf8.";
 222   std::string orig_string(kUtf8WithEmbededNull,
 223                           sizeof(kUtf8WithEmbededNull) -1);
 224   pp::Var converted_string(orig_string);
 225
 226   if (converted_string.is_null())
 227     return "Unable to convert utf8 with embedded nulls to var.";
 228
 229   // Since we're already here, test PP_Var back to UTF8 string.
 230   std::string returned_string = converted_string.AsString();
 231
 232   if (returned_string.size() != orig_string.size()) {
 233     return "Unable to convert utf8 with embedded nulls back from var.";
 234   }
 235   if (returned_string != orig_string) {
 236     return "String mismatches on conversion back from PP_Var.";
 237   }
 238
 239   PASS();
 240 }
 241
 242 std::string TestVarDeprecated::TestVarToUtf8ForWrongType() {
 243   uint32_t length = kInvalidLength;
 244   const char* result = NULL;
 245   result = var_interface_->VarToUtf8(PP_MakeUndefined(), &length);
 246   if (length != 0) {
 247     return "Expected 0 on string conversion from Void var.";
 248   }
 249   if (result != NULL) {
 250     return "Expected NULL on string conversion from Void var.";
 251   }
 252
 253   length = kInvalidLength;
 254   result = NULL;
 255   result = var_interface_->VarToUtf8(PP_MakeNull(), &length);
 256   if (length != 0) {
 257     return "Expected 0 on string conversion from Null var.";
 258   }
 259   if (result != NULL) {
 260     return "Expected NULL on string conversion from Null var.";
 261   }
 262
 263   length = kInvalidLength;
 264   result = NULL;
 265   result = var_interface_->VarToUtf8(PP_MakeBool(PP_TRUE), &length);
 266   if (length != 0) {
 267     return "Expected 0 on string conversion from Bool var.";
 268   }
 269   if (result != NULL) {
 270     return "Expected NULL on string conversion from Bool var.";
 271   }
 272
 273   length = kInvalidLength;
 274   result = NULL;
 275   result = var_interface_->VarToUtf8(PP_MakeInt32(1), &length);
 276   if (length != 0) {
 277     return "Expected 0 on string conversion from Int32 var.";
 278   }
 279   if (result != NULL) {
 280     return "Expected NULL on string conversion from Int32 var.";
 281   }
 282
 283   length = kInvalidLength;
 284   result = NULL;
 285   result = var_interface_->VarToUtf8(PP_MakeDouble(1.0), &length);
 286   if (length != 0) {
 287     return "Expected 0 on string conversion from Double var.";
 288   }
 289   if (result != NULL) {
 290     return "Expected NULL on string conversion from Double var.";
 291   }
 292
 293   PASS();
 294 }
 295
 296 std::string TestVarDeprecated::TestHasPropertyAndMethod() {
 297   pp::VarPrivate window = instance_->GetWindowObject();
 298   ASSERT_TRUE(window.is_object());
 299
 300   // Regular property.
 301   pp::Var exception;
 302   ASSERT_TRUE(window.HasProperty("scrollX", &exception));
 303   ASSERT_TRUE(exception.is_undefined());
 304   ASSERT_FALSE(window.HasMethod("scrollX", &exception));
 305   ASSERT_TRUE(exception.is_undefined());
 306
 307   // Regular method (also counts as HasProperty).
 308   ASSERT_TRUE(window.HasProperty("find", &exception));
 309   ASSERT_TRUE(exception.is_undefined());
 310   ASSERT_TRUE(window.HasMethod("find", &exception));
 311   ASSERT_TRUE(exception.is_undefined());
 312
 313   // Nonexistant ones should return false and not set the exception.
 314   ASSERT_FALSE(window.HasProperty("superEvilBit", &exception));
 315   ASSERT_TRUE(exception.is_undefined());
 316   ASSERT_FALSE(window.HasMethod("superEvilBit", &exception));
 317   ASSERT_TRUE(exception.is_undefined());
 318
 319   // Check exception and return false on invalid property name.
 320   ASSERT_FALSE(window.HasProperty(3.14159, &exception));
 321   ASSERT_FALSE(exception.is_undefined());
 322   exception = pp::Var();
 323
 324   exception = pp::Var();
 325   ASSERT_FALSE(window.HasMethod(3.14159, &exception));
 326   ASSERT_FALSE(exception.is_undefined());
 327
 328   // Try to use something not an object.
 329   exception = pp::Var();
 330   pp::VarPrivate string_object("asdf");
 331   ASSERT_FALSE(string_object.HasProperty("find", &exception));
 332   ASSERT_FALSE(exception.is_undefined());
 333   exception = pp::Var();
 334   ASSERT_FALSE(string_object.HasMethod("find", &exception));
 335   ASSERT_FALSE(exception.is_undefined());
 336
 337   // Try to use an invalid object (need to use the C API).
 338   PP_Var invalid_object;
 339   invalid_object.type = PP_VARTYPE_OBJECT;
 340   invalid_object.value.as_id = static_cast<int64_t>(-1234567);
 341   PP_Var exception2 = PP_MakeUndefined();
 342   ASSERT_FALSE(var_interface_->HasProperty(invalid_object,
 343                                            pp::Var("find").pp_var(),
 344                                            &exception2));
 345   ASSERT_NE(PP_VARTYPE_UNDEFINED, exception2.type);
 346   var_interface_->Release(exception2);
 347
 348   exception2 = PP_MakeUndefined();
 349   ASSERT_FALSE(var_interface_->HasMethod(invalid_object,
 350                                          pp::Var("find").pp_var(),
 351                                          &exception2));
 352   ASSERT_NE(PP_VARTYPE_UNDEFINED, exception2.type);
 353   var_interface_->Release(exception2);
 354
 355   // Getting a valid property/method when the exception is set returns false.
 356   exception = pp::Var("Bad something-or-other exception");
 357   ASSERT_FALSE(window.HasProperty("find", &exception));
 358   ASSERT_FALSE(exception.is_undefined());
 359   ASSERT_FALSE(window.HasMethod("find", &exception));
 360   ASSERT_FALSE(exception.is_undefined());
 361
 362   PASS();
 363 }
 364
 365 // Tests that when the page sends an object to the plugin via a function call,
 366 // that the refcounting works properly (bug 79813).
 367 std::string TestVarDeprecated::TestPassReference() {
 368   var_from_page_ = pp::Var();
 369
 370   // Send a JS object from the page to the plugin.
 371   pp::Var exception;
 372   pp::Var ret = instance_->ExecuteScript(
 373       "document.getElementById('plugin').SetValue(function(arg) {"
 374           "return 'works' + arg;"
 375       "})",
 376       &exception);
 377   ASSERT_TRUE(exception.is_undefined());
 378
 379   // We should have gotten an object set for our var_from_page.
 380   ASSERT_TRUE(var_from_page_.is_object());
 381
 382   // If the reference counting works, the object should be valid. We can test
 383   // this by executing it (it was a function we defined above) and it should
 384   // return "works" concatenated with the argument.
 385   pp::VarPrivate function(var_from_page_);
 386   pp::Var result = var_from_page_.Call(pp::Var(), "nice");
 387   ASSERT_TRUE(result.is_string());
 388   ASSERT_TRUE(result.AsString() == "worksnice");
 389
 390   // Reset var_from_page_ so it doesn't seem like a leak to the var leak
 391   // checking code.
 392   var_from_page_ = pp::Var();
 393
 394   PASS();
 395 }
 396