ppapi/tests/test_post_message.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/tests/test_post_message.h"
   6
   7 #include <string.h>
   8 #include <algorithm>
   9 #include <map>
  10 #include <sstream>
  11
  12 #include "ppapi/c/pp_var.h"
  13 #include "ppapi/c/ppb_file_io.h"
  14 #include "ppapi/cpp/file_io.h"
  15 #include "ppapi/cpp/file_ref.h"
  16 #include "ppapi/cpp/file_system.h"
  17 #include "ppapi/cpp/instance.h"
  18 #include "ppapi/cpp/var.h"
  19 #include "ppapi/cpp/var_array.h"
  20 #include "ppapi/cpp/var_array_buffer.h"
  21 #include "ppapi/cpp/var_dictionary.h"
  22 #include "ppapi/tests/pp_thread.h"
  23 #include "ppapi/tests/test_utils.h"
  24 #include "ppapi/tests/testing_instance.h"
  25
  26 // Windows defines 'PostMessage', so we have to undef it.
  27 #ifdef PostMessage
  28 #undef PostMessage
  29 #endif
  30
  31 REGISTER_TEST_CASE(PostMessage);
  32
  33 namespace {
  34
  35 const char kTestFilename[] = "testfile.txt";
  36 const char kTestString[] = "Hello world!";
  37 const bool kTestBool = true;
  38 const int32_t kTestInt = 42;
  39 const double kTestDouble = 42.0;
  40
  41 // On Windows XP bots, the NonMainThread test can run very slowly. So we dial
  42 // back the number of threads & messages when running on Windows.
  43 #ifdef PPAPI_OS_WIN
  44 const int32_t kThreadsToRun = 2;
  45 const int32_t kMessagesToSendPerThread = 5;
  46 #else
  47 const int32_t kThreadsToRun = 4;
  48 const int32_t kMessagesToSendPerThread = 10;
  49 #endif
  50
  51 // The struct that invoke_post_message_thread_func expects for its argument.
  52 // It includes the instance on which to invoke PostMessage, and the value to
  53 // pass to PostMessage.
  54 struct InvokePostMessageThreadArg {
  55   InvokePostMessageThreadArg(pp::Instance* i, const pp::Var& v)
  56       : instance(i), value_to_send(v) {}
  57   pp::Instance* instance;
  58   pp::Var value_to_send;
  59 };
  60
  61 void InvokePostMessageThreadFunc(void* user_data) {
  62   InvokePostMessageThreadArg* arg =
  63       static_cast<InvokePostMessageThreadArg*>(user_data);
  64   for (int32_t i = 0; i < kMessagesToSendPerThread; ++i)
  65     arg->instance->PostMessage(arg->value_to_send);
  66   delete arg;
  67 }
  68
  69 // TODO(raymes): Consider putting something like this into pp::Var.
  70 bool VarsEqual(const pp::Var& expected,
  71                const pp::Var& actual,
  72                std::map<int64_t, int64_t>* visited_ids) {
  73   if (expected.pp_var().type != actual.pp_var().type) {
  74     if (!expected.is_number() && !actual.is_number())
  75       return false;
  76   }
  77   // TODO(raymes): Implement a pp::Var::IsRefCounted() function.
  78   if (expected.pp_var().type > PP_VARTYPE_DOUBLE) {
  79     std::map<int64_t, int64_t>::const_iterator it =
  80         visited_ids->find(expected.pp_var().value.as_id);
  81     if (it != visited_ids->end()) {
  82       if (it->second == actual.pp_var().value.as_id)
  83         return true;
  84       return false;
  85     }
  86     // Round-tripping reference graphs with strings will not necessarily
  87     // result in isomorphic graphs. This is because string vars are converted
  88     // to string primitives in JS which cannot be referenced.
  89     if (!expected.is_string()) {
  90       (*visited_ids)[expected.pp_var().value.as_id] =
  91           actual.pp_var().value.as_id;
  92     }
  93   }
  94
  95   if (expected.is_number()) {
  96     return fabs(expected.AsDouble() - actual.AsDouble()) < 1.0e-4;
  97   } else if (expected.is_array()) {
  98     pp::VarArray expected_array(expected);
  99     pp::VarArray actual_array(actual);
 100     if (expected_array.GetLength() != actual_array.GetLength())
 101       return false;
 102     for (uint32_t i = 0; i < expected_array.GetLength(); ++i) {
 103       if (!VarsEqual(expected_array.Get(i), actual_array.Get(i), visited_ids))
 104         return false;
 105     }
 106     return true;
 107   } else if (expected.is_dictionary()) {
 108     pp::VarDictionary expected_dict(expected);
 109     pp::VarDictionary actual_dict(actual);
 110     if (expected_dict.GetKeys().GetLength() !=
 111         actual_dict.GetKeys().GetLength()) {
 112       return false;
 113     }
 114     for (uint32_t i = 0; i < expected_dict.GetKeys().GetLength(); ++i) {
 115       pp::Var key = expected_dict.GetKeys().Get(i);
 116       if (!actual_dict.HasKey(key))
 117         return false;
 118       if (!VarsEqual(expected_dict.Get(key), actual_dict.Get(key), visited_ids))
 119         return false;
 120     }
 121     return true;
 122   } else {
 123     return expected == actual;
 124   }
 125 }
 126
 127 bool VarsEqual(const pp::Var& expected,
 128                const pp::Var& actual) {
 129   std::map<int64_t, int64_t> visited_ids;
 130   return VarsEqual(expected, actual, &visited_ids);
 131 }
 132
 133 class ScopedArrayBufferSizeSetter {
 134  public:
 135   ScopedArrayBufferSizeSetter(const PPB_Testing_Private* interface,
 136                               PP_Instance instance,
 137                               uint32_t threshold)
 138      : interface_(interface),
 139        instance_(instance) {
 140     interface_->SetMinimumArrayBufferSizeForShmem(instance_, threshold);
 141   }
 142   ~ScopedArrayBufferSizeSetter() {
 143     interface_->SetMinimumArrayBufferSizeForShmem(instance_, 0);
 144   }
 145  private:
 146   const PPB_Testing_Private* interface_;
 147   PP_Instance instance_;
 148 };
 149
 150 #define FINISHED_WAITING_MESSAGE "TEST_POST_MESSAGE_FINISHED_WAITING"
 151
 152 }  // namespace
 153
 154 TestPostMessage::TestPostMessage(TestingInstance* instance)
 155     : TestCase(instance) {
 156 }
 157
 158 TestPostMessage::~TestPostMessage() {
 159   instance_->PostMessage(pp::Var("This isn't guaranteed to be received, but "
 160                                  "shouldn't cause a crash."));
 161
 162   // Remove the special listener that only responds to a FINISHED_WAITING
 163   // string. See Init for where it gets added.
 164   std::string js_code;
 165   js_code += "var plugin = document.getElementById('plugin');"
 166              "plugin.removeEventListener('message',"
 167              "                           plugin.wait_for_messages_handler);"
 168              "delete plugin.wait_for_messages_handler;";
 169   instance_->EvalScript(js_code);
 170 }
 171
 172 bool TestPostMessage::Init() {
 173   bool success = CheckTestingInterface();
 174
 175   // Add a post condition to tests which caches the postMessage function and
 176   // then calls it after the instance is destroyed. The ensures that no UAF
 177   // occurs because the MessageChannel may still be alive after the plugin
 178   // instance is destroyed (it will get garbage collected eventually).
 179   instance_->EvalScript("window.pluginPostMessage = "
 180                         "document.getElementById('plugin').postMessage");
 181   instance_->AddPostCondition("window.pluginPostMessage('') === undefined");
 182
 183   // Set up a special listener that only responds to a FINISHED_WAITING string.
 184   // This is for use by WaitForMessages.
 185   std::string js_code;
 186   // Note the following code is dependent on some features of test_case.html.
 187   // E.g., it is assumed that the DOM element where the plugin is embedded has
 188   // an id of 'plugin', and there is a function 'IsTestingMessage' that allows
 189   // us to ignore the messages that are intended for use by the testing
 190   // framework itself.
 191   js_code += "var plugin = document.getElementById('plugin');"
 192              "var wait_for_messages_handler = function(message_event) {"
 193              "  if (!IsTestingMessage(message_event.data) &&"
 194              "      message_event.data === '" FINISHED_WAITING_MESSAGE "') {"
 195              "    plugin.postMessage('" FINISHED_WAITING_MESSAGE "');"
 196              "  }"
 197              "};"
 198              "plugin.addEventListener('message', wait_for_messages_handler);"
 199              // Stash it on the plugin so we can remove it in the destructor.
 200              "plugin.wait_for_messages_handler = wait_for_messages_handler;";
 201   instance_->EvalScript(js_code);
 202
 203   // Set up the JavaScript message event listener to echo the data part of the
 204   // message event back to us.
 205   success = success && AddEchoingListener("message_event.data");
 206   message_data_.clear();
 207   // Send a message that the first test will expect to receive. This is to
 208   // verify that we can send messages when the 'Instance::Init' function is on
 209   // the stack.
 210   instance_->PostMessage(pp::Var(kTestString));
 211
 212   return success;
 213 }
 214
 215 void TestPostMessage::RunTests(const std::string& filter) {
 216   // Note: SendInInit must be first, because it expects to receive a message
 217   // that was sent in Init above.
 218   RUN_TEST(SendInInit, filter);
 219   RUN_TEST(SendingData, filter);
 220   RUN_TEST(SendingString, filter);
 221   RUN_TEST(SendingArrayBuffer, filter);
 222   RUN_TEST(SendingArray, filter);
 223   RUN_TEST(SendingDictionary, filter);
 224   RUN_TEST(SendingResource, filter);
 225   RUN_TEST(SendingComplexVar, filter);
 226   RUN_TEST(MessageEvent, filter);
 227   RUN_TEST(NoHandler, filter);
 228   RUN_TEST(ExtraParam, filter);
 229   if (testing_interface_->IsOutOfProcess())
 230     RUN_TEST(NonMainThread, filter);
 231 }
 232
 233 void TestPostMessage::HandleMessage(const pp::Var& message_data) {
 234   if (message_data.is_string() &&
 235       (message_data.AsString() == FINISHED_WAITING_MESSAGE))
 236     testing_interface_->QuitMessageLoop(instance_->pp_instance());
 237   else
 238     message_data_.push_back(message_data);
 239 }
 240
 241 bool TestPostMessage::AddEchoingListener(const std::string& expression) {
 242   std::string js_code;
 243   // Note the following code is dependent on some features of test_case.html.
 244   // E.g., it is assumed that the DOM element where the plugin is embedded has
 245   // an id of 'plugin', and there is a function 'IsTestingMessage' that allows
 246   // us to ignore the messages that are intended for use by the testing
 247   // framework itself.
 248   js_code += "var plugin = document.getElementById('plugin');"
 249              "var message_handler = function(message_event) {"
 250              "  if (!IsTestingMessage(message_event.data) &&"
 251              "      !(message_event.data === '" FINISHED_WAITING_MESSAGE "')) {"
 252              "    plugin.postMessage(";
 253   js_code += expression;
 254   js_code += "                      );"
 255              "  }"
 256              "};"
 257              "plugin.addEventListener('message', message_handler);"
 258              // Maintain an array of all event listeners, attached to the
 259              // plugin. This is so that we can easily remove them later (see
 260              // ClearListeners()).
 261              "if (!plugin.eventListeners) plugin.eventListeners = [];"
 262              "plugin.eventListeners.push(message_handler);";
 263   instance_->EvalScript(js_code);
 264   return true;
 265 }
 266
 267 bool TestPostMessage::PostMessageFromJavaScript(const std::string& func) {
 268   std::string js_code;
 269   js_code += "var plugin = document.getElementById('plugin');"
 270              "plugin.postMessage(";
 271   js_code += func + "()";
 272   js_code += "                      );";
 273   instance_->EvalScript(js_code);
 274   return true;
 275 }
 276
 277 bool TestPostMessage::ClearListeners() {
 278   std::string js_code;
 279   js_code += "var plugin = document.getElementById('plugin');"
 280              "while (plugin.eventListeners.length) {"
 281              "  plugin.removeEventListener('message',"
 282              "                             plugin.eventListeners.pop());"
 283              "}";
 284   instance_->EvalScript(js_code);
 285   return true;
 286 }
 287
 288 int TestPostMessage::WaitForMessages() {
 289   size_t message_size_before = message_data_.size();
 290   // We first post a FINISHED_WAITING_MESSAGE. This should be guaranteed to
 291   // come back _after_ any other incoming messages that were already pending.
 292   instance_->PostMessage(pp::Var(FINISHED_WAITING_MESSAGE));
 293   testing_interface_->RunMessageLoop(instance_->pp_instance());
 294   // Now that the FINISHED_WAITING_MESSAGE has been echoed back to us, we know
 295   // that all pending messages have been slurped up. Return the number we
 296   // received (which may be zero).
 297   return static_cast<int>(message_data_.size() - message_size_before);
 298 }
 299
 300 std::string TestPostMessage::CheckMessageProperties(
 301     const pp::Var& test_data,
 302     const std::vector<std::string>& properties_to_check) {
 303   typedef std::vector<std::string>::const_iterator Iterator;
 304   for (Iterator iter = properties_to_check.begin();
 305        iter != properties_to_check.end();
 306        ++iter) {
 307     ASSERT_TRUE(AddEchoingListener(*iter));
 308     message_data_.clear();
 309     instance_->PostMessage(test_data);
 310     ASSERT_EQ(0, message_data_.size());
 311     ASSERT_EQ(1, WaitForMessages());
 312     ASSERT_TRUE(message_data_.back().is_bool());
 313     if (!message_data_.back().AsBool())
 314       return std::string("Failed: ") + *iter;
 315     ASSERT_TRUE(message_data_.back().AsBool());
 316     ASSERT_TRUE(ClearListeners());
 317   }
 318   PASS();
 319 }
 320
 321 std::string TestPostMessage::TestSendInInit() {
 322   // Wait for the messages from Init() to be guaranteed to be sent.
 323   WaitForMessages();
 324   // This test assumes Init already sent a message.
 325   ASSERT_EQ(1, message_data_.size());
 326   ASSERT_TRUE(message_data_.back().is_string());
 327   ASSERT_EQ(kTestString, message_data_.back().AsString());
 328   message_data_.clear();
 329   PASS();
 330 }
 331
 332 std::string TestPostMessage::TestSendingData() {
 333   // Clean up after previous tests. This also swallows the message sent by Init
 334   // if we didn't run the 'SendInInit' test. All tests other than 'SendInInit'
 335   // should start with these.
 336   WaitForMessages();
 337   ASSERT_TRUE(ClearListeners());
 338
 339   // Set up the JavaScript message event listener to echo the data part of the
 340   // message event back to us.
 341   ASSERT_TRUE(AddEchoingListener("message_event.data"));
 342
 343   // Test sending a message to JavaScript for each supported type. The JS sends
 344   // the data back to us, and we check that they match.
 345   message_data_.clear();
 346   instance_->PostMessage(pp::Var(kTestBool));
 347   ASSERT_EQ(0, message_data_.size());
 348   ASSERT_EQ(1, WaitForMessages());
 349   ASSERT_TRUE(message_data_.back().is_bool());
 350   ASSERT_EQ(message_data_.back().AsBool(), kTestBool);
 351
 352   message_data_.clear();
 353   instance_->PostMessage(pp::Var(kTestInt));
 354   ASSERT_EQ(0, message_data_.size());
 355   ASSERT_EQ(1, WaitForMessages());
 356   ASSERT_TRUE(message_data_.back().is_number());
 357   ASSERT_DOUBLE_EQ(static_cast<double>(kTestInt),
 358                    message_data_.back().AsDouble());
 359
 360   message_data_.clear();
 361   instance_->PostMessage(pp::Var(kTestDouble));
 362   ASSERT_EQ(0, message_data_.size());
 363   ASSERT_EQ(1, WaitForMessages());
 364   ASSERT_TRUE(message_data_.back().is_number());
 365   ASSERT_DOUBLE_EQ(message_data_.back().AsDouble(), kTestDouble);
 366
 367   message_data_.clear();
 368   instance_->PostMessage(pp::Var());
 369   ASSERT_EQ(0, message_data_.size());
 370   ASSERT_EQ(1, WaitForMessages());
 371   ASSERT_TRUE(message_data_.back().is_undefined());
 372
 373   message_data_.clear();
 374   instance_->PostMessage(pp::Var(pp::Var::Null()));
 375   ASSERT_EQ(0, message_data_.size());
 376   ASSERT_EQ(1, WaitForMessages());
 377   ASSERT_TRUE(message_data_.back().is_null());
 378
 379   message_data_.clear();
 380   ASSERT_TRUE(ClearListeners());
 381
 382   PASS();
 383 }
 384
 385 std::string TestPostMessage::TestSendingString() {
 386   // Clean up after previous tests. This also swallows the message sent by Init
 387   // if we didn't run the 'SendInInit' test. All tests other than 'SendInInit'
 388   // should start with these.
 389   WaitForMessages();
 390   ASSERT_TRUE(ClearListeners());
 391
 392   // Test that a string var is converted to a primitive JS string.
 393   message_data_.clear();
 394   std::vector<std::string> properties_to_check;
 395   properties_to_check.push_back(
 396       "typeof message_event.data === 'string'");
 397   ASSERT_SUBTEST_SUCCESS(CheckMessageProperties(kTestString,
 398                                                 properties_to_check));
 399
 400   ASSERT_TRUE(AddEchoingListener("message_event.data"));
 401   message_data_.clear();
 402   instance_->PostMessage(pp::Var(kTestString));
 403   // PostMessage is asynchronous, so we should not receive a response yet.
 404   ASSERT_EQ(0, message_data_.size());
 405   ASSERT_EQ(1, WaitForMessages());
 406   ASSERT_TRUE(message_data_.back().is_string());
 407   ASSERT_EQ(message_data_.back().AsString(), kTestString);
 408
 409   message_data_.clear();
 410   ASSERT_TRUE(ClearListeners());
 411
 412   PASS();
 413 }
 414
 415 std::string TestPostMessage::TestSendingArrayBuffer() {
 416   // Clean up after previous tests. This also swallows the message sent by Init
 417   // if we didn't run the 'SendInInit' test. All tests other than 'SendInInit'
 418   // should start with these.
 419   WaitForMessages();
 420   ASSERT_TRUE(ClearListeners());
 421
 422   // TODO(sehr,dmichael): Add testing of longer array buffers when
 423   // crbug.com/110086 is fixed.
 424   ScopedArrayBufferSizeSetter setter(testing_interface_,
 425                                      instance_->pp_instance(),
 426                                      200);
 427   uint32_t sizes[] = { 0, 100, 1000, 10000 };
 428   for (size_t i = 0; i < sizeof(sizes)/sizeof(sizes[i]); ++i) {
 429     std::ostringstream size_stream;
 430     size_stream << sizes[i];
 431     const std::string kSizeAsString(size_stream.str());
 432
 433     // Create an appropriately sized array buffer with test_data[i] == i.
 434     pp::VarArrayBuffer test_data(sizes[i]);
 435     if (sizes[i] > 0)
 436       ASSERT_NE(NULL, test_data.Map());
 437     // Make sure we can Unmap/Map successfully (there's not really any way to
 438     // detect if it's unmapped, so we just re-map before getting the pointer to
 439     // the buffer).
 440     test_data.Unmap();
 441     test_data.Map();
 442     ASSERT_EQ(sizes[i], test_data.ByteLength());
 443     unsigned char* buff = static_cast<unsigned char*>(test_data.Map());
 444     const uint32_t kByteLength = test_data.ByteLength();
 445     for (size_t j = 0; j < kByteLength; ++j)
 446       buff[j] = static_cast<uint8_t>(j % 256u);
 447
 448     // Have the listener test some properties of the ArrayBuffer.
 449     std::vector<std::string> properties_to_check;
 450     properties_to_check.push_back(
 451         "message_event.data.constructor.name === 'ArrayBuffer'");
 452     properties_to_check.push_back(
 453         std::string("message_event.data.byteLength === ") + kSizeAsString);
 454     if (sizes[i] > 0) {
 455       properties_to_check.push_back(
 456           "(new DataView(message_event.data)).getUint8(0) == 0");
 457       // Checks that the last element has the right value: (byteLength-1)%256.
 458       std::string received_byte("(new DataView(message_event.data)).getUint8("
 459                                 "    message_event.data.byteLength-1)");
 460       std::string expected_byte("(message_event.data.byteLength-1)%256");
 461       properties_to_check.push_back(received_byte + " == " + expected_byte);
 462     }
 463     ASSERT_SUBTEST_SUCCESS(CheckMessageProperties(test_data,
 464                                                   properties_to_check));
 465
 466     // Set up the JavaScript message event listener to echo the data part of the
 467     // message event back to us.
 468     ASSERT_TRUE(AddEchoingListener("message_event.data"));
 469     message_data_.clear();
 470     instance_->PostMessage(test_data);
 471     // PostMessage is asynchronous, so we should not receive a response yet.
 472     ASSERT_EQ(0, message_data_.size());
 473     ASSERT_EQ(1, WaitForMessages());
 474     ASSERT_TRUE(message_data_.back().is_array_buffer());
 475     pp::VarArrayBuffer received(message_data_.back());
 476     message_data_.clear();
 477     ASSERT_EQ(test_data.ByteLength(), received.ByteLength());
 478     unsigned char* received_buff = static_cast<unsigned char*>(received.Map());
 479     // The buffer should be copied, so this should be a distinct buffer. When
 480     // 'transferrables' are implemented for PPAPI, we'll also want to test that
 481     // we get the _same_ buffer back when it's transferred.
 482     if (sizes[i] > 0)
 483       ASSERT_NE(buff, received_buff);
 484     for (size_t i = 0; i < test_data.ByteLength(); ++i)
 485       ASSERT_EQ(buff[i], received_buff[i]);
 486
 487     message_data_.clear();
 488     ASSERT_TRUE(ClearListeners());
 489   }
 490
 491   PASS();
 492 }
 493
 494 std::string TestPostMessage::TestSendingArray() {
 495   // Clean up after previous tests. This also swallows the message sent by Init
 496   // if we didn't run the 'SendInInit' test. All tests other than 'SendInInit'
 497   // should start with these.
 498   WaitForMessages();
 499   ASSERT_TRUE(ClearListeners());
 500
 501   pp::VarArray array;
 502   array.Set(0, pp::Var(kTestBool));
 503   array.Set(1, pp::Var(kTestString));
 504   // Purposely leave index 2 empty.
 505   array.Set(3, pp::Var(kTestInt));
 506   array.Set(4, pp::Var(kTestDouble));
 507
 508   std::stringstream ss;
 509   ss << array.GetLength();
 510   std::string length_as_string(ss.str());
 511
 512   // Have the listener test some properties of the Array.
 513   std::vector<std::string> properties_to_check;
 514   properties_to_check.push_back(
 515       "message_event.data.constructor.name === 'Array'");
 516   properties_to_check.push_back(
 517       std::string("message_event.data.length === ") + length_as_string);
 518   // Check that the string is converted to a primitive JS string.
 519   properties_to_check.push_back(
 520       std::string("typeof message_event.data[1] === 'string'"));
 521   ASSERT_SUBTEST_SUCCESS(CheckMessageProperties(array, properties_to_check));
 522
 523   // Set up the JavaScript message event listener to echo the data part of the
 524   // message event back to us.
 525   ASSERT_TRUE(AddEchoingListener("message_event.data"));
 526   message_data_.clear();
 527   instance_->PostMessage(array);
 528   // PostMessage is asynchronous, so we should not receive a response yet.
 529   ASSERT_EQ(0, message_data_.size());
 530   ASSERT_EQ(1, WaitForMessages());
 531   ASSERT_TRUE(message_data_.back().is_array());
 532   ASSERT_TRUE(VarsEqual(array, message_data_.back()));
 533
 534   message_data_.clear();
 535   ASSERT_TRUE(ClearListeners());
 536
 537   PASS();
 538 }
 539
 540 std::string TestPostMessage::TestSendingDictionary() {
 541   // Clean up after previous tests. This also swallows the message sent by Init
 542   // if we didn't run the 'SendInInit' test. All tests other than 'SendInInit'
 543   // should start with these.
 544   WaitForMessages();
 545   ASSERT_TRUE(ClearListeners());
 546
 547   pp::VarDictionary dictionary;
 548   dictionary.Set(pp::Var("foo"), pp::Var(kTestBool));
 549   dictionary.Set(pp::Var("bar"), pp::Var(kTestString));
 550   dictionary.Set(pp::Var("abc"), pp::Var(kTestInt));
 551   dictionary.Set(pp::Var("def"), pp::Var());
 552
 553   std::stringstream ss;
 554   ss << dictionary.GetKeys().GetLength();
 555   std::string length_as_string(ss.str());
 556
 557   // Have the listener test some properties of the Dictionary.
 558   std::vector<std::string> properties_to_check;
 559   properties_to_check.push_back(
 560       "message_event.data.constructor.name === 'Object'");
 561   properties_to_check.push_back(
 562       std::string("Object.keys(message_event.data).length === ") +
 563       length_as_string);
 564   // Check that the string is converted to a primitive JS string.
 565   properties_to_check.push_back(
 566       std::string("typeof message_event.data['bar'] === 'string'"));
 567   ASSERT_SUBTEST_SUCCESS(CheckMessageProperties(dictionary,
 568                                                 properties_to_check));
 569
 570   // Set up the JavaScript message event listener to echo the data part of the
 571   // message event back to us.
 572   ASSERT_TRUE(AddEchoingListener("message_event.data"));
 573   message_data_.clear();
 574   instance_->PostMessage(dictionary);
 575   // PostMessage is asynchronous, so we should not receive a response yet.
 576   ASSERT_EQ(0, message_data_.size());
 577   ASSERT_EQ(1, WaitForMessages());
 578   ASSERT_TRUE(message_data_.back().is_dictionary());
 579   ASSERT_TRUE(VarsEqual(dictionary, message_data_.back()));
 580
 581   message_data_.clear();
 582   ASSERT_TRUE(ClearListeners());
 583
 584   PASS();
 585 }
 586
 587 std::string TestPostMessage::TestSendingResource() {
 588   // Clean up after previous tests. This also swallows the message sent by Init
 589   // if we didn't run the 'SendInInit' test. All tests other than 'SendInInit'
 590   // should start with these.
 591   WaitForMessages();
 592   message_data_.clear();
 593   ASSERT_TRUE(ClearListeners());
 594
 595   std::string file_path("/");
 596   file_path += kTestFilename;
 597   int content_length = static_cast<int>(strlen(kTestString));
 598
 599   // Create a file in the HTML5 temporary file system, in the Pepper plugin.
 600   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 601   pp::FileSystem file_system(instance_, PP_FILESYSTEMTYPE_LOCALTEMPORARY);
 602   callback.WaitForResult(file_system.Open(1024, callback.GetCallback()));
 603   CHECK_CALLBACK_BEHAVIOR(callback);
 604   ASSERT_EQ(PP_OK, callback.result());
 605   pp::FileRef write_file_ref(file_system, file_path.c_str());
 606   // Write to the file.
 607   pp::FileIO write_file_io(instance_);
 608   ASSERT_NE(0, write_file_io.pp_resource());
 609   callback.WaitForResult(
 610       write_file_io.Open(write_file_ref,
 611                          PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_CREATE,
 612                          callback.GetCallback()));
 613   CHECK_CALLBACK_BEHAVIOR(callback);
 614   ASSERT_EQ(PP_OK, callback.result());
 615   callback.WaitForResult(write_file_io.Write(
 616       0, kTestString, content_length, callback.GetCallback()));
 617   CHECK_CALLBACK_BEHAVIOR(callback);
 618   ASSERT_EQ(callback.result(), content_length);
 619   write_file_io.Close();
 620
 621   // Pass the file system to JavaScript and have the listener test some
 622   // properties of the file system.
 623   pp::Var file_system_var(file_system);
 624   std::vector<std::string> properties_to_check;
 625   properties_to_check.push_back(
 626       "message_event.data.constructor.name === 'DOMFileSystem'");
 627   properties_to_check.push_back(
 628       "message_event.data.root.constructor.name === 'DirectoryEntry'");
 629   properties_to_check.push_back(
 630       "message_event.data.name.indexOf("
 631       "    ':Temporary',"
 632       "    message_event.data.name.length - ':Temporary'.length) !== -1");
 633   ASSERT_SUBTEST_SUCCESS(CheckMessageProperties(file_system_var,
 634                                                 properties_to_check));
 635
 636   // Set up the JavaScript message event listener to echo the data part of the
 637   // message event back to us.
 638   ASSERT_TRUE(AddEchoingListener("message_event.data"));
 639   // Send the file system in a message from the Pepper plugin to JavaScript.
 640   message_data_.clear();
 641   instance_->PostMessage(file_system_var);
 642   // PostMessage is asynchronous, so we should not receive a response yet.
 643   ASSERT_EQ(0, message_data_.size());
 644   ASSERT_EQ(1, WaitForMessages());
 645
 646   // The JavaScript should have posted the file system back to us. Verify that
 647   // it is a file system and read the file contents that we wrote earlier.
 648   pp::Var var = message_data_.back();
 649   ASSERT_TRUE(var.is_resource());
 650   pp::Resource result = var.AsResource();
 651   ASSERT_TRUE(pp::FileSystem::IsFileSystem(result));
 652   {
 653     pp::FileSystem received_file_system(result);
 654     pp::FileRef file_ref(received_file_system, file_path.c_str());
 655     ASSERT_NE(0, file_ref.pp_resource());
 656
 657     // Ensure that the file can be queried.
 658     TestCompletionCallbackWithOutput<PP_FileInfo> cc(instance_->pp_instance(),
 659                                                      callback_type());
 660     cc.WaitForResult(file_ref.Query(cc.GetCallback()));
 661     CHECK_CALLBACK_BEHAVIOR(cc);
 662     ASSERT_EQ(PP_OK, cc.result());
 663     ASSERT_EQ(cc.output().size, content_length);
 664
 665     // Read the file and test that its contents match.
 666     pp::FileIO file_io(instance_);
 667     ASSERT_NE(0, file_io.pp_resource());
 668     callback.WaitForResult(
 669         file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback.GetCallback()));
 670     CHECK_CALLBACK_BEHAVIOR(callback);
 671     ASSERT_EQ(PP_OK, callback.result());
 672
 673     std::vector<char> buffer_vector(content_length);
 674     char* buffer = &buffer_vector[0];  // Note: Not null-terminated!
 675     callback.WaitForResult(
 676         file_io.Read(0, buffer, content_length, callback.GetCallback()));
 677     CHECK_CALLBACK_BEHAVIOR(callback);
 678     ASSERT_EQ(callback.result(), content_length);
 679     ASSERT_EQ(0, memcmp(buffer, kTestString, content_length));
 680   }
 681
 682   WaitForMessages();
 683   message_data_.clear();
 684   ASSERT_TRUE(ClearListeners());
 685
 686   PASS();
 687 }
 688
 689 std::string TestPostMessage::TestSendingComplexVar() {
 690   // Clean up after previous tests. This also swallows the message sent by Init
 691   // if we didn't run the 'SendInInit' test. All tests other than 'SendInInit'
 692   // should start with these.
 693   WaitForMessages();
 694   message_data_.clear();
 695   ASSERT_TRUE(ClearListeners());
 696
 697   pp::Var string(kTestString);
 698   pp::VarDictionary dictionary;
 699   dictionary.Set(pp::Var("foo"), pp::Var(kTestBool));
 700   dictionary.Set(pp::Var("bar"), string);
 701   dictionary.Set(pp::Var("abc"), pp::Var(kTestInt));
 702   dictionary.Set(pp::Var("def"), pp::Var());
 703
 704   // Reference to array.
 705   pp::VarArray array;
 706   array.Set(0, pp::Var(kTestBool));
 707   array.Set(1, string);
 708   // Purposely leave index 2 empty (which will place an undefined var there).
 709   array.Set(3, pp::Var(kTestInt));
 710   array.Set(4, pp::Var(kTestDouble));
 711
 712   dictionary.Set(pp::Var("array-ref1"), array);
 713   dictionary.Set(pp::Var("array-ref2"), array);
 714
 715   // Set up the JavaScript message event listener to echo the data part of the
 716   // message event back to us.
 717   ASSERT_TRUE(AddEchoingListener("message_event.data"));
 718   instance_->PostMessage(dictionary);
 719   // PostMessage is asynchronous, so we should not receive a response yet.
 720   ASSERT_EQ(0, message_data_.size());
 721   ASSERT_EQ(1, WaitForMessages());
 722   ASSERT_TRUE(message_data_.back().is_dictionary());
 723   pp::VarDictionary result(message_data_.back());
 724   ASSERT_TRUE(VarsEqual(dictionary, message_data_.back()));
 725
 726   WaitForMessages();
 727   message_data_.clear();
 728   ASSERT_TRUE(ClearListeners());
 729
 730   // Set up a (dictionary -> array -> dictionary) cycle. Cycles shouldn't be
 731   // transmitted.
 732   pp::VarArray array2;
 733   array2.Set(0, dictionary);
 734   dictionary.Set(pp::Var("array2"), array2);
 735
 736   ASSERT_TRUE(AddEchoingListener("message_event.data"));
 737   instance_->PostMessage(dictionary);
 738   // PostMessage is asynchronous, so we should not receive a response yet.
 739   ASSERT_EQ(0, message_data_.size());
 740   ASSERT_EQ(WaitForMessages(), 0);
 741
 742   // Break the cycles.
 743   dictionary.Delete(pp::Var("array2"));
 744
 745   WaitForMessages();
 746   message_data_.clear();
 747   ASSERT_TRUE(ClearListeners());
 748
 749   // Test sending a cycle from JavaScript to the plugin.
 750   ASSERT_TRUE(AddEchoingListener("message_event.data"));
 751   PostMessageFromJavaScript("function() { var x = []; x[0] = x; return x; }");
 752   ASSERT_EQ(0, message_data_.size());
 753   ASSERT_EQ(WaitForMessages(), 0);
 754
 755   WaitForMessages();
 756   message_data_.clear();
 757   ASSERT_TRUE(ClearListeners());
 758
 759   PASS();
 760 }
 761
 762 std::string TestPostMessage::TestMessageEvent() {
 763   // Set up the JavaScript message event listener to pass us some values from
 764   // the MessageEvent and make sure they match our expectations.
 765
 766   WaitForMessages();
 767   ASSERT_TRUE(ClearListeners());
 768   // Have the listener pass back the class name of message_event and make sure
 769   // it's "MessageEvent".
 770   ASSERT_TRUE(AddEchoingListener("message_event.constructor.name"));
 771   message_data_.clear();
 772   instance_->PostMessage(pp::Var(kTestInt));
 773   ASSERT_EQ(0, message_data_.size());
 774   ASSERT_EQ(1, WaitForMessages());
 775   ASSERT_TRUE(message_data_.back().is_string());
 776   ASSERT_EQ(message_data_.back().AsString(), "MessageEvent");
 777   ASSERT_TRUE(ClearListeners());
 778
 779   // Make sure all the non-data properties have the expected values.
 780   bool success = AddEchoingListener("((message_event.origin === '')"
 781                                    " && (message_event.lastEventId === '')"
 782                                    " && (message_event.source === null)"
 783                                    " && (message_event.ports.length === 0)"
 784                                    " && (message_event.bubbles === false)"
 785                                    " && (message_event.cancelable === false)"
 786                                    ")");
 787   ASSERT_TRUE(success);
 788   message_data_.clear();
 789   instance_->PostMessage(pp::Var(kTestInt));
 790   ASSERT_EQ(0, message_data_.size());
 791   ASSERT_EQ(1, WaitForMessages());
 792   ASSERT_TRUE(message_data_.back().is_bool());
 793   ASSERT_TRUE(message_data_.back().AsBool());
 794   ASSERT_TRUE(ClearListeners());
 795
 796   // Add some event handlers to make sure they receive messages.
 797   ASSERT_TRUE(AddEchoingListener("1"));
 798   ASSERT_TRUE(AddEchoingListener("2"));
 799   ASSERT_TRUE(AddEchoingListener("3"));
 800
 801   message_data_.clear();
 802   instance_->PostMessage(pp::Var(kTestInt));
 803   // Make sure we don't get a response in a re-entrant fashion.
 804   ASSERT_EQ(0, message_data_.size());
 805   // We should get 3 messages.
 806   ASSERT_EQ(WaitForMessages(), 3);
 807   // Copy to a vector of doubles and sort; w3c does not specify the order for
 808   // event listeners. (Copying is easier than writing an operator< for pp::Var.)
 809   //
 810   // See http://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html.
 811   VarVector::iterator iter(message_data_.begin()), the_end(message_data_.end());
 812   std::vector<double> double_vec;
 813   for (; iter != the_end; ++iter) {
 814     ASSERT_TRUE(iter->is_number());
 815     double_vec.push_back(iter->AsDouble());
 816   }
 817   std::sort(double_vec.begin(), double_vec.end());
 818   ASSERT_DOUBLE_EQ(double_vec[0], 1.0);
 819   ASSERT_DOUBLE_EQ(double_vec[1], 2.0);
 820   ASSERT_DOUBLE_EQ(double_vec[2], 3.0);
 821
 822   message_data_.clear();
 823   ASSERT_TRUE(ClearListeners());
 824
 825   PASS();
 826 }
 827
 828 std::string TestPostMessage::TestNoHandler() {
 829   // Delete any lingering messages and event listeners.
 830   WaitForMessages();
 831   ASSERT_TRUE(ClearListeners());
 832
 833   // Now send a message.  We shouldn't get a response.
 834   message_data_.clear();
 835   instance_->PostMessage(pp::Var());
 836   ASSERT_EQ(WaitForMessages(), 0);
 837   ASSERT_TRUE(message_data_.empty());
 838
 839   PASS();
 840 }
 841
 842 std::string TestPostMessage::TestExtraParam() {
 843   // Delete any lingering messages and event listeners.
 844   WaitForMessages();
 845   ASSERT_TRUE(ClearListeners());
 846   // Add a listener that will respond with 1 and an empty array (where the
 847   // message port array would appear if it was Worker postMessage).
 848   ASSERT_TRUE(AddEchoingListener("1, []"));
 849
 850   // Now send a message.  We shouldn't get a response.
 851   message_data_.clear();
 852   instance_->PostMessage(pp::Var());
 853   ASSERT_EQ(WaitForMessages(), 0);
 854   ASSERT_TRUE(message_data_.empty());
 855
 856   ASSERT_TRUE(ClearListeners());
 857
 858   PASS();
 859 }
 860
 861 std::string TestPostMessage::TestNonMainThread() {
 862   WaitForMessages();
 863   ASSERT_TRUE(ClearListeners());
 864   ASSERT_TRUE(AddEchoingListener("message_event.data"));
 865   message_data_.clear();
 866
 867   // Set up a thread for each integer from 0 to (kThreadsToRun - 1).  Make each
 868   // thread send the number that matches its index kMessagesToSendPerThread
 869   // times.  For good measure, call postMessage from the main thread
 870   // kMessagesToSendPerThread times. At the end, we make sure we got all the
 871   // values we expected.
 872   PP_Thread threads[kThreadsToRun];
 873   for (int32_t i = 0; i < kThreadsToRun; ++i) {
 874     // Set up a thread to send a value of i.
 875     void* arg = new InvokePostMessageThreadArg(instance_, pp::Var(i));
 876     PP_CreateThread(&threads[i], &InvokePostMessageThreadFunc, arg);
 877   }
 878   // Invoke PostMessage right now to send a value of (kThreadsToRun).
 879   for (int32_t i = 0; i < kMessagesToSendPerThread; ++i)
 880     instance_->PostMessage(pp::Var(kThreadsToRun));
 881
 882   // Now join all threads.
 883   for (int32_t i = 0; i < kThreadsToRun; ++i)
 884     PP_JoinThread(threads[i]);
 885
 886   // PostMessage is asynchronous, so we should not receive a response yet.
 887   ASSERT_EQ(0, message_data_.size());
 888
 889   // Make sure we got all values that we expected.  Note that because it's legal
 890   // for the JavaScript engine to treat our integers as floating points, we
 891   // can't just use std::find or equality comparison. So we instead, we convert
 892   // each incoming value to an integer, and count them in received_counts.
 893   int32_t expected_num = (kThreadsToRun + 1) * kMessagesToSendPerThread;
 894   // Count how many we receive per-index.
 895   std::vector<int32_t> expected_counts(kThreadsToRun + 1,
 896                                        kMessagesToSendPerThread);
 897   std::vector<int32_t> received_counts(kThreadsToRun + 1, 0);
 898   ASSERT_EQ(expected_num, WaitForMessages());
 899   for (int32_t i = 0; i < expected_num; ++i) {
 900     const pp::Var& latest_var(message_data_[i]);
 901     ASSERT_TRUE(latest_var.is_int() || latest_var.is_double());
 902     int32_t received_value = -1;
 903     if (latest_var.is_int()) {
 904       received_value = latest_var.AsInt();
 905     } else if (latest_var.is_double()) {
 906       received_value = static_cast<int32_t>(latest_var.AsDouble() + 0.5);
 907     }
 908     ASSERT_TRUE(received_value >= 0);
 909     ASSERT_TRUE(received_value <= kThreadsToRun);
 910     ++received_counts[received_value];
 911   }
 912   ASSERT_EQ(expected_counts, received_counts);
 913
 914   message_data_.clear();
 915   ASSERT_TRUE(ClearListeners());
 916
 917   PASS();
 918 }