[PPAPI] It is now possible to pass filesystems from JavaScript to NaCl modules.

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 <string.h>
 #include <algorithm>
 #include <map>
 #include <sstream>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/pp_var.h"
+#include "ppapi/c/ppb_file_io.h"
+#include "ppapi/cpp/file_io.h"
+#include "ppapi/cpp/file_ref.h"
+#include "ppapi/cpp/file_system.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/cpp/var_array.h"
 #include "ppapi/cpp/var_array_buffer.h"
 #include "ppapi/cpp/var_dictionary.h"
 #include "ppapi/tests/pp_thread.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 
 // Windows defines 'PostMessage', so we have to undef it.
 #ifdef PostMessage
 #undef PostMessage
 #endif
 
 REGISTER_TEST_CASE(PostMessage);
 
 namespace {
 
+const char kTestFilename[] = "testfile.txt";
 const char kTestString[] = "Hello world!";
 const bool kTestBool = true;
 const int32_t kTestInt = 42;
 const double kTestDouble = 42.0;
 
 // On Windows XP bots, the NonMainThread test can run very slowly. So we dial
 // back the number of threads & messages when running on Windows.
 #ifdef PPAPI_OS_WIN
 const int32_t kThreadsToRun = 2;
 const int32_t kMessagesToSendPerThread = 5;
@@ skipping 113 matching lines @@
   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 = CheckTestingInterface();
 
+  core_interface_ = static_cast<const PPB_Core*>(
+      pp::Module::Get()->GetBrowserInterface(PPB_CORE_INTERFACE));
+  file_system_interface_ = static_cast<const PPB_FileSystem*>(
+      pp::Module::Get()->GetBrowserInterface(PPB_FILESYSTEM_INTERFACE));
+  var_interface_ = static_cast<const PPB_Var*>(
+      pp::Module::Get()->GetBrowserInterface(PPB_VAR_INTERFACE));
+  var_resource_interface_ = static_cast<const PPB_VarResource_Dev*>(
+      pp::Module::Get()->GetBrowserInterface(PPB_VAR_RESOURCE_DEV_INTERFACE));
+  if (!core_interface_ || !file_system_interface_ || !var_interface_ ||
+      !var_resource_interface_)
+    return false;
+
   // 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');"
              "var wait_for_messages_handler = function(message_event) {"
@@ skipping 20 matching lines @@
 }
 
 void TestPostMessage::RunTests(const std::string& filter) {
   // Note: SendInInit must be first, because it expects to receive a message
   // that was sent in Init above.
   RUN_TEST(SendInInit, filter);
   RUN_TEST(SendingData, filter);
   RUN_TEST(SendingArrayBuffer, filter);
   RUN_TEST(SendingArray, filter);
   RUN_TEST(SendingDictionary, filter);
+  RUN_TEST(SendingResource, filter);
   RUN_TEST(SendingComplexVar, filter);
   RUN_TEST(MessageEvent, filter);
   RUN_TEST(NoHandler, filter);
   RUN_TEST(ExtraParam, filter);
   if (testing_interface_->IsOutOfProcess())
     RUN_TEST(NonMainThread, filter);
 }
 
 void TestPostMessage::HandleMessage(const pp::Var& message_data) {
   if (message_data.is_string() &&
@@ skipping 32 matching lines @@
 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::PostMessageFromJavaScriptAsync(const std::string& func) {
+  // After the |func| calls callback, post both the given |message|, as well as
+  // the special message FINISHED_WAITING_MESSAGE. This ensures that
+  // WaitForMessagesAsync correctly waits until the callback is called.
+  std::string js_code;
+  js_code += "var plugin = document.getElementById('plugin');"
+             "var callback = function(message) {"
+             "  plugin.postMessage(message);"
+             "  plugin.postMessage('" FINISHED_WAITING_MESSAGE "');"
+             "};";
+  js_code += "(" + func + ")(callback);";
+  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;
 }
 
 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
   // received (which may be zero).
   return message_data_.size() - message_size_before;
 }
 
+int TestPostMessage::WaitForMessagesAsync() {

[dmichael (off chromium), 2013/10/23 17:36:02]

This function only works right if you've called PostMessageFromJavaScriptAsync
exactly once before it. 0 will cause a hang, >1 will be dropped (and 1 is
returned).

What about rolling these two new methods in to one, that posts 1 message and
then returns some indication as to whether that message was received. Then it
will be harder to use incorrectly.

[Matt Giuca, 2013/10/24 01:00:11]

Done.

+  size_t message_size_before = message_data_.size();
+  // Unlike WaitForMessages, we do not post FINISHED_WAITING_MESSAGE. This is
+  // because PostMessageFromJavaScriptAsync will post it for us, when the
+  // asynchronous operation completes.
+  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
+  // received (which may be zero).
+  return message_data_.size() - message_size_before;
+}
+
 std::string TestPostMessage::CheckMessageProperties(
     const pp::Var& test_data,
     const std::vector<std::string>& properties_to_check) {
   typedef std::vector<std::string>::const_iterator Iterator;
   for (Iterator iter = properties_to_check.begin();
        iter != properties_to_check.end();
        ++iter) {
     ASSERT_TRUE(AddEchoingListener(*iter));
     message_data_.clear();
     instance_->PostMessage(test_data);
@@ skipping 237 matching lines @@
   ASSERT_EQ(WaitForMessages(), 1);
   ASSERT_TRUE(message_data_.back().is_dictionary());
   ASSERT_TRUE(VarsEqual(dictionary, message_data_.back()));
 
   message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
   PASS();
 }
 
+std::string TestPostMessage::TestSendingResource() {
+  // 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());
+
+  // Test sending a DOMFileSystem from JavaScript to the plugin.
+  // This opens a real (temporary) file using the HTML5 FileSystem API and
+  // writes to it.
+  ASSERT_TRUE(AddEchoingListener("message_event.data"));
+  std::string js_code =
+      "function(callback) {"
+      "  window.webkitRequestFileSystem(window.TEMPORARY, 1024,"
+      "                                 function(fileSystem) {"
+      "    fileSystem.root.getFile('";
+  js_code += kTestFilename;
+  js_code += "', {create: true}, function(tempFile) {"
+      "      tempFile.createWriter(function(writer) {"
+      "        writer.onerror = function() { callback(null); };"
+      "        writer.onwriteend = function() { callback(fileSystem); };"
+      "        var blob = new Blob(['";
+  js_code += kTestString;
+  js_code += "'], {'type': 'text/plain'});"
+      "        writer.write(blob);"
+      "      });"
+      "    }, function() { callback(null); });"
+      "  }, function() { callback(null); });"
+      "}";
+  PostMessageFromJavaScriptAsync(js_code);
+  ASSERT_EQ(message_data_.size(), 0);
+  ASSERT_EQ(WaitForMessagesAsync(), 1);
+  // TODO(mgiuca): Use the C++ API instead of the C API, when it is available.
+  PP_Var var = message_data_.back().Detach();
+  PP_Resource result = var_resource_interface_->VarToResource(var);
+  ASSERT_TRUE(file_system_interface_->IsFileSystem(result));
+  {
+    pp::FileSystem file_system(pp::PASS_REF, result);
+    std::string file_path = "/";
+    file_path += kTestFilename;
+    pp::FileRef file_ref(file_system, file_path.c_str());
+    ASSERT_NE(0, file_ref.pp_resource());
+    ASSERT_EQ(kTestFilename, file_ref.GetName().AsString());
+    pp::FileIO file_io(instance_);
+    ASSERT_NE(0, file_io.pp_resource());
+
+    TestCompletionCallback callback_1(instance_->pp_instance(),
+                                      callback_type());
+    callback_1.WaitForResult(
+        file_io.Open(file_ref, PP_FILEOPENFLAG_READ, callback_1.GetCallback()));
+    CHECK_CALLBACK_BEHAVIOR(callback_1);
+    ASSERT_EQ(PP_OK, callback_1.result());
+
+    TestCompletionCallback callback_2(instance_->pp_instance(),
+                                      callback_type());

[dmichael (off chromium), 2013/10/23 17:33:21]

We usually just reuse the first TestCompletionCallback. GetCallback() returns a
new pp::CompletionCallback each time.

[Matt Giuca, 2013/10/24 01:00:11]

Done. (I copied the callback_1 style from test_file_io.cc; it's quite prevalent
there.)

[dmichael (off chromium), 2013/10/25 20:13:16]

That's necessary when you have 2 operations in parallel and need 2 distinct
callbacks at the same time. I think that's how FileIO uses it, FWIW.

+    int length = strlen(kTestString);
+    char buffer[length];  // Note: Not null-terminated!
+    callback_2.WaitForResult(
+        file_io.Read(0, buffer, length, callback_2.GetCallback()));
+    CHECK_CALLBACK_BEHAVIOR(callback_2);
+    ASSERT_EQ(length, callback_2.result());
+    ASSERT_EQ(0, memcmp(buffer, kTestString, length));
+  }
+  var_interface_->Release(var);
+
+  WaitForMessages();
+  message_data_.clear();
+  ASSERT_TRUE(ClearListeners());
+
+  // TODO(mgiuca): Test roundtrip from plugin to JS and back, when the plugin to
+  // JS support is available.
+
+  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 dictionary;
@@ skipping 210 matching lines @@
     ASSERT_TRUE(received_value <= kThreadsToRun);
     ++received_counts[received_value];
   }
   ASSERT_EQ(received_counts, expected_counts);
 
   message_data_.clear();
   ASSERT_TRUE(ClearListeners());
 
   PASS();
 }