Revert of PPAPI: Never re-enter JavaScript for 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 86 matching lines @@
   MessageChannel* message_channel = new MessageChannel(instance);
   v8::HandleScope handle_scope(instance->GetIsolate());
   v8::Context::Scope context_scope(instance->GetContext());
   gin::Handle<MessageChannel> handle =
       gin::CreateHandle(instance->GetIsolate(), message_channel);
   result->Reset(instance->GetIsolate(), handle.ToV8()->ToObject());
   return message_channel;
 }
 
 MessageChannel::~MessageChannel() {
-  // Note it's unlikely but possible that we outlive the instance, and so we
-  // might have already unregistered in InstanceDeleted. That's OK, because
-  // removing an observer that's already removed is a no-op.
-  UnregisterSyncMessageStatusObserver();
-
   passthrough_object_.Reset();
   if (instance_)
     instance_->MessageChannelDestroyed();
 }
 
 void MessageChannel::InstanceDeleted() {
-  UnregisterSyncMessageStatusObserver();
   instance_ = NULL;
 }
 
 void MessageChannel::PostMessageToJavaScript(PP_Var message_data) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
 
   // 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_->GetContext();
   if (context.IsEmpty())
     return;
 
   v8::Context::Scope context_scope(context);
 
   v8::Handle<v8::Value> v8_val;
   if (!V8VarConverter(instance_->pp_instance())
            .ToV8Value(message_data, context, &v8_val)) {
     PpapiGlobals::Get()->LogWithSource(instance_->pp_instance(),
                                        PP_LOGLEVEL_ERROR,
                                        std::string(),
                                        kVarToV8ConversionError);
     return;
   }
 
   WebSerializedScriptValue serialized_val =
       WebSerializedScriptValue::serialize(v8_val);
 
-  if (js_message_queue_state_ != SEND_DIRECTLY) {
+  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.
-    js_message_queue_.push_back(serialized_val);
+    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(js_message_queue_.empty());
+    DCHECK(early_message_queue_.empty());
     PostMessageToJavaScriptImpl(serialized_val);
   }
 }
 
 void MessageChannel::Start() {
-  DCHECK_EQ(WAITING_TO_START, js_message_queue_state_);
-  DCHECK_EQ(WAITING_TO_START, plugin_message_queue_state_);
-
-  ppapi::proxy::HostDispatcher* dispatcher =
-      ppapi::proxy::HostDispatcher::GetForInstance(instance_->pp_instance());
-  // The dispatcher is NULL for in-process.
-  if (dispatcher)
-    dispatcher->AddSyncMessageStatusObserver(this);
-
-  // We can't drain the JS message queue directly since we haven't finished
-  // initializing the PepperWebPluginImpl yet, so the plugin isn't available in
-  // the DOM.
-  DrainJSMessageQueueSoon();
-
-  plugin_message_queue_state_ = SEND_DIRECTLY;
-  DrainCompletedPluginMessages();
+  // We PostTask here instead of draining the message queue directly
+  // since we haven't finished initializing the PepperWebPluginImpl yet, so
+  // the plugin isn't available in the DOM.
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&MessageChannel::DrainEarlyMessageQueue,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void MessageChannel::SetPassthroughObject(v8::Handle<v8::Object> passthrough) {
   passthrough_object_.Reset(instance_->GetIsolate(), passthrough);
 }
 
 void MessageChannel::SetReadOnlyProperty(PP_Var key, PP_Var value) {
   StringVar* key_string = StringVar::FromPPVar(key);
   if (key_string) {
     internal_named_properties_[key_string->value()] = ScopedPPVar(value);
   } else {
     NOTREACHED();
   }
 }
 
 MessageChannel::MessageChannel(PepperPluginInstanceImpl* instance)
     : gin::NamedPropertyInterceptor(instance->GetIsolate(), this),
       instance_(instance),
-      js_message_queue_state_(WAITING_TO_START),
-      blocking_message_depth_(0),
-      plugin_message_queue_state_(WAITING_TO_START),
+      early_message_queue_state_(QUEUE_MESSAGES),
       weak_ptr_factory_(this) {
 }
 
 gin::ObjectTemplateBuilder MessageChannel::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return Wrappable<MessageChannel>::GetObjectTemplateBuilder(isolate)
       .AddNamedPropertyInterceptor();
 }
 
-void MessageChannel::BeginBlockOnSyncMessage() {
-  js_message_queue_state_ = QUEUE_MESSAGES;
-  ++blocking_message_depth_;
-}
-
-void MessageChannel::EndBlockOnSyncMessage() {
-  DCHECK_GT(blocking_message_depth_, 0);
-  --blocking_message_depth_;
-  if (!blocking_message_depth_)
-    DrainJSMessageQueueSoon();
-}
-
 v8::Local<v8::Value> MessageChannel::GetNamedProperty(
     v8::Isolate* isolate,
     const std::string& identifier) {
   if (!instance_)
     return v8::Local<v8::Value>();
 
   PepperTryCatchV8 try_catch(instance_, V8VarConverter::kDisallowObjectVars,
                              isolate);
   if (identifier == kPostMessage) {
     return gin::CreateFunctionTemplate(isolate,
@@ skipping 80 matching lines @@
     try_catch.ThrowException(
         "postMessageAndAwaitResponse requires one argument");
     return;
   }
 
   v8::Handle<v8::Value> message_data;
   if (!args->GetNext(&message_data)) {
     NOTREACHED();
   }
 
-  if (plugin_message_queue_state_ == WAITING_TO_START) {
+  if (early_message_queue_state_ == QUEUE_MESSAGES) {
     try_catch.ThrowException(
         "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
@@ skipping 92 matching lines @@
                                          const ScopedPPVar& result,
                                          bool success) {
   if (!instance_)
     return;
   result_holder->ConversionCompleted(result, success);
   DrainCompletedPluginMessages();
 }
 
 void MessageChannel::DrainCompletedPluginMessages() {
   DCHECK(instance_);
-  if (plugin_message_queue_state_ == WAITING_TO_START)
+  if (early_message_queue_state_ == QUEUE_MESSAGES)
     return;
 
   while (!plugin_message_queue_.empty() &&
          plugin_message_queue_.front().conversion_completed()) {
     const VarConversionResult& front = plugin_message_queue_.front();
     if (front.success()) {
       instance_->HandleMessage(front.var());
     } else {
       PpapiGlobals::Get()->LogWithSource(instance()->pp_instance(),
                                          PP_LOGLEVEL_ERROR,
                                          std::string(),
                                          kV8ToVarConversionError);
     }
     plugin_message_queue_.pop_front();
   }
 }
 
-void MessageChannel::DrainJSMessageQueue() {
+void MessageChannel::DrainEarlyMessageQueue() {
   if (!instance_)
     return;
-  if (js_message_queue_state_ == SEND_DIRECTLY)
-    return;
+  DCHECK(early_message_queue_state_ == QUEUE_MESSAGES);
 
   // Take a reference on the PluginInstance. This is because JavaScript code
   // may delete the plugin, which would destroy the PluginInstance and its
   // corresponding MessageChannel.
   scoped_refptr<PepperPluginInstanceImpl> instance_ref(instance_);
-  while (!js_message_queue_.empty()) {
-    PostMessageToJavaScriptImpl(js_message_queue_.front());
-    js_message_queue_.pop_front();
+  while (!early_message_queue_.empty()) {
+    PostMessageToJavaScriptImpl(early_message_queue_.front());
+    early_message_queue_.pop_front();
   }
-  js_message_queue_state_ = SEND_DIRECTLY;
-}
+  early_message_queue_state_ = SEND_DIRECTLY;
 
-void MessageChannel::DrainJSMessageQueueSoon() {
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&MessageChannel::DrainJSMessageQueue,
-                 weak_ptr_factory_.GetWeakPtr()));
-}
-
-void MessageChannel::UnregisterSyncMessageStatusObserver() {
-  if (!instance_)
-    return;
-  ppapi::proxy::HostDispatcher* dispatcher =
-      ppapi::proxy::HostDispatcher::GetForInstance(instance_->pp_instance());
-  // The dispatcher is NULL for in-process.
-  if (dispatcher)
-    dispatcher->RemoveSyncMessageStatusObserver(this);
+  DrainCompletedPluginMessages();
 }
 
 }  // namespace content