Add TestingInstance::EvalScript method which posts a message that the test page can eval().

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 42 matching lines @@
 
 }  // namespace
 
 TestPostMessage::TestPostMessage(TestingInstance* instance)
     : TestCase(instance) {
 }
 
 TestPostMessage::~TestPostMessage() {
   // Remove the special listener that only responds to a FINISHED_WAITING
   // string. See Init for where it gets added.
-  std::string js_code;
+  std::string js_code("TESTING_MESSAGE:ExecuteScript:");
   js_code += "var plugin = document.getElementById('plugin');"
              "plugin.removeEventListener('message',"
              "                           plugin.wait_for_messages_handler);"
              "delete plugin.wait_for_messages_handler;";
-  pp::Var exception;
-  instance_->ExecuteScript(js_code, &exception);
+  instance_->PostMessage(pp::Var(js_code));
 }
 
 bool TestPostMessage::Init() {
   bool success = InitTestingInterface();
 
   // Set up a special listener that only responds to a FINISHED_WAITING string.
   // This is for use by WaitForMessages.
-  std::string js_code;
+  std::string js_code("TESTING_MESSAGE:ExecuteScript:");
   // 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');"
              "var wait_for_messages_handler = function(message_event) {"
              "  if (!IsTestingMessage(message_event.data) &&"
              "      message_event.data === '" FINISHED_WAITING_MESSAGE "') {"
              "    plugin.postMessage('" FINISHED_WAITING_MESSAGE "');"
              "  }"
              "};"
              "plugin.addEventListener('message', wait_for_messages_handler);"
              // Stash it on the plugin so we can remove it in the destructor.
              "plugin.wait_for_messages_handler = wait_for_messages_handler;";
-  pp::Var exception;
-  instance_->ExecuteScript(js_code, &exception);
-  success = success && exception.is_undefined();
+  instance_->PostMessage(pp::Var(js_code));
 
   // Set up the JavaScript message event listener to echo the data part of the
   // message event back to us.
   success = success && AddEchoingListener("message_event.data");
   message_data_.clear();
   // Send a message that the first test will expect to receive. This is to
   // verify that we can send messages when the 'Instance::Init' function is on
   // the stack.
   instance_->PostMessage(pp::Var(kTestString));
 
@@ skipping 15 matching lines @@
 
 void TestPostMessage::HandleMessage(const pp::Var& message_data) {
   if (message_data.is_string() &&
       (message_data.AsString() == FINISHED_WAITING_MESSAGE))
     testing_interface_->QuitMessageLoop(instance_->pp_instance());
   else
     message_data_.push_back(message_data);
 }
 
 bool TestPostMessage::AddEchoingListener(const std::string& expression) {
-  std::string js_code;
+  std::string js_code("TESTING_MESSAGE:ExecuteScript:");
   // 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');"
              "var message_handler = function(message_event) {"
              "  if (!IsTestingMessage(message_event.data) &&"
              "      !(message_event.data === '" FINISHED_WAITING_MESSAGE "')) {"
              "    plugin.postMessage(";
   js_code += expression;
   js_code += "                      );"
              "  }"
              "};"
              "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);";
-  pp::Var exception;
-  instance_->ExecuteScript(js_code, &exception);
-  return exception.is_undefined();
+  instance_->PostMessage(pp::Var(js_code));
+  return true;
 }
 
 bool TestPostMessage::ClearListeners() {
-  std::string js_code(
-      "var plugin = document.getElementById('plugin');"
-      "while (plugin.eventListeners.length) {"
-      "  plugin.removeEventListener('message', plugin.eventListeners.pop());"
-      "}");
-  pp::Var exception;
-  instance_->ExecuteScript(js_code, &exception);
-  return(exception.is_undefined());
+  std::string js_code("TESTING_MESSAGE:ExecuteScript:");
+  js_code += "var plugin = document.getElementById('plugin');"
+             "while (plugin.eventListeners.length) {"
+             "  plugin.removeEventListener('message',"
+             "                             plugin.eventListeners.pop());"
+             "}";
+  instance_->PostMessage(pp::Var(js_code));
+  return true;
 }
 
 int TestPostMessage::WaitForMessages() {
   size_t message_size_before = message_data_.size();
   // We first post a FINISHED_WAITING_MESSAGE. This should be guaranteed to
   // come back _after_ any other incoming messages that were already pending.
   instance_->PostMessage(pp::Var(FINISHED_WAITING_MESSAGE));
   testing_interface_->RunMessageLoop(instance_->pp_instance());
   // Now that the FINISHED_WAITING_MESSAGE has been echoed back to us, we know
   // that all pending messages have been slurped up. Return the number we
@@ skipping 272 matching lines @@
     }
     ASSERT_TRUE(received_value >= 0);
     ASSERT_TRUE(received_value <= kThreadsToRun);
     ++received_counts[received_value];
   }
   ASSERT_EQ(received_counts, expected_counts);
 
   PASS();
 }