Proxy PPB_Var, fix o-o-p string var id tracking.

ppapi/tests/test_var_deprecated.cc

 // Copyright (c) 2011 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/tests/test_var_deprecated.h"
 
 #include <string.h>
 
 #include <limits>
 
+#include "base/basictypes.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/cpp/dev/scriptable_object_deprecated.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/private/var_private.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/tests/testing_instance.h"
 
@@ skipping 39 matching lines @@
   }
 
   return pp::Var();
 }
 
 }  // namespace
 
 REGISTER_TEST_CASE(VarDeprecated);
 
 bool TestVarDeprecated::Init() {
-  var_interface_ = reinterpret_cast<PPB_Var_Deprecated const*>(
+  var_interface_ = static_cast<const PPB_Var_Deprecated*>(
       pp::Module::Get()->GetBrowserInterface(PPB_VAR_DEPRECATED_INTERFACE));
   return var_interface_ && InitTestingInterface();
 }
 
 void TestVarDeprecated::RunTest() {
   RUN_TEST(BasicString);
   RUN_TEST(InvalidAndEmpty);
   RUN_TEST(InvalidUtf8);
   RUN_TEST(NullInputInUtf8Conversion);
   RUN_TEST(ValidUtf8);
   RUN_TEST(Utf8WithEmbeddedNulls);
   RUN_TEST(VarToUtf8ForWrongType);
   RUN_TEST(HasPropertyAndMethod);
   RUN_TEST(PassReference);
 }
 
 pp::deprecated::ScriptableObject* TestVarDeprecated::CreateTestObject() {
   return new VarScriptableObject(this);
 }
 
 std::string TestVarDeprecated::TestBasicString() {
   uint32_t before_object = testing_interface_->GetLiveObjectsForInstance(
       instance_->pp_instance());
   {
-    const uint32_t kStrLen = 5;
-    const char kStr[kStrLen + 1] = "Hello";
+    const char kStr[] = "Hello";
+    const uint32_t kStrLen(arraysize(kStr) - 1);
     PP_Var str = var_interface_->VarFromUtf8(pp::Module::Get()->pp_module(),
-                                             kStr, sizeof(kStr) - 1);
+                                             kStr, kStrLen);
     ASSERT_EQ(PP_VARTYPE_STRING, str.type);
 
     // Reading back the string should work.
     uint32_t len = 0;
     const char* result = var_interface_->VarToUtf8(str, &len);
     ASSERT_EQ(kStrLen, len);
     ASSERT_EQ(0, strncmp(kStr, result, kStrLen));
 
     // Destroy the string, readback should now fail.
     var_interface_->Release(str);
-    /*
-    Note: this will crash in the current out-of-process implementation since
-    we don't do actual tracking of strings (we just convert the ID to a
-    pointer).
-    TODO(brettw) This should be fixed and this checking code re-enabled.
     result = var_interface_->VarToUtf8(str, &len);
     ASSERT_EQ(0, len);
     ASSERT_EQ(NULL, result);
-    */
   }
 
   // Make sure nothing leaked.
   ASSERT_TRUE(testing_interface_->GetLiveObjectsForInstance(
       instance_->pp_instance()) == before_object);
 
   PASS();
 }
 
 std::string TestVarDeprecated::TestInvalidAndEmpty() {
@@ skipping 22 matching lines @@
   ASSERT_NE(NULL, result);
 
   PASS();
 }
 
 std::string TestVarDeprecated::TestInvalidUtf8() {
   // utf8じゃない (japanese for "is not utf8") in shift-jis encoding.
   static const char kSjisString[] = "utf8\x82\xb6\x82\xe1\x82\xc8\x82\xa2";
   pp::Var sjis(kSjisString);
   if (!sjis.is_null())
-    return "Non-UTF8 string permitted.";
+    return "Non-UTF8 string was permitted erroneously.";
 
   PASS();
 }
 
 std::string TestVarDeprecated::TestNullInputInUtf8Conversion() {
   // This test talks directly to the C interface to access edge cases that
   // cannot be exercised via the C++ interface.
   PP_Var converted_string;
 
   // 0-length string should not dereference input string, and should produce
@@ skipping 224 matching lines @@
   // If the reference counting works, the object should be valid. We can test
   // this by executing it (it was a function we defined above) and it should
   // return "works" concatenated with the argument.
   pp::VarPrivate function(var_from_page_);
   pp::Var result = var_from_page_.Call(pp::Var(), "nice");
   ASSERT_TRUE(result.is_string());
   ASSERT_TRUE(result.AsString() == "worksnice");
 
   PASS();
 }