Allow MimeHandlerViewGuest be embedded inside OOPIFs

content/browser/browser_plugin/browser_plugin_guest.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/browser/browser_plugin/browser_plugin_guest.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 118 matching lines @@
   // Create a RenderFrameProxyHost for the guest in the embedder renderer
   // process, so that the embedder can access the guest's window object.
   // On reattachment, we can reuse the same RenderFrameProxyHost because
   // the embedder process will always be the same even if the embedder
   // WebContents changes.
   //
   // TODO(fsamuel): Make sure this works for transferring guests across
   // owners in different processes. We probably need to clear the
   // |guest_proxy_routing_id_| and perform any necessary cleanup on Detach
   // to enable this.
-  SiteInstance* owner_site_instance = owner_web_contents_->GetSiteInstance();
-  int proxy_routing_id =
-      GetWebContents()->GetFrameTree()->root()->render_manager()->
-          CreateRenderFrameProxy(owner_site_instance);
+  //
+  // TODO(ekaramad): We create the proxy for post messaging to the guest. The

[Charlie Reis, 2016/11/02 20:47:06]

nit: Say "to the guest below."  (I was having a hard time understanding how the
rest of this comment related to the code below, until I figured out that the
code below is creating the proxy that the embedder will use to talk to the
guest, rather than the "reverse" one the comment is describing.)

[EhsanK, 2016/11/08 23:10:16]

Sorry but I am a bit confused with the term "to the guest below" since |this| is
the guest as far as I understand.

I have reworded the comments; also changed the lines 129-133. Now in 129-135 we
explain the process of creating RFPH to post message to guest and how the
reverse one is created.

The TODO now only mentions that the reverse RFPH is not created when the
embedder is OOPIF.

+  // reverse route proxies are created when we first post message. However, if
+  // the guest is inisde an <iframe> (e.g., <embed>-ed PDF) then the reverse

[Charlie Reis, 2016/11/02 20:47:06]

nit: inside

[EhsanK, 2016/11/08 23:10:16]

Done.

+  // proxy is not created and the posted messages's source attribute is null.
+  // We should either create a RenderFrameProxyHost for the reverse path or
+  // implement MimeHandlerViewGuest's using OOPIF (https://crbug.com/659750).
+  SiteInstance* owner_site_instance = GetEmbedderFrame()->GetSiteInstance();
+  int proxy_routing_id = GetWebContents()
+                             ->GetFrameTree()
+                             ->root()
+                             ->render_manager()
+                             ->CreateRenderFrameProxy(owner_site_instance);
   guest_proxy_routing_id_ = RenderFrameProxyHost::FromID(
       owner_site_instance->GetProcess()->GetID(), proxy_routing_id)
           ->GetRenderViewHost()->GetRoutingID();
 
   return guest_proxy_routing_id_;
 }
 
 int BrowserPluginGuest::LoadURLWithParams(
     const NavigationController::LoadURLParams& load_params) {
   GetWebContents()->GetController().LoadURLWithParams(load_params);
@@ skipping 10 matching lines @@
 void BrowserPluginGuest::SizeContents(const gfx::Size& new_size) {
   GetWebContents()->GetView()->SizeContents(new_size);
 }
 
 void BrowserPluginGuest::WillDestroy() {
   is_in_destruction_ = true;
   owner_web_contents_ = nullptr;
   attached_ = false;
 }
 
+RenderFrameHostImpl* BrowserPluginGuest::GetEmbedderFrame() const {
+  return static_cast<RenderFrameHostImpl*>(delegate_->GetEmbedderFrame());
+}
+
 void BrowserPluginGuest::Init() {
   if (initialized_)
     return;
   initialized_ = true;
 
   // TODO(fsamuel): Initiailization prior to attachment should be behind a
   // command line flag once we introduce experimental guest types that rely on
   // this functionality.
   if (!delegate_->CanRunInDetachedState())
     return;
@@ skipping 52 matching lines @@
       static_cast<WebContentsImpl*>(delegate_->CreateNewGuestWindow(params));
   DCHECK(new_contents);
   return new_contents;
 }
 
 bool BrowserPluginGuest::OnMessageReceivedFromEmbedder(
     const IPC::Message& message) {
   RenderWidgetHostViewGuest* rwhv = static_cast<RenderWidgetHostViewGuest*>(
       web_contents()->GetRenderWidgetHostView());
   // Until the guest is attached, it should not be handling input events.
-  if (attached() && rwhv &&
-      rwhv->OnMessageReceivedFromEmbedder(
-          message,
-          RenderWidgetHostImpl::From(
-              embedder_web_contents()->GetRenderViewHost()->GetWidget()))) {
+  RenderFrameHostImpl* rfhi = GetEmbedderFrame();
+  RenderWidgetHostImpl* rwhi = rfhi ? rfhi->GetRenderWidgetHost() : nullptr;

[Charlie Reis, 2016/11/02 20:47:06]

nit: Move these two lines above the "// Until" comment.

[EhsanK, 2016/11/08 23:10:16]

Done.

+  if (attached() && rwhv && rwhi &&
+      rwhv->OnMessageReceivedFromEmbedder(message, rwhi)) {
     return true;
   }
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BrowserPluginGuest, message)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_Detach, OnDetach)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_DragStatusUpdate,
                         OnDragStatusUpdate)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_ExecuteEditCommand,
                         OnExecuteEditCommand)
@@ skipping 107 matching lines @@
 }
 
 // static
 bool BrowserPluginGuest::IsGuest(RenderViewHostImpl* render_view_host) {
   return render_view_host && IsGuest(
       static_cast<WebContentsImpl*>(WebContents::FromRenderViewHost(
           render_view_host)));
 }
 
 RenderWidgetHostView* BrowserPluginGuest::GetOwnerRenderWidgetHostView() {
-  if (!owner_web_contents_)
-    return nullptr;
-  return owner_web_contents_->GetRenderWidgetHostView();
+  if (GetEmbedderFrame())
+    return GetEmbedderFrame()->GetView();
+
+  return nullptr;
 }
 
 void BrowserPluginGuest::UpdateVisibility() {
   OnSetVisibility(browser_plugin_instance_id(), visible());
 }
 
 BrowserPluginGuestManager*
 BrowserPluginGuest::GetBrowserPluginGuestManager() const {
   return GetWebContents()->GetBrowserContext()->GetGuestManager();
 }
@@ skipping 51 matching lines @@
 bool BrowserPluginGuest::HandleStopFindingForEmbedder(StopFindAction action) {
   return delegate_->HandleStopFindingForEmbedder(action);
 }
 
 void BrowserPluginGuest::ResendEventToEmbedder(
     const blink::WebInputEvent& event) {
   if (!attached() || !owner_web_contents_)
     return;
 
   DCHECK(browser_plugin_instance_id_);
-  RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
-      embedder_web_contents()->GetMainFrame()->GetView());
+  RenderWidgetHostViewBase* view =
+      static_cast<RenderWidgetHostViewBase*>(GetOwnerRenderWidgetHostView());
 
   gfx::Vector2d offset_from_embedder = guest_window_rect_.OffsetFromOrigin();
   if (event.type == blink::WebInputEvent::GestureScrollUpdate) {
     blink::WebGestureEvent resent_gesture_event;
     memcpy(&resent_gesture_event, &event, sizeof(blink::WebGestureEvent));
     resent_gesture_event.x += offset_from_embedder.x();
     resent_gesture_event.y += offset_from_embedder.y();
     // Mark the resend source with the browser plugin's instance id, so the
     // correct browser_plugin will know to ignore the event.
     resent_gesture_event.resendingPluginId = browser_plugin_instance_id_;
@@ skipping 36 matching lines @@
   // in this case just queue any messages we receive.
   if (!attached() || !owner_web_contents_) {
     // Some pages such as data URLs, javascript URLs, and about:blank
     // do not load external resources and so they load prior to attachment.
     // As a result, we must save all these IPCs until attachment and then
     // forward them so that the embedder gets a chance to see and process
     // the load events.
     pending_messages_.push_back(std::move(msg));
     return;
   }
-  owner_web_contents_->Send(msg.release());
+
+  GetEmbedderFrame()->GetRenderWidgetHost()->Send(msg.release());

[Charlie Reis, 2016/11/02 20:47:06]

This change looks a little odd to me (sending via WebContents vs sending via
RenderWidgetHost), but I guess under the hood they're basically equivalent.  Ok.

[EhsanK, 2016/11/08 23:10:16]

To respect the exact implementation, we should send it to RenderWidgetHost
(since WebContents eventually does that under the hood).

However, we are handling these messages in BrowserPluginManager which is a
RenderThreadObserver. So, as I understand sending them to the embedder frame
directly also works. I wonder if we could alternatively send them to "any other"
IPC::Listener in the embedder process? (assuming that the browser side entity is
alive when RWH is).

 }
 
 void BrowserPluginGuest::DragSourceEndedAt(int client_x, int client_y,
     int screen_x, int screen_y, blink::WebDragOperation operation) {
   web_contents()->GetRenderViewHost()->DragSourceEndedAt(client_x, client_y,
       screen_x, screen_y, operation);
   seen_embedder_drag_source_ended_at_ = true;
   EndSystemDragIfApplicable();
 }
 
@@ skipping 515 matching lines @@
           range, character_bounds);
 }
 #endif
 
 void BrowserPluginGuest::SetContextMenuPosition(const gfx::Point& position) {
   if (delegate_)
     delegate_->SetContextMenuPosition(position);
 }
 
 }  // namespace content