Make PPAPI PostMessage behave asynchronously.

webkit/plugins/ppapi/message_channel.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/plugins/ppapi/message_channel.h"
 
 #include <cstdlib>
 #include <string>
 
 #include "base/logging.h"
+#include "base/message_loop.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "webkit/plugins/ppapi/npapi_glue.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/var.h"
 
 using WebKit::WebBindings;
@@ skipping 50 matching lines @@
       if (!string) {
         VOID_TO_NPVARIANT(*result);
         return false;
       }
       const std::string& value = string->value();
       STRINGN_TO_NPVARIANT(value.c_str(), value.size(), *result);
       break;
     }
     case PP_VARTYPE_OBJECT:
       // Objects are not currently supported.
-      DCHECK(false);
+      NOTIMPLEMENTED();
       VOID_TO_NPVARIANT(*result);
       return false;
     default:
       VOID_TO_NPVARIANT(*result);
       return false;
   }
   return true;
 }
 
+// Copy a PP_Var in to a PP_Var that is appropriate for sending via postMessage.
+// This currently just copies the value.  For a string Var, the result is a
+// PP_Var with the a copy of |var|'s string contents and a reference count of 1.
+//
+// TODO(dmichael):  We need to do structured clone eventually to copy a object
+// structure.  The details and PPAPI changes for this are TBD.
+PP_Var CopyPPVar(const PP_Var& var) {
+  if (var.type == PP_VARTYPE_OBJECT) {
+    // Objects are not currently supported.
+    NOTIMPLEMENTED();
+    return PP_MakeUndefined();
+  } else if (var.type == PP_VARTYPE_STRING) {
+    scoped_refptr<StringVar> string(StringVar::FromPPVar(var));
+    if (!string) {

[brettw, 2011/03/26 17:34:16]

Be consistent, so no {} for single-line conditionals.

[dmichael(do not use this one), 2011/03/26 20:57:08]

Argh...  old habits die hard.  Thanks.

+      return PP_MakeUndefined();
+    }
+    return StringVar::StringToPPVar(string->module(), string->value());
+  } else {
+    return var;
+  }
+}
+
 //------------------------------------------------------------------------------
 // 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;
 }
 
@@ skipping 148 matching lines @@
 }  // namespace
 
 // MessageChannel --------------------------------------------------------------
 MessageChannel::MessageChannelNPObject::MessageChannelNPObject() {}
 
 MessageChannel::MessageChannelNPObject::~MessageChannelNPObject() {}
 
 MessageChannel::MessageChannel(PluginInstance* instance)
     : instance_(instance),
       passthrough_object_(NULL),
-      np_object_(NULL) {
+      np_object_(NULL),
+      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
   VOID_TO_NPVARIANT(onmessage_invoker_);
 
   // Now create an NPObject for receiving calls to postMessage.
   NPObject* obj = WebBindings::createObject(NULL, &message_channel_class);
   DCHECK(obj);
   np_object_ = static_cast<MessageChannel::MessageChannelNPObject*>(obj);
   np_object_->message_channel = this;
 }
 
 bool MessageChannel::EvaluateOnMessageInvoker() {
@@ skipping 29 matching lines @@
   if (!WebBindings::evaluate(NULL, frame->windowObject(), &function_string,
                              &onmessage_invoker_)) {
     // If it fails, do nothing.
     return false;
   }
   DCHECK(NPVARIANT_IS_OBJECT(onmessage_invoker_));
   return true;
 }
 
 void MessageChannel::PostMessageToJavaScript(PP_Var message_data) {
-  // Make sure we have our function for invoking a JavaScript onmessage
-  // function.
+  // Make a copy of the message data for the Task we will run.
+  PP_Var var_copy(CopyPPVar(message_data));
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      method_factory_.NewRunnableMethod(
+          &MessageChannel::PostMessageToJavaScriptImpl,
+          var_copy));
+}
+
+void MessageChannel::PostMessageToJavaScriptImpl(PP_Var message_data) {
+  // Make sure we have our function for invoking onmessage on JavaScript.
   bool success = EvaluateOnMessageInvoker();
   DCHECK(success);
   if (!success)
     return;
 
   DCHECK(instance_);
 
   NPVariant result_var;
   VOID_TO_NPVARIANT(result_var);
   NPVariant npvariant_args[2];
   OBJECT_TO_NPVARIANT(instance_->container()->scriptableObjectForElement(),
                       npvariant_args[0]);
-  // Convert message to an NPVariant without copying.  Note this means that
-  // in-process plugins will not copy the data, so isn't really following the
-  // postMessage spec in spirit.  Copying is handled in the proxy, and we don't
-  // want to re-copy unnecessarily.
-  //
-  // TODO(dmichael):  We need to do structured clone eventually to copy a object
-  // structure.  The details and PPAPI changes for this are TBD.
+  // Convert message to an NPVariant without copying. At this point, the data
+  // has already been copied.
   if (!PPVarToNPVariantNoCopy(message_data, &npvariant_args[1]))
     return;
 
   WebBindings::invokeDefault(NULL,
                              NPVARIANT_TO_OBJECT(onmessage_invoker_),
                              npvariant_args,
                              sizeof(npvariant_args)/sizeof(*npvariant_args),
                              &result_var);
 }
 
 void MessageChannel::PostMessageToNative(PP_Var message_data) {
+  // Make a copy of the message data for the Task we will run.
+  PP_Var var_copy(CopyPPVar(message_data));
+
+  MessageLoop::current()->PostTask(FROM_HERE,
+      method_factory_.NewRunnableMethod(
+          &MessageChannel::PostMessageToNativeImpl,
+          var_copy));
+}
+
+void MessageChannel::PostMessageToNativeImpl(PP_Var message_data) {
   instance_->HandleMessage(message_data);
 }
 
 MessageChannel::~MessageChannel() {
   WebBindings::releaseObject(np_object_);
   WebBindings::releaseVariantValue(&onmessage_invoker_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit