PPAPI: Support sending browser-hosted resources synchronously

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 169 matching lines @@
 }
 
 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),
       var_converter_(instance->pp_instance(),
                      V8VarConverter::kDisallowObjectVars),
+      var_conversion_weak_ptr_factory_(this),
       weak_ptr_factory_(this) {
 }
 
 gin::ObjectTemplateBuilder MessageChannel::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return Wrappable<MessageChannel>::GetObjectTemplateBuilder(isolate)
       .AddNamedPropertyInterceptor();
 }
 
 void MessageChannel::BeginBlockOnSyncMessage() {
@@ skipping 106 matching lines @@
     NOTREACHED();
   }
 
   if (plugin_message_queue_state_ == WAITING_TO_START) {
     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
-  // 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()) {
-    try_catch.ThrowException(
-        "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 = try_catch.FromV8(message_data);
   if (try_catch.ThrowException())
     return;
+  if (!plugin_message_queue_.empty()) {
+    // 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 have to force all the conversions to
+    // happen synchronously so that we can preserve message order.
+
+    // CURRENT STRATEGY:
+    //  1) Always push async conversions to the browser. They'll be guaranteed
+    //     to arrive in order.
+    //  2) For blocking messages, after you've queued up the conversion, if
+    //     there's anything waiting in the queue, it's irrelevant whether it
+    //     is from that sync message or an earlier one. We want to block until
+    //     it's complete.
+
+    // TODO/FIXME Force the browser to convert all pending vars here
+    // Mark all messages in the queue completed.
+    // Now all our pending vars have completed synchronously, but the browser
+    // might already have sent us a response for one or more of them, so we
+    // make sure the conversion callbacks don't get invoked.
+    var_conversion_weak_ptr_factory_.InvalidateWeakPtrs();
+  }
 
   ScopedPPVar pp_result;
   bool was_handled = instance_->HandleBlockingMessage(param, &pp_result);
   if (!was_handled) {
     try_catch.ThrowException(
         "The plugin has not registered a handler for synchronous messages. "
         "See the documentation for PPB_Messaging::RegisterMessageHandler "
         "and PPP_MessageHandler.");
     return;
   }
@@ skipping 45 matching lines @@
   // Convert the v8 value in to an appropriate PP_Var like Dictionary,
   // Array, etc. (We explicitly don't want an "Object" PP_Var, which we don't
   // support for Messaging.)
   // TODO(raymes): Possibly change this to use TryCatch to do the conversion and
   // throw an exception if necessary.
   V8VarConverter::VarResult conversion_result =
       var_converter_.FromV8Value(
           v8_value,
           v8::Isolate::GetCurrent()->GetCurrentContext(),
           base::Bind(&MessageChannel::FromV8ValueComplete,
-                     weak_ptr_factory_.GetWeakPtr(),
+                     var_conversion_weak_ptr_factory_.GetWeakPtr(),
                      &plugin_message_queue_.back()));
   if (conversion_result.completed_synchronously) {
     plugin_message_queue_.back().ConversionCompleted(
         conversion_result.var,
         conversion_result.success);
   }
 }
 
 void MessageChannel::FromV8ValueComplete(VarConversionResult* result_holder,
                                          const ScopedPPVar& result,
@@ skipping 49 matching lines @@
 }
 
 void MessageChannel::UnregisterSyncMessageStatusObserver() {
   if (!unregister_observer_callback_.is_null()) {
     unregister_observer_callback_.Run();
     unregister_observer_callback_.Reset();
   }
 }
 
 }  // namespace content