Add GetLiveVars to PPB_Testing_Dev. Fix leaks it uncovered.

ppapi/tests/test_post_message.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_post_message.h"
 
 #include <algorithm>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/pp_var.h"
@@ skipping 51 matching lines @@
   // string. See Init for where it gets added.
   std::string js_code;
   js_code += "var plugin = document.getElementById('plugin');"
              "plugin.removeEventListener('message',"
              "                           plugin.wait_for_messages_handler);"
              "delete plugin.wait_for_messages_handler;";
   instance_->EvalScript(js_code);
 }
 
 bool TestPostMessage::Init() {
-  bool success = InitTestingInterface();
+  bool success = CheckTestingInterface();
 
   // Set up a special listener that only responds to a FINISHED_WAITING string.
   // This is for use by WaitForMessages.
   std::string js_code;
   // Note the following code is dependent on some features of test_case.html.
   // E.g., it is assumed that the DOM element where the plugin is embedded has
   // an id of 'plugin', and there is a function 'IsTestingMessage' that allows
   // us to ignore the messages that are intended for use by the testing
   // framework itself.
   js_code += "var plugin = document.getElementById('plugin');"
@@ skipping 89 matching lines @@
   // received (which may be zero).
   return message_data_.size() - message_size_before;
 }
 
 std::string TestPostMessage::TestSendInInit() {
   ASSERT_EQ(WaitForMessages(), 1);
   // This test assumes Init already sent a message.
   ASSERT_EQ(message_data_.size(), 1);
   ASSERT_TRUE(message_data_.back().is_string());
   ASSERT_EQ(message_data_.back().AsString(), kTestString);
+  message_data_.clear();
   PASS();
 }
 
 std::string TestPostMessage::TestSendingData() {
   // 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();
   ASSERT_TRUE(ClearListeners());
   // Set up the JavaScript message event listener to echo the data part of the
@@ skipping 37 matching lines @@
   ASSERT_EQ(message_data_.size(), 0);
   ASSERT_EQ(WaitForMessages(), 1);
   ASSERT_TRUE(message_data_.back().is_undefined());
 
   message_data_.clear();
   instance_->PostMessage(pp::Var(pp::Var::Null()));
   ASSERT_EQ(message_data_.size(), 0);
   ASSERT_EQ(WaitForMessages(), 1);
   ASSERT_TRUE(message_data_.back().is_null());
 
+  message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
   PASS();
 }
 
 std::string TestPostMessage::TestSendingArrayBuffer() {
   // 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();
@@ skipping 40 matching lines @@
   message_data_.clear();
   ASSERT_EQ(test_data.ByteLength(), received.ByteLength());
   unsigned char* received_buff = static_cast<unsigned char*>(received.Map());
   // The buffer should be copied, so this should be a distinct buffer. When
   // 'transferrables' are implemented for PPAPI, we'll also want to test that
   // we get the _same_ buffer back when it's transferred.
   ASSERT_NE(buff, received_buff);
   for (size_t i = 0; i < test_data.ByteLength(); ++i)
     ASSERT_EQ(buff[i], received_buff[i]);
 
+  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();
@@ skipping 45 matching lines @@
   std::vector<double> double_vec;
   for (; iter != the_end; ++iter) {
     ASSERT_TRUE(iter->is_number());
     double_vec.push_back(iter->AsDouble());
   }
   std::sort(double_vec.begin(), double_vec.end());
   ASSERT_DOUBLE_EQ(double_vec[0], 1.0);
   ASSERT_DOUBLE_EQ(double_vec[1], 2.0);
   ASSERT_DOUBLE_EQ(double_vec[2], 3.0);
 
+  message_data_.clear();
+  ASSERT_TRUE(ClearListeners());
+
   PASS();
 }
 
 std::string TestPostMessage::TestNoHandler() {
   // Delete any lingering messages and event listeners.
   WaitForMessages();
   ASSERT_TRUE(ClearListeners());
 
   // Now send a message.  We shouldn't get a response.
   message_data_.clear();
@@ skipping 11 matching lines @@
   // Add a listener that will respond with 1 and an empty array (where the
   // message port array would appear if it was Worker postMessage).
   ASSERT_TRUE(AddEchoingListener("1, []"));
 
   // Now send a message.  We shouldn't get a response.
   message_data_.clear();
   instance_->PostMessage(pp::Var());
   ASSERT_EQ(WaitForMessages(), 0);
   ASSERT_TRUE(message_data_.empty());
 
+  ASSERT_TRUE(ClearListeners());
+
   PASS();
 }
 
 std::string TestPostMessage::TestNonMainThread() {
   WaitForMessages();
   ASSERT_TRUE(ClearListeners());
   ASSERT_TRUE(AddEchoingListener("message_event.data"));
   message_data_.clear();
 
   // Set up a thread for each integer from 0 to (kThreadsToRun - 1).  Make each
@@ skipping 36 matching lines @@
       received_value = latest_var.AsInt();
     } else if (latest_var.is_double()) {
       received_value = static_cast<int32_t>(latest_var.AsDouble() + 0.5);
     }
     ASSERT_TRUE(received_value >= 0);
     ASSERT_TRUE(received_value <= kThreadsToRun);
     ++received_counts[received_value];
   }
   ASSERT_EQ(received_counts, expected_counts);
 
+  message_data_.clear();
+  ASSERT_TRUE(ClearListeners());
+
   PASS();
 }