Queue postMessage messages destined for a MimeHandlerView guest

extensions/renderer/guest_view/mime_handler_view/mime_handler_view_container.cc

 // Copyright 2014 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 "extensions/renderer/guest_view/mime_handler_view/mime_handler_view_container.h"
 
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/guest_view/guest_view_constants.h"
@@ skipping 63 matching lines @@
 }  // namespace
 
 MimeHandlerViewContainer::MimeHandlerViewContainer(
     content::RenderFrame* render_frame,
     const std::string& mime_type,
     const GURL& original_url)
     : GuestViewContainer(render_frame),
       mime_type_(mime_type),
       original_url_(original_url),
       guest_proxy_routing_id_(-1),
+      guest_loaded_(false),
       weak_factory_(this) {
   DCHECK(!mime_type_.empty());
   is_embedded_ = !render_frame->GetWebFrame()->document().isPluginDocument();
 }
 
 MimeHandlerViewContainer::~MimeHandlerViewContainer() {
   if (loader_)
     loader_->cancel();
 }
 
@@ skipping 19 matching lines @@
 void MimeHandlerViewContainer::DidReceiveData(const char* data,
                                               int data_length) {
   html_string_ += std::string(data, data_length);
 }
 
 bool MimeHandlerViewContainer::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(MimeHandlerViewContainer, message)
     IPC_MESSAGE_HANDLER(ExtensionMsg_CreateMimeHandlerViewGuestACK,
                         OnCreateMimeHandlerViewGuestACK)
+    IPC_MESSAGE_HANDLER(ExtensionMsg_MimeHandlerViewGuestOnLoadCompleted,
+                        OnMimeHandlerViewGuestOnLoadCompleted)
     IPC_MESSAGE_HANDLER(ExtensionMsg_GuestAttached, OnGuestAttached)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 v8::Local<v8::Object> MimeHandlerViewContainer::V8ScriptableObject(
     v8::Isolate* isolate) {
   if (scriptable_object_.IsEmpty()) {
     v8::Local<v8::Object> object =
@@ skipping 13 matching lines @@
 void MimeHandlerViewContainer::didFinishLoading(
     blink::WebURLLoader* /* unused */,
     double /* unused */,
     int64_t /* unused */) {
   DCHECK(is_embedded_);
   CreateMimeHandlerViewGuest();
 }
 
 void MimeHandlerViewContainer::PostMessage(v8::Isolate* isolate,
                                            v8::Handle<v8::Value> message) {
+  if (!guest_loaded_) {
+    linked_ptr<ScopedPersistent<v8::Value>> scoped_persistent(
+        new ScopedPersistent<v8::Value>(isolate, message));
+    pending_messages_.push_back(scoped_persistent);
+    return;
+  }
+
   content::RenderView* guest_proxy_render_view =
       content::RenderView::FromRoutingID(guest_proxy_routing_id_);
   if (!guest_proxy_render_view)
     return;
   blink::WebFrame* guest_proxy_frame =
       guest_proxy_render_view->GetWebView()->mainFrame();
   if (!guest_proxy_frame)
     return;
 
   v8::Local<v8::Object> guest_proxy_window =
@@ skipping 13 matching lines @@
       guest_proxy_window, arraysize(args), args);
 }
 
 void MimeHandlerViewContainer::OnCreateMimeHandlerViewGuestACK(
     int element_instance_id) {
   DCHECK_NE(this->element_instance_id(), guestview::kInstanceIDNone);
   DCHECK_EQ(this->element_instance_id(), element_instance_id);
   render_frame()->AttachGuest(element_instance_id);
 }
 
+void MimeHandlerViewContainer::OnMimeHandlerViewGuestOnLoadCompleted(
+    int /* unused */) {
+  guest_loaded_ = true;
+  if (pending_messages_.empty())
+    return;
+
+  // Now that the guest has loaded, flush any unsent messages.
+  content::RenderView* render_view =

[Sam McNally, 2014/12/19 03:11:46]

Use render_frame()->GetWebFrame().

[raymes, 2014/12/19 03:21:07]

Done.

+      content::RenderView::FromRoutingID(render_view_routing_id());
+  if (!render_view)
+    return;
+  blink::WebFrame* frame = render_view->GetWebView()->mainFrame();
+  if (!frame)
+    return;
+
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::HandleScope handle_scope(isolate);
+  v8::Context::Scope context_scope(frame->mainWorldScriptContext());
+  for (size_t i = 0; i < pending_messages_.size(); ++i)
+    PostMessage(isolate, pending_messages_[i]->NewHandle(isolate));
+
+  pending_messages_.clear();
+}
+
 void MimeHandlerViewContainer::OnGuestAttached(int /* unused */,
                                                int guest_proxy_routing_id) {
   // Save the RenderView routing ID of the guest here so it can be used to route
   // PostMessage calls.
   guest_proxy_routing_id_ = guest_proxy_routing_id;
 }
 
 void MimeHandlerViewContainer::CreateMimeHandlerViewGuest() {
   // The loader has completed loading |html_string_| so we can dispose it.
   loader_.reset();
 
   // Parse the stream URL to ensure it's valid.
   GURL stream_url(html_string_);
 
   DCHECK_NE(element_instance_id(), guestview::kInstanceIDNone);
   render_frame()->Send(new ExtensionHostMsg_CreateMimeHandlerViewGuest(
       render_frame()->GetRoutingID(), stream_url.spec(), original_url_.spec(),
       mime_type_, element_instance_id()));
 }
 
 }  // namespace extensions