PPAPI: Make Messaging not PostTask and copy when out-of-process.

webkit/plugins/ppapi/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 "webkit/plugins/ppapi/message_channel.h"
 
 #include <cstdlib>
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.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/WebDOMMessageEvent.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/WebNode.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebSerializedScriptValue.h"
 #include "v8/include/v8.h"
 #include "webkit/plugins/ppapi/host_array_buffer_var.h"
 #include "webkit/plugins/ppapi/npapi_glue.h"
+#include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 using ppapi::ArrayBufferVar;
 using ppapi::PpapiGlobals;
 using ppapi::StringVar;
 using WebKit::WebBindings;
 using WebKit::WebElement;
 using WebKit::WebDOMEvent;
 using WebKit::WebDOMMessageEvent;
 using WebKit::WebPluginContainer;
@@ skipping 286 matching lines @@
 // MessageChannel --------------------------------------------------------------
 MessageChannel::MessageChannelNPObject::MessageChannelNPObject() {
 }
 
 MessageChannel::MessageChannelNPObject::~MessageChannelNPObject() {}
 
 MessageChannel::MessageChannel(PluginInstance* instance)
     : instance_(instance),
       passthrough_object_(NULL),
       np_object_(NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
+      early_message_queue_state_(QUEUE_MESSAGES) {
   // Now create an NPObject for receiving calls to postMessage. This sets the
   // reference count to 1.  We release it in the destructor.
   NPObject* obj = WebBindings::createObject(NULL, &message_channel_class);
   DCHECK(obj);
   np_object_ = static_cast<MessageChannel::MessageChannelNPObject*>(obj);
   np_object_->message_channel = weak_ptr_factory_.GetWeakPtr();
 }
 
 void MessageChannel::PostMessageToJavaScript(PP_Var message_data) {
   // Serialize the message data.
   v8::HandleScope scope;
   // Because V8 is probably not on the stack for Native->JS calls, we need to
   // enter the appropriate context for the plugin.
   v8::Local<v8::Context> context =
       instance_->container()->element().document().frame()->
           mainWorldScriptContext();
   v8::Context::Scope context_scope(context);
 
   v8::Local<v8::Value> v8_val;
   if (!PPVarToV8Value(message_data, &v8_val)) {
     NOTREACHED();
     return;
   }
 
   WebSerializedScriptValue serialized_val =
       WebSerializedScriptValue::serialize(v8_val);
 
+  if (instance_->module()->IsProxied()) {
+    if (early_message_queue_state_ != SEND_DIRECTLY) {
+      // We can't just PostTask here; the messages would arrive out of
+      // order. Instead, we queue them up until we're ready to post
+      // them.
+      early_message_queue_.push_back(serialized_val);
+    } else {
+      // The proxy sent an asynchronous message, so the plugin is already
+      // unblocked. Therefore, there's no need to PostTask.
+      DCHECK(early_message_queue_.size() == 0);
+      PostMessageToJavaScriptImpl(serialized_val);
+    }
+  } else {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&MessageChannel::PostMessageToJavaScriptImpl,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   serialized_val));
+  }
+}
+
+void MessageChannel::StopQueueingJavaScriptMessages() {
+  // We PostTask here instead of draining the message queue directly
+  // since we haven't finished initializing the WebPluginImpl yet, so
+  // the plugin isn't available in the DOM.
+  early_message_queue_state_ = DRAIN_PENDING;
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&MessageChannel::PostMessageToJavaScriptImpl,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 serialized_val));
+      base::Bind(&MessageChannel::DrainEarlyMessageQueue,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void MessageChannel::QueueJavaScriptMessages() {
+  if (early_message_queue_state_ == DRAIN_PENDING)
+    early_message_queue_state_ = DRAIN_CANCELLED;
+  else
+    early_message_queue_state_ = QUEUE_MESSAGES;
+}
+
+void MessageChannel::DrainEarlyMessageQueue() {
+  if (early_message_queue_state_ == DRAIN_CANCELLED) {
+    early_message_queue_state_ = QUEUE_MESSAGES;
+    return;
+  }
+  DCHECK(early_message_queue_state_ == DRAIN_PENDING);
+
+  while (!early_message_queue_.empty()) {
+    PostMessageToJavaScriptImpl(early_message_queue_.front());
+    early_message_queue_.pop_front();
+  }
+  early_message_queue_state_ = SEND_DIRECTLY;
 }
 
 void MessageChannel::PostMessageToJavaScriptImpl(
     const WebSerializedScriptValue& message_data) {
   DCHECK(instance_);
 
   WebPluginContainer* container = instance_->container();
   // It's possible that container() is NULL if the plugin has been removed from
   // the DOM (but the PluginInstance is not destroyed yet).
   if (!container)
@@ skipping 15 matching lines @@
   //      http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html
   //     This currently behaves like Web Workers. On Firefox, Chrome, and Safari
   //     at least, postMessage on Workers does not provide the origin or source.
   //     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(PP_Var message_data) {
-  // Make a copy of the message data for the Task we will run.
-  PP_Var var_copy(CopyPPVar(message_data));
+  if (instance_->module()->IsProxied()) {
+    // In the proxied case, the copy will happen via serializiation, and the
+    // message is asynchronous. Therefore there's no need to copy the Var, nor
+    // to PostTask.
+    PostMessageToNativeImpl(message_data);
+  } else {
+    // 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,
-      base::Bind(&MessageChannel::PostMessageToNativeImpl,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 var_copy));
+    MessageLoop::current()->PostTask(FROM_HERE,
+        base::Bind(&MessageChannel::PostMessageToNativeImpl,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   var_copy));
+  }
 }
 
 void MessageChannel::PostMessageToNativeImpl(PP_Var message_data) {
   instance_->HandleMessage(message_data);
 }
 
 MessageChannel::~MessageChannel() {
   WebBindings::releaseObject(np_object_);
   if (passthrough_object_)
     WebBindings::releaseObject(passthrough_object_);
@@ skipping 10 matching lines @@
   // invokes:
   //   SetPassthroughObject(passthrough_object());
   if (passthrough_object_)
     WebBindings::releaseObject(passthrough_object_);
 
   passthrough_object_ = passthrough;
 }
 
 }  // namespace ppapi
 }  // namespace webkit