Browser Plugin: browser process side changes

content/browser/browser_plugin/browser_plugin_host.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_host.h"
+
+#include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/browser/web_contents/web_contents_impl.h"
+#include "content/common/browser_plugin_messages.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_source.h"
+#include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_widget_host_view.h"
+#include "content/public/browser/site_instance.h"
+#include "content/public/browser/web_contents_view.h"
+#include "ppapi/proxy/ppapi_messages.h"
+
+namespace content {
+
+BrowserPluginHost::BrowserPluginHost(
+    WebContentsImpl* web_contents)
+    : WebContentsObserver(web_contents),
+      embedder_(NULL),
+      instance_id_(0),
+      pending_render_view_host_(NULL) {
+  registrar_.Add(this,
+                 NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
+                 Source<RenderViewHost>(
+                    web_contents->GetRenderViewHost()));

[Charlie Reis, 2012/05/17 21:24:05]

This needs another space of indent.

[Fady Samuel, 2012/05/18 17:37:52]

Done.

+}
+
+BrowserPluginHost::~BrowserPluginHost() {
+}
+
+BrowserPluginHost* BrowserPluginHost::GetGuestByContainerID(int container_id) {
+  ContainerInstanceMap::const_iterator it =
+      guests_by_container_id_.find(container_id);
+  if (it != guests_by_container_id_.end())
+    return it->second;
+  return NULL;
+}
+
+void BrowserPluginHost::RegisterContainerInstance(
+    int container_id,
+    BrowserPluginHost* observer) {
+  DCHECK(guests_by_container_id_.find(container_id) ==
+      guests_by_container_id_.end());
+  guests_by_container_id_[container_id] = observer;
+}
+
+void BrowserPluginHost::OnCrossProcessNavigation(RenderViewHost* dest_rvh) {
+  if (web_contents()->GetRenderViewHost() != dest_rvh) {
+    pending_render_view_host_ = dest_rvh;
+  }
+}
+
+
+bool BrowserPluginHost::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(BrowserPluginHost, message)
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_ConnectToChannel,
+                        OnConnectToChannel)
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_NavigateFromEmbedder,
+                        OnNavigateFromEmbedder)
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_NavigateFromGuest,
+                        OnNavigateFromGuest)
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_MapInstance,
+                        OnMapInstance)
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_ResizeGuest, OnResizeGuest)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void BrowserPluginHost::OnResizeGuest(int width, int height) {
+  // Tell the RenderWidgetHostView to adjust its size.
+  web_contents()->GetRenderViewHost()->GetView()->SetSize(

[Charlie Reis, 2012/05/17 21:24:05]

This isn't safe.  We need to know who sent us the message so that it gets
delivered to the right RenderViewHost.  For example, the active RVH could have
changed since the message was sent.

Could RenderViewHostImpl itself receive and process this message?

[Fady Samuel, 2012/05/18 17:37:52]

Done.

+      gfx::Size(width, height));
+}
+
+void BrowserPluginHost::OnNavigateFromEmbedder(
+    int instance_id,
+    long long frame_id,
+    const std::string& src,
+    const gfx::Size& size) {
+  BrowserPluginHost* guest_observer = GetGuestByContainerID(instance_id);
+  WebContentsImpl* guest_web_contents =
+      guest_observer ?
+          static_cast<WebContentsImpl*>(guest_observer->web_contents()): NULL;
+  if (!guest_observer) {
+    GURL url(src);
+    guest_web_contents =
+        static_cast<WebContentsImpl*>(
+            WebContents::Create(
+                web_contents()->GetBrowserContext(),
+                web_contents()->GetSiteInstance(),

[Charlie Reis, 2012/05/17 21:24:05]

Also not safe.  The SiteInstance could have just changed.  We need to know more
about who is sending the message.

[Fady Samuel, 2012/05/18 17:37:52]

Done.

+                MSG_ROUTING_NONE,
+                NULL, // base WebContents
+                NULL  // session storage namespace
+            ));
+    guest_observer =
+        guest_web_contents->browser_plugin_host();
+    guest_observer->set_embedder(static_cast<WebContentsImpl*>(web_contents()));
+    guest_observer->set_instance_id(instance_id);
+    guest_observer->set_url(url);
+    guest_observer->set_initial_size(size);
+    RegisterContainerInstance(instance_id, guest_observer);
+    AddGuest(guest_web_contents, frame_id);
+  }
+
+  // TODO(fsamuel): Set the WebContentsDelegate here.
+  guest_observer->web_contents()->GetController().LoadURL(

[Charlie Reis, 2012/05/17 21:24:05]

I'm skeptical about this and the one below.  Where are we getting a string from
that is causing us to navigate?  It's not consistent with the other ways that we
initiate navigations.

[Fady Samuel, 2012/05/18 17:37:52]

The string is coming from the browser plugin's src attribute on the embedder
page.

[Charlie Reis, 2012/05/18 20:35:24]

Ok, I think it'll do for now.

+      guest_observer->url(),
+      Referrer(),
+      PAGE_TRANSITION_HOME_PAGE,

[Charlie Reis, 2012/05/17 21:24:05]

I don't think Home Page is the right transition here.

[Fady Samuel, 2012/05/18 17:37:52]

changed to PAGE_TRANSITION_AUTO_SUBFRAME as per offline discussion.

+      std::string());
+}
+
+void BrowserPluginHost::OnNavigateFromGuest(
+    PP_Instance instance,
+    const std::string& src) {
+  DCHECK(embedder());
+  GURL url(src);
+  web_contents()->GetController().LoadURL(
+      url,
+      Referrer(),
+      PAGE_TRANSITION_HOME_PAGE,
+      std::string());
+}
+
+void BrowserPluginHost::OnMapInstance(int container_id, PP_Instance instance) {
+  BrowserPluginHost* guest_observer = GetGuestByContainerID(container_id);
+  WebContentsImpl* guest_web_contents =
+    static_cast<WebContentsImpl*>(guest_observer->web_contents());
+  // TODO(fsamuel): This should be correct unless we decide at some point to
+  // discard the pending_render_view_host for whatever reason. I need to
+  // investigate possible corner cases.
+  RenderViewHost* rvh = guest_observer->pending_render_view_host() ?
+      guest_observer->pending_render_view_host() :
+          guest_web_contents->GetRenderViewHost();

[Charlie Reis, 2012/05/17 21:24:05]

No, this isn't safe for the reasons stated above.  We can't assume that the
message came from the pending RVH just because one exists.  We need to know
which RVH it came from.

I think it would be safer to process these messages in RenderViewHostImpl, and
if we need to call a method here to handle them, then pass in "this".  For
examples, see OnMsgNavigate, OnMsgUpdateState, OnMsgUpdateTitle, etc.

[Fady Samuel, 2012/05/18 17:37:52]

This is tricky. OnMapInstance is coming from the embedder RenderView.
guest_web_contents is a different RenderView in a different process that's in
the process of navigating. I don't think this can be simply moved to
RenderViewHostImpl. 

I added a TODO explaining what I think is the correct solution but it will
probably require a change to Pepper's PluginInstance so that the embedder can
send a message to the guest via the pepper channel to "CompleteNavigation" which
basically means associate the PP_Instance with the RenderViewImpl, request input
events and initialize the graphics context.

+
+  // TODO(fsamuel): This is wrong. The current size of the plugin container
+  // might not be equal to initial size on subsequent navigations.
+  // BrowserPluginHost_MapInstance should also report the current size of
+  // the container to the browser process.
+  guest_web_contents->GetView()->SizeContents(guest_observer->initial_size());
+
+  rvh->Send(new BrowserPluginMsg_CompleteNavigation(
+                rvh->GetRoutingID(),
+                instance));
+}
+
+void BrowserPluginHost::OnConnectToChannel(
+    const IPC::ChannelHandle& channel_handle) {
+  DCHECK(embedder());
+  // Tell the BrowserPlugin in the embedder that we're done and that it can
+  // begin using the guest renderer.
+  embedder()->GetRenderProcessHost()->Send(
+      new BrowserPluginMsg_LoadGuest(
+          instance_id(),
+          //embedder_web_contents->GetRenderProcessHost()->GetID(),
+          web_contents()->GetPendingSiteInstance()->GetProcess()->
+              GetID(),
+          channel_handle));
+}
+
+void BrowserPluginHost::AddGuest(WebContentsImpl* guest, int64 frame_id) {
+  guests_[guest] = frame_id;
+}
+
+void BrowserPluginHost::RemoveGuest(WebContentsImpl* guest) {
+  guests_.erase(guest);
+}
+
+void BrowserPluginHost::DestroyGuests() {
+  for (GuestMap::const_iterator it = guests_.begin();
+       it != guests_.end(); ++it) {
+    WebContentsImpl* web_contents = it->first;
+    delete web_contents;
+  }
+  guests_.clear();
+  guests_by_container_id_.clear();
+}
+
+void BrowserPluginHost::DidCommitProvisionalLoadForFrame(
+    int64 frame_id,
+    bool is_main_frame,
+    const GURL& url,
+    PageTransition transition_type) {
+  typedef std::set<WebContentsImpl*> GuestSet;
+  GuestSet guests_to_delete;
+  for (GuestMap::const_iterator it = guests_.begin();
+       it != guests_.end(); ++it) {
+    WebContentsImpl* web_contents = it->first;
+    if (it->second == frame_id) {
+      guests_to_delete.insert(web_contents);
+    }
+  }
+  for (GuestSet::const_iterator it = guests_to_delete.begin();
+       it != guests_to_delete.end(); ++it) {
+    delete *it;
+    guests_.erase(*it);
+  }
+}
+
+void BrowserPluginHost::RenderViewDeleted(RenderViewHost* render_view_host) {
+  // TODO(fsamuel): For some reason ToT hangs when killing a guest, this wasn't
+  // the case earlier. Presumably, when a guest is killed/crashes, one of
+  // RenderViewDeleted, RenderViewGone or WebContentsDestroyed will get called.
+  // At that point, we should remove reference to this BrowserPluginHost
+  // from its embedder, in addition to destroying its guests, to ensure
+  // that we do not attempt a double delete.
+  DestroyGuests();
+}
+
+void BrowserPluginHost::RenderViewGone(base::TerminationStatus status) {
+  DestroyGuests();
+}
+
+void BrowserPluginHost::WebContentsDestroyed(WebContents* web_contents) {
+  DestroyGuests();
+}
+
+void BrowserPluginHost::Observe(
+    int type,
+    const NotificationSource& source,
+    const NotificationDetails& details) {
+  DCHECK(type == NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED);
+  bool visible = *Details<bool>(details).ptr();
+
+  // If the embedder is hidden we need to hide the guests as well.
+  for (GuestMap::const_iterator it = guests_.begin();
+       it != guests_.end(); ++it) {
+    WebContentsImpl* web_contents = it->first;
+    if (visible)
+      web_contents->ShowContents();
+    else
+      web_contents->HideContents();
+  }
+}
+
+}  // namespace content