PPAPI: Implement synchronous postMessage

content/renderer/pepper/message_channel.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 "content/renderer/pepper/message_channel.h"
 
 #include <cstdlib>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 using blink::WebDOMEvent;
 using blink::WebDOMMessageEvent;
 using blink::WebPluginContainer;
 using blink::WebSerializedScriptValue;
 
 namespace content {
 
 namespace {
 
 const char kPostMessage[] = "postMessage";
+const char kPostMessageAndAwaitResponse[] = "postMessageAndAwaitResponse";
 const char kV8ToVarConversionError[] =
     "Failed to convert a PostMessage "
     "argument from a JavaScript value to a PP_Var. It may have cycles or be of "
     "an unsupported type.";
 const char kVarToV8ConversionError[] =
     "Failed to convert a PostMessage "
     "argument from a PP_Var to a Javascript value. It may have cycles or be of "
     "an unsupported type.";
 
 // Helper function to get the MessageChannel that is associated with an
 // NPObject*.
 MessageChannel* ToMessageChannel(NPObject* object) {
   return static_cast<MessageChannel::MessageChannelNPObject*>(object)
       ->message_channel.get();
 }
 
 NPObject* ToPassThroughObject(NPObject* object) {
   MessageChannel* channel = ToMessageChannel(object);
   return channel ? channel->passthrough_object() : NULL;
 }
 
 // Return true iff |identifier| is equal to |string|.
 bool IdentifierIs(NPIdentifier identifier, const char string[]) {
   return WebBindings::getStringIdentifier(string) == identifier;
 }
 
+bool HasDevChannelPermission(NPObject* channel_object) {
+  MessageChannel* channel = ToMessageChannel(channel_object);
+  if (!channel)
+    return false;
+  return channel->instance()->module()->permissions().HasPermission(
+      ppapi::PERMISSION_DEV_CHANNEL);
+}
+
 //------------------------------------------------------------------------------
 // Implementations of NPClass functions.  These are here to:
 // - Implement postMessage behavior.
 // - Forward calls to the 'passthrough' object to allow backwards-compatibility
 //   with GetInstanceObject() objects.
 //------------------------------------------------------------------------------
 NPObject* MessageChannelAllocate(NPP npp, NPClass* the_class) {
   return new MessageChannel::MessageChannelNPObject;
 }
 
 void MessageChannelDeallocate(NPObject* object) {
   MessageChannel::MessageChannelNPObject* instance =
       static_cast<MessageChannel::MessageChannelNPObject*>(object);
   delete instance;
 }
 
 bool MessageChannelHasMethod(NPObject* np_obj, NPIdentifier name) {
   if (!np_obj)
     return false;
 
   if (IdentifierIs(name, kPostMessage))
     return true;
-
+  if (IdentifierIs(name, kPostMessageAndAwaitResponse) &&
+      HasDevChannelPermission(np_obj)) {
+    return true;
+  }
   // Other method names we will pass to the passthrough object, if we have one.
   NPObject* passthrough = ToPassThroughObject(np_obj);
   if (passthrough)
     return WebBindings::hasMethod(NULL, passthrough, name);
   return false;
 }
 
 bool MessageChannelInvoke(NPObject* np_obj,
                           NPIdentifier name,
                           const NPVariant* args,
                           uint32 arg_count,
                           NPVariant* result) {
   if (!np_obj)
     return false;
 
   MessageChannel* message_channel = ToMessageChannel(np_obj);
   if (!message_channel)
     return false;
 
-  // Check to see if we should handle this function ourselves. We only handle
-  // kPostMessage.
+  // Check to see if we should handle this function ourselves.
   if (IdentifierIs(name, kPostMessage) && (arg_count == 1)) {
     message_channel->PostMessageToNative(&args[0]);
     return true;
+  } else if (IdentifierIs(name, kPostMessageAndAwaitResponse) &&
+             (arg_count == 1) &&
+             HasDevChannelPermission(np_obj)) {
+    message_channel->PostBlockingMessageToNative(&args[0], result);
+    return true;
   }
+
   // Other method calls we will pass to the passthrough object, if we have one.
   NPObject* passthrough = ToPassThroughObject(np_obj);
   if (passthrough) {
     return WebBindings::invoke(
         NULL, passthrough, name, args, arg_count, result);
   }
   return false;
 }
 
 bool MessageChannelInvokeDefault(NPObject* np_obj,
@@ skipping 28 matching lines @@
     return WebBindings::hasProperty(NULL, passthrough, name);
   return false;
 }
 
 bool MessageChannelGetProperty(NPObject* np_obj,
                                NPIdentifier name,
                                NPVariant* result) {
   if (!np_obj)
     return false;
 
-  // Don't allow getting the postMessage function.
+  // Don't allow getting the postMessage functions.
   if (IdentifierIs(name, kPostMessage))
     return false;
-
+  if (IdentifierIs(name, kPostMessageAndAwaitResponse) &&
+      HasDevChannelPermission(np_obj)) {
+     return false;
+  }
   MessageChannel* message_channel = ToMessageChannel(np_obj);
   if (message_channel) {
     if (message_channel->GetReadOnlyProperty(name, result))
       return true;
   }
 
   // Invoke on the passthrough object, if we have one.
   NPObject* passthrough = ToPassThroughObject(np_obj);
   if (passthrough)
     return WebBindings::getProperty(NULL, passthrough, name, result);
   return false;
 }
 
 bool MessageChannelSetProperty(NPObject* np_obj,
                                NPIdentifier name,
                                const NPVariant* variant) {
   if (!np_obj)
     return false;
 
-  // Don't allow setting the postMessage function.
+  // Don't allow setting the postMessage functions.
   if (IdentifierIs(name, kPostMessage))
     return false;
-
+  if (IdentifierIs(name, kPostMessageAndAwaitResponse) &&
+      HasDevChannelPermission(np_obj)) {
+    return false;
+  }
   // Invoke on the passthrough object, if we have one.
   NPObject* passthrough = ToPassThroughObject(np_obj);
   if (passthrough)
     return WebBindings::setProperty(NULL, passthrough, name, variant);
   return false;
 }
 
 bool MessageChannelEnumerate(NPObject* np_obj,
                              NPIdentifier** value,
                              uint32_t* count) {
@@ skipping 233 matching lines @@
   //     TODO(dmichael):  Add origin if we change to a more iframe-like origin
   //                      policy (see crbug.com/81537)
   container->element().dispatchEvent(msg_event);
 }
 
 void MessageChannel::PostMessageToNative(const NPVariant* message_data) {
   EnqueuePluginMessage(message_data);
   DrainCompletedPluginMessages();
 }
 
+void MessageChannel::PostBlockingMessageToNative(const NPVariant* message_data,
+                                                 NPVariant* np_result) {
+  if (early_message_queue_state_ == QUEUE_MESSAGES) {
+    WebBindings::setException(
+        np_object_,
+        "Attempted to call a synchronous method on a plugin that was not "
+        "yet loaded.");
+    return;
+  }
+
+  // If the queue of messages to the plugin is non-empty, we're still waiting on
+  // pending Var conversions. This means at some point in the past, JavaScript
+  // called postMessage (the async one) and passed us something with a browser-
+  // side host (e.g., FileSystem) and we haven't gotten a response from the
+  // browser yet. We can't currently support sending a sync message if the
+  // plugin does this, because it will break the ordering of the messages
+  // arriving at the plugin.
+  // TODO(dmichael): Fix this.
+  // See https://code.google.com/p/chromium/issues/detail?id=367896#c4
+  if (!plugin_message_queue_.empty()) {
+    WebBindings::setException(
+        np_object_,
+        "Failed to convert parameter synchronously, because a prior "
+        "call to postMessage contained a type which required asynchronous "
+        "transfer which has not completed. Not all types are supported yet by "
+        "postMessageAndAwaitResponse. See crbug.com/367896.");
+    return;
+  }
+  ScopedPPVar param;
+  if (message_data->type == NPVariantType_Object) {
+    // Convert NPVariantType_Object in to an appropriate PP_Var like Dictionary,
+    // Array, etc. Note NPVariantToVar would convert to an "Object" PP_Var,
+    // which we don't support for Messaging.
+    v8::Handle<v8::Value> v8_value = WebBindings::toV8Value(message_data);
+    V8VarConverter v8_var_converter(instance_->pp_instance());
+    bool success = v8_var_converter.FromV8ValueSync(
+        v8_value,
+        v8::Isolate::GetCurrent()->GetCurrentContext(),
+        &param);
+    if (!success) {
+      WebBindings::setException(
+          np_object_,
+          "Failed to convert the given parameter to a PP_Var to send to "
+          "the plugin.");
+      return;
+    }
+  } else {
+    param = ScopedPPVar(ScopedPPVar::PassRef(),
+                        NPVariantToPPVar(instance(), message_data));
+  }
+  ScopedPPVar pp_result;
+  bool was_handled = instance_->HandleBlockingMessage(param, &pp_result);
+  if (!was_handled) {
+    WebBindings::setException(
+        np_object_,
+        "The plugin has not registered a handler for synchronous messages. "
+        "See the documentation for PPB_Messaging::RegisterMessageHandler "
+        "and PPP_MessageHandler.");
+    return;
+  }
+  v8::Handle<v8::Value> v8_val;
+  if (!V8VarConverter(instance_->pp_instance()).ToV8Value(
+          pp_result.get(),
+          v8::Isolate::GetCurrent()->GetCurrentContext(),
+          &v8_val)) {
+    WebBindings::setException(
+        np_object_,
+        "Failed to convert the plugin's result to a JavaScript type.");
+    return;
+  }
+  // Success! Convert the result to an NPVariant.
+  WebBindings::toNPVariant(v8_val, NULL, np_result);
+}
+
 MessageChannel::~MessageChannel() {
   WebBindings::releaseObject(np_object_);
   if (passthrough_object_)
     WebBindings::releaseObject(passthrough_object_);
 }
 
 void MessageChannel::SetPassthroughObject(NPObject* passthrough) {
   // Retain the passthrough object; We need to ensure it lives as long as this
   // MessageChannel.
   if (passthrough)
@@ skipping 19 matching lines @@
     return true;
   }
   return false;
 }
 
 void MessageChannel::SetReadOnlyProperty(PP_Var key, PP_Var value) {
   internal_properties_[PPVarToNPIdentifier(key)] = ScopedPPVar(value);
 }
 
 }  // namespace content