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