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

ppapi/proxy/raw_var_data_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 "ppapi/proxy/raw_var_data.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/shared_impl/array_var.h"
 #include "ppapi/shared_impl/dictionary_var.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/shared_impl/test_globals.h"
 #include "ppapi/shared_impl/unittest_utils.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
+void DefaultHandleWriter(IPC::Message* m, const SerializedHandle& handle) {
+  IPC::ParamTraits<SerializedHandle>::Write(m, handle);
+}
+
 class RawVarDataTest : public testing::Test {
  public:
   RawVarDataTest() {}
   ~RawVarDataTest() {}
 
   // testing::Test implementation.
   virtual void SetUp() {
     ProxyLock::Acquire();
   }
   virtual void TearDown() {
     ASSERT_TRUE(PpapiGlobals::Get()->GetVarTracker()->GetLiveVars().empty());
     ProxyLock::Release();
   }
 
  private:
   TestGlobals globals_;
 };
 
-PP_Var WriteAndRead(const PP_Var& var) {
+bool WriteAndRead(const PP_Var& var, PP_Var* result) {
   PP_Instance dummy_instance = 1234;
   scoped_ptr<RawVarDataGraph> expected_data(RawVarDataGraph::Create(
       var, dummy_instance));
+  if (!expected_data)
+    return false;
   IPC::Message m;
-  expected_data->Write(&m);
+  expected_data->Write(&m, base::Bind(&DefaultHandleWriter));
   PickleIterator iter(m);
   scoped_ptr<RawVarDataGraph> actual_data(RawVarDataGraph::Read(&m, &iter));
-  return actual_data->CreatePPVar(dummy_instance);
+  *result = actual_data->CreatePPVar(dummy_instance);
+  return true;
 }
 
 // Assumes a ref for var.
 bool WriteReadAndCompare(const PP_Var& var) {
   ScopedPPVar expected(ScopedPPVar::PassRef(), var);
-  ScopedPPVar actual(ScopedPPVar::PassRef(), WriteAndRead(expected.get()));
+  PP_Var result;
+  bool success = WriteAndRead(expected.get(), &result);
+  if (!success)
+    return false;
+  ScopedPPVar actual(ScopedPPVar::PassRef(), result);
   return TestEqual(expected.get(), actual.get());
 }
 
 }  // namespace
 
 TEST_F(RawVarDataTest, SimpleTest) {
   EXPECT_TRUE(WriteReadAndCompare(PP_MakeUndefined()));
   EXPECT_TRUE(WriteReadAndCompare(PP_MakeNull()));
   EXPECT_TRUE(WriteReadAndCompare(PP_MakeInt32(100)));
   EXPECT_TRUE(WriteReadAndCompare(PP_MakeBool(PP_TRUE)));
@@ skipping 81 matching lines @@
   array->Set(index++, release_dictionary.get());
   EXPECT_TRUE(WriteReadAndCompare(array->GetPPVar()));
 
   // Array with dictionary with array.
   array2->Set(0, PP_MakeInt32(100));
   dictionary->SetWithStringKey("9", release_array2.get());
   EXPECT_TRUE(WriteReadAndCompare(array->GetPPVar()));
 
   // Array <-> dictionary cycle.
   dictionary->SetWithStringKey("10", release_array.get());
-  ScopedPPVar result = ScopedPPVar(ScopedPPVar::PassRef(),
-                                   WriteAndRead(release_dictionary.get()));
-  EXPECT_TRUE(TestEqual(release_dictionary.get(), result.get()));
+  PP_Var result;
+  ASSERT_FALSE(WriteAndRead(release_dictionary.get(), &result));
   // 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");
 
   // Array with self references.
   array->Set(index, release_array.get());
-  result = ScopedPPVar(ScopedPPVar::PassRef(),
-                       WriteAndRead(release_array.get()));
-  EXPECT_TRUE(TestEqual(release_array.get(), result.get()));
+  ASSERT_FALSE(WriteAndRead(release_array.get(), &result));
   // Break the self reference.
   array->Set(index, PP_MakeUndefined());
-  ArrayVar* result_array = ArrayVar::FromPPVar(result.get());
-  result_array->Set(index, PP_MakeUndefined());
 }
 
 }  // namespace proxy
 }  // namespace ppapi