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 117 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);
+  SiteInstance* owner_site_instance =
+      GetEmbedderFrame()->render_view_host()->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 &&
+  if (attached() && rwhv && GetEmbedderFrame() &&

[wjmaclean, 2016/10/20 14:47:22]

nit: Instead of the repeated calls to GetEmbedderFrame() in this block, would it
be cleaner to do

RenderFrameHostImpl rfhi = GetEmbedderFrame();
RenderWidgetHostImpl* rwhi = rfhi->GetRenderWidgetHost();
return (attached() && rwhv && rwhi &&
        rwhv->OnMessageReceivedFromEmbedder(
          message, RenderWidgetHostImpl::From(rwhi)));

?

[EhsanK, 2016/10/20 21:41:18]

Acknowledged.

+      GetEmbedderFrame()->GetRenderWidgetHost() &&
       rwhv->OnMessageReceivedFromEmbedder(
-          message,
-          RenderWidgetHostImpl::From(
-              embedder_web_contents()->GetRenderViewHost()->GetWidget()))) {
+          message, RenderWidgetHostImpl::From(
+                       GetEmbedderFrame()->GetRenderWidgetHost()))) {
     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*>(GetEmbedderFrame()->GetView());
 
   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 35 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(linked_ptr<IPC::Message>(msg));
     return;
   }
-  owner_web_contents_->Send(msg);
+
+  GetEmbedderFrame()->GetRenderWidgetHost()->Send(msg);
 }
 
 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 221 matching lines @@
   return handled;
 #else
   return false;
 #endif
 }
 
 void BrowserPluginGuest::Attach(
     int browser_plugin_instance_id,
     WebContentsImpl* embedder_web_contents,
     const BrowserPluginHostMsg_Attach_Params& params) {
+  DCHECK_EQ(GetEmbedderFrame()->delegate(), embedder_web_contents);
   browser_plugin_instance_id_ = browser_plugin_instance_id;
   // The guest is owned by the embedder. Attach is queued up so we cannot
   // change embedders before attach completes. If the embedder goes away,
   // so does the guest and so we will never call WillAttachComplete because
   // we have a weak ptr.
   delegate_->WillAttach(embedder_web_contents, browser_plugin_instance_id,
                         params.is_full_page_plugin,
                         base::Bind(&BrowserPluginGuest::OnWillAttachComplete,
                                    weak_ptr_factory_.GetWeakPtr(),
                                    embedder_web_contents, params));
@@ skipping 275 matching lines @@
           range, character_bounds);
 }
 #endif
 
 void BrowserPluginGuest::SetContextMenuPosition(const gfx::Point& position) {
   if (delegate_)
     delegate_->SetContextMenuPosition(position);
 }
 
 }  // namespace content