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);
+  instance_->PostMessage(pp::Var());
+  // 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_undefined());
+
+  // 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; }");
+  instance_->PostMessage(pp::Var());
+  ASSERT_EQ(message_data_.size(), 0);
+  ASSERT_EQ(WaitForMessages(), 1);

[dmichael (off chromium), 2013/06/05 17:05:47]

Shouldn't we expect 0 here now?

[raymes, 2013/06/05 22:48:26]

Yeah - I thought that WaitForMessages() wouldn't work if we weren't expecting a
message so I posted an undefined var right after, but it seems to work fine.

[dmichael (off chromium), 2013/06/06 16:32:30]

It sends its own special message (that's echoed back) that goes in the queue
behind whatever messages you're really waiting on, and quits the message loop
when that one arrives. That's how it knows how many messages you got.

+  ASSERT_TRUE(message_data_.back().is_undefined());
+
+  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();
 }