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

ppapi/tests/test_post_message.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/tests/test_post_message.h"
 
 #include <algorithm>
 #include <map>
 #include <sstream>
 
@@ skipping 220 matching lines @@
              "plugin.addEventListener('message', message_handler);"
              // Maintain an array of all event listeners, attached to the
              // plugin. This is so that we can easily remove them later (see
              // ClearListeners()).
              "if (!plugin.eventListeners) plugin.eventListeners = [];"
              "plugin.eventListeners.push(message_handler);";
   instance_->EvalScript(js_code);
   return true;
 }
 
+bool TestPostMessage::PostMessageFromJavaScript(const std::string& func) {
+  std::string js_code;
+  js_code += "var plugin = document.getElementById('plugin');"
+             "plugin.postMessage(";
+  js_code += func + "()";
+  js_code += "                      );";
+  instance_->EvalScript(js_code);
+  return true;
+}
+
 bool TestPostMessage::ClearListeners() {
   std::string js_code;
   js_code += "var plugin = document.getElementById('plugin');"
              "while (plugin.eventListeners.length) {"
              "  plugin.removeEventListener('message',"
              "                             plugin.eventListeners.pop());"
              "}";
   instance_->EvalScript(js_code);
   return true;
 }
@@ skipping 265 matching lines @@
   ASSERT_TRUE(ClearListeners());
 
   PASS();
 }
 
 std::string TestPostMessage::TestSendingComplexVar() {
   // Clean up after previous tests. This also swallows the message sent by Init
   // if we didn't run the 'SendInInit' test. All tests other than 'SendInInit'
   // should start with these.
   WaitForMessages();
+  message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
   pp::Var string(kTestString);
   pp::VarDictionary_Dev dictionary;
   dictionary.Set(pp::Var("foo"), pp::Var(kTestBool));
   dictionary.Set(pp::Var("bar"), string);
   dictionary.Set(pp::Var("abc"), pp::Var(kTestInt));
   dictionary.Set(pp::Var("def"), pp::Var());
-  dictionary.Set(pp::Var("dictionary"), dictionary);  // Self-reference.
 
   // Reference to array.
   pp::VarArray_Dev array;
   array.Set(0, pp::Var(kTestBool));
   array.Set(1, string);
   // Purposely leave index 2 empty (which will place an undefined var there).
   array.Set(3, pp::Var(kTestInt));
   array.Set(4, pp::Var(kTestDouble));
 
   dictionary.Set(pp::Var("array-ref1"), array);
   dictionary.Set(pp::Var("array-ref2"), array);
 
-  // Set up a (dictionary -> array -> dictionary) cycle.
-  pp::VarArray_Dev array2;
-  array2.Set(0, dictionary);
-  dictionary.Set(pp::Var("array2"), array2);
-
   // Set up the JavaScript message event listener to echo the data part of the
   // message event back to us.
   ASSERT_TRUE(AddEchoingListener("message_event.data"));
-  message_data_.clear();
   instance_->PostMessage(dictionary);
   // PostMessage is asynchronous, so we should not receive a response yet.
   ASSERT_EQ(message_data_.size(), 0);
   ASSERT_EQ(WaitForMessages(), 1);
   ASSERT_TRUE(message_data_.back().is_dictionary());
   pp::VarDictionary_Dev result(message_data_.back());
   ASSERT_TRUE(VarsEqual(dictionary, message_data_.back()));
 
-  // Break the cycles.
-  dictionary.Delete(pp::Var("dictionary"));
-  dictionary.Delete(pp::Var("array2"));
-  result.Delete(pp::Var("dictionary"));
-  result.Delete(pp::Var("array2"));
-
+  WaitForMessages();
   message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
+  // Set up a (dictionary -> array -> dictionary) cycle. Cycles shouldn't be
+  // transmitted.
+  pp::VarArray_Dev array2;
+  array2.Set(0, dictionary);
+  dictionary.Set(pp::Var("array2"), array2);
+
+  ASSERT_TRUE(AddEchoingListener("message_event.data"));
+  instance_->PostMessage(dictionary);
+  // PostMessage is asynchronous, so we should not receive a response yet.
+  ASSERT_EQ(message_data_.size(), 0);
+  ASSERT_EQ(WaitForMessages(), 0);
+
+  // Break the cycles.
+  dictionary.Delete(pp::Var("array2"));
+
+  WaitForMessages();
+  message_data_.clear();
+  ASSERT_TRUE(ClearListeners());
+
+  // Test sending a cycle from JavaScript to the plugin.
+  ASSERT_TRUE(AddEchoingListener("message_event.data"));
+  PostMessageFromJavaScript("function() { var x = []; x[0] = x; return x; }");
+  ASSERT_EQ(message_data_.size(), 0);
+  ASSERT_EQ(WaitForMessages(), 0);
+
+  WaitForMessages();
+  message_data_.clear();
+  ASSERT_TRUE(ClearListeners());
+
   PASS();
 }
 
 std::string TestPostMessage::TestMessageEvent() {
   // Set up the JavaScript message event listener to pass us some values from
   // the MessageEvent and make sure they match our expectations.
 
   WaitForMessages();
   ASSERT_TRUE(ClearListeners());
   // Have the listener pass back the class name of message_event and make sure
@@ skipping 140 matching lines @@
     ASSERT_TRUE(received_value <= kThreadsToRun);
     ++received_counts[received_value];
   }
   ASSERT_EQ(received_counts, expected_counts);
 
   message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
   PASS();
 }