Don't send PP_Vars/V8 values with cycles across PostMessage

webkit/plugins/ppapi/v8_var_converter_unittest.cc

 // Copyright (c) 2012 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 "webkit/plugins/ppapi/v8_var_converter.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 135 matching lines @@
     context_ = v8::Persistent<v8::Context>(
         isolate, v8::Context::New(isolate, NULL, global));
   }
   virtual void TearDown() {
     context_.Dispose(context_->GetIsolate());
     ASSERT_TRUE(PpapiGlobals::Get()->GetVarTracker()->GetLiveVars().empty());
     ProxyLock::Release();
   }
 
  protected:
-  bool RoundTrip(const PP_Var& var, PP_Var* result) {
-    V8VarConverter converter;
+  bool RoundTrip(const PP_Var& var, PP_Var* result, bool allow_cycles) {
+    V8VarConverter converter(allow_cycles);
     v8::Context::Scope context_scope(context_);
     v8::HandleScope handle_scope;
     v8::Handle<v8::Value> v8_result;
     if (!converter.ToV8Value(var, context_, &v8_result))
       return false;
     if (!Equals(var, v8_result))
       return false;
     if (!converter.FromV8Value(v8_result, context_, result))
       return false;
     return true;
   }
 
   // Assumes a ref for var.
   bool RoundTripAndCompare(const PP_Var& var) {
     ScopedPPVar expected(ScopedPPVar::PassRef(), var);
     PP_Var actual_var;
-    if (!RoundTrip(expected.get(), &actual_var))
+    if (!RoundTrip(expected.get(), &actual_var, false))
       return false;
     ScopedPPVar actual(ScopedPPVar::PassRef(), actual_var);
     return TestEqual(expected.get(), actual.get());
   }
 
   // Context for the JavaScript in the test.
   v8::Persistent<v8::Context> context_;
 
  private:
   TestGlobals globals_;
@@ skipping 77 matching lines @@
   EXPECT_TRUE(RoundTripAndCompare(dictionary->GetPPVar()));
 
   // Array with dictionary.
   array->Set(index++, release_dictionary.get());
   EXPECT_TRUE(RoundTripAndCompare(array->GetPPVar()));
 
   // Array with dictionary with array.
   array2->Set(0, PP_MakeInt32(100));
   dictionary->SetWithStringKey("9", release_array2.get());
   EXPECT_TRUE(RoundTripAndCompare(array->GetPPVar()));
+}
+
+TEST_F(V8VarConverterTest, Cycles) {
+  v8::Context::Scope context_scope(context_);
+  v8::HandleScope handle_scope;
+  scoped_refptr<DictionaryVar> dictionary(new DictionaryVar);
+  ScopedPPVar release_dictionary(ScopedPPVar::PassRef(),
+                                 dictionary->GetPPVar());
+  scoped_refptr<ArrayVar> array(new ArrayVar);
+  ScopedPPVar release_array(ScopedPPVar::PassRef(), array->GetPPVar());
+
+  dictionary->SetWithStringKey("1", PP_MakeUndefined());
+  dictionary->SetWithStringKey("2", PP_MakeNull());
+  dictionary->SetWithStringKey("3", PP_MakeInt32(-100));
+  dictionary->SetWithStringKey("4", PP_MakeBool(PP_TRUE));
+  dictionary->SetWithStringKey("5", PP_MakeDouble(-103.52));
+  dictionary->SetWithStringKey("6", release_array.get());
+
+  array->Set(0, PP_MakeUndefined());
+  array->Set(1, PP_MakeNull());
+  array->Set(2, PP_MakeInt32(100));
+  array->Set(3, PP_MakeBool(PP_FALSE));
+  array->Set(4, PP_MakeDouble(0.123));
+  array->Set(5, release_dictionary.get());
+
+  V8VarConverter converter_with_cycles(true);
+  V8VarConverter converter_without_cycles(false);
+  PP_Var var_result;
+  v8::Handle<v8::Value> v8_result;
 
   // Array <-> dictionary cycle.
-  dictionary->SetWithStringKey("10", release_array.get());
-  PP_Var result_var;
-  EXPECT_TRUE(RoundTrip(release_dictionary.get(), &result_var));
-  ScopedPPVar result = ScopedPPVar(ScopedPPVar::PassRef(), result_var);
-  EXPECT_TRUE(TestEqual(release_dictionary.get(), result.get()));
+  dictionary->SetWithStringKey("6", release_array.get());
+  ASSERT_FALSE(converter_without_cycles.ToV8Value(release_dictionary.get(),
+                                                  context_, &v8_result));
+  ASSERT_TRUE(converter_with_cycles.ToV8Value(release_dictionary.get(),
+                                              context_, &v8_result));
+  ASSERT_TRUE(Equals(release_dictionary.get(), v8_result));
+  ASSERT_FALSE(converter_without_cycles.FromV8Value(v8_result,
+                                                    context_, &var_result));
+  ASSERT_TRUE(converter_with_cycles.FromV8Value(v8_result,
+                                                context_, &var_result));
+  ScopedPPVar release_result = ScopedPPVar(ScopedPPVar::PassRef(), var_result);
+  EXPECT_TRUE(TestEqual(release_dictionary.get(), release_result.get()));
   // Break the cycle.
   // TODO(raymes): We need some better machinery for releasing vars with
   // cycles. Remove the code below once we have that.
-  dictionary->DeleteWithStringKey("10");
-  DictionaryVar* result_dictionary = DictionaryVar::FromPPVar(result.get());
-  result_dictionary->DeleteWithStringKey("10");
+  dictionary->DeleteWithStringKey("6");
+  DictionaryVar* result_dictionary = DictionaryVar::FromPPVar(
+      release_result.get());
+  result_dictionary->DeleteWithStringKey("6");
 
   // Array with self references.
-  array->Set(index, release_array.get());
-  EXPECT_TRUE(RoundTrip(release_array.get(), &result_var));
-  result = ScopedPPVar(ScopedPPVar::PassRef(), result_var);
-  EXPECT_TRUE(TestEqual(release_array.get(), result.get()));
+  array->Set(5, release_array.get());
+  ASSERT_FALSE(converter_without_cycles.ToV8Value(release_array.get(),
+                                                  context_, &v8_result));
+  ASSERT_TRUE(converter_with_cycles.ToV8Value(release_array.get(),
+                                               context_, &v8_result));
+  ASSERT_TRUE(Equals(release_array.get(), v8_result));
+  ASSERT_FALSE(converter_without_cycles.FromV8Value(v8_result,
+                                                    context_, &var_result));
+  ASSERT_TRUE(converter_with_cycles.FromV8Value(v8_result,
+                                                context_, &var_result));
+  release_result = ScopedPPVar(ScopedPPVar::PassRef(), var_result);
+  EXPECT_TRUE(TestEqual(release_array.get(), release_result.get()));
   // Break the self reference.
-  array->Set(index, PP_MakeUndefined());
-  ArrayVar* result_array = ArrayVar::FromPPVar(result.get());
-  result_array->Set(index, PP_MakeUndefined());
+  array->Set(5, PP_MakeUndefined());
+  ArrayVar* result_array = ArrayVar::FromPPVar(release_result.get());
+  result_array->Set(5, PP_MakeUndefined());
 }
 
 TEST_F(V8VarConverterTest, StrangeDictionaryKeyTest) {
   {
     // Test keys with '.'.
     scoped_refptr<DictionaryVar> dictionary(new DictionaryVar);
     dictionary->SetWithStringKey(".", PP_MakeUndefined());
     dictionary->SetWithStringKey("x.y", PP_MakeUndefined());
     EXPECT_TRUE(RoundTripAndCompare(dictionary->GetPPVar()));
   }
@@ skipping 11 matching lines @@
           "false: 'qux',"
           "null: 'quux',"
           "undefined: 'oops'"
         "};"
         "})();";
 
     v8::Handle<v8::Script> script(v8::Script::New(v8::String::New(source)));
     v8::Handle<v8::Object> object = script->Run().As<v8::Object>();
     ASSERT_FALSE(object.IsEmpty());
 
-    V8VarConverter converter;
+    V8VarConverter converter(false);
     PP_Var actual;
     ASSERT_TRUE(converter.FromV8Value(object, context_, &actual));
     ScopedPPVar release_actual(ScopedPPVar::PassRef(), actual);
 
     scoped_refptr<DictionaryVar> expected(new DictionaryVar);
     ScopedPPVar foo(ScopedPPVar::PassRef(), StringVar::StringToPPVar("foo"));
     expected->SetWithStringKey("1", foo.get());
     ScopedPPVar bar(ScopedPPVar::PassRef(), StringVar::StringToPPVar("bar"));
     expected->SetWithStringKey("2", bar.get());
     ScopedPPVar baz(ScopedPPVar::PassRef(), StringVar::StringToPPVar("baz"));
     expected->SetWithStringKey("true", baz.get());
     ScopedPPVar qux(ScopedPPVar::PassRef(), StringVar::StringToPPVar("qux"));
     expected->SetWithStringKey("false", qux.get());
     ScopedPPVar quux(ScopedPPVar::PassRef(), StringVar::StringToPPVar("quux"));
     expected->SetWithStringKey("null", quux.get());
     ScopedPPVar oops(ScopedPPVar::PassRef(), StringVar::StringToPPVar("oops"));
     expected->SetWithStringKey("undefined", oops.get());
     ScopedPPVar release_expected(
         ScopedPPVar::PassRef(), expected->GetPPVar());
 
     ASSERT_TRUE(TestEqual(release_expected.get(), release_actual.get()));
   }
 }
 
 }  // namespace ppapi
 }  // namespace webkit