Browser Plugin: New Implementation (Browser Side)

content/browser/web_contents/web_contents_impl.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/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
+#include "content/browser/browser_plugin/browser_plugin_embedder.h"
+#include "content/browser/browser_plugin/browser_plugin_guest.h"
 #include "content/browser/browser_plugin/old/old_browser_plugin_host.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/debugger/devtools_manager_impl.h"
 #include "content/browser/dom_storage/dom_storage_context_impl.h"
 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/download/mhtml_generation_manager.h"
 #include "content/browser/download/save_package.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/host_zoom_map_impl.h"
 #include "content/browser/intents/web_intents_dispatcher_impl.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/web_contents/interstitial_page_impl.h"
 #include "content/browser/web_contents/navigation_entry_impl.h"
 #include "content/browser/webui/web_ui_impl.h"
+#include "content/common/browser_plugin_messages.h"
 #include "content/common/intents_messages.h"
 #include "content/common/ssl_status_serialization.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_view_host_delegate_view.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/color_chooser.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/devtools_agent_host_registry.h"
 #include "content/public/browser/download_manager.h"
@@ skipping 260 matching lines @@
        ++it) {
     new_contents->GetController().SetSessionStorageNamespace(it->first,
                                                              it->second);
   }
 
   new_contents->Init(browser_context, site_instance, routing_id,
                      static_cast<const WebContentsImpl*>(base_web_contents));
   return new_contents;
 }
 
+WebContents* WebContents::CreateGuest(BrowserContext* browser_context,
+                                      const std::string& host_url,
+                                      int guest_instance_id) {
+  // The SiteInstance of a given guest is based on the fact that it's a guest
+  // in addition to which platform application the guest belongs to, rather
+  // than the URL that the guest is being navigated to.
+  GURL guest_site(
+      base::StringPrintf("%s://%s", chrome::kGuestScheme, host_url.c_str()));
+  SiteInstance* guest_site_instance =
+      SiteInstance::CreateForURL(browser_context, guest_site);
+  WebContents* new_contents = WebContents::Create(
+      browser_context,
+      guest_site_instance,
+      MSG_ROUTING_NONE,
+      NULL);  // base WebContents
+  WebContentsImpl* new_contents_impl =
+      static_cast<WebContentsImpl*>(new_contents);
+
+  // This makes |new_contents| to have a guest role.
+  // For more info, see comment above class BrowserPluginGuest.
+  new_contents_impl->browser_plugin_guest_.reset(
+      content::BrowserPluginGuest::Create(
+          guest_instance_id,
+          new_contents_impl,
+          new_contents_impl->GetRenderViewHost()));
+  return new_contents;
+}
+
 WebContents* WebContents::FromRenderViewHost(const RenderViewHost* rvh) {
   return rvh->GetDelegate()->GetAsWebContents();
 }
 
 }
 
 // WebContentsImpl -------------------------------------------------------------
 
 WebContentsImpl::WebContentsImpl(
     content::BrowserContext* browser_context,
@@ skipping 357 matching lines @@
     IPC_MESSAGE_HANDLER(ViewHostMsg_CrashedPlugin, OnCrashedPlugin)
     IPC_MESSAGE_HANDLER(ViewHostMsg_AppCacheAccessed, OnAppCacheAccessed)
     IPC_MESSAGE_HANDLER(ViewHostMsg_OpenColorChooser, OnOpenColorChooser)
     IPC_MESSAGE_HANDLER(ViewHostMsg_EndColorChooser, OnEndColorChooser)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SetSelectedColorInColorChooser,
                         OnSetSelectedColorInColorChooser)
     IPC_MESSAGE_HANDLER(ViewHostMsg_PepperPluginHung, OnPepperPluginHung)
     IPC_MESSAGE_HANDLER(ViewHostMsg_WebUISend, OnWebUISend)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RequestPpapiBrokerPermission,
                         OnRequestPpapiBrokerPermission)
+    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_NavigateGuest,
+                        OnBrowserPluginNavigateGuest)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   message_source_ = NULL;
 
   if (!message_is_ok) {
     content::RecordAction(UserMetricsAction("BadMessageTerminate_RVD"));
     GetRenderProcessHost()->ReceivedBadMessage();
   }
 
   return handled;
@@ skipping 1591 matching lines @@
 }
 
 void WebContentsImpl::OnPpapiBrokerPermissionResult(int request_id,
                                                     bool result) {
   RenderViewHostImpl* rvh = GetRenderViewHostImpl();
   rvh->Send(new ViewMsg_PpapiBrokerPermissionResult(rvh->GetRoutingID(),
                                                     request_id,
                                                     result));
 }
 
+void WebContentsImpl::OnBrowserPluginNavigateGuest(int instance_id,
+                                                   int64 frame_id,
+                                                   const std::string& src,
+                                                   const gfx::Size& size) {
+  // This is the first 'navigate' to a browser plugin, before WebContents has/is
+  // an 'Embedder'; subsequent navigate messages for this WebContents will
+  // be handled by the BrowserPluginEmbedderHelper of the embedder itself (this
+  // also means any message from browser plugin renderer prior to NavigateGuest
+  // which is not NavigateGuest will be ignored). Therefore
+  // |browser_plugin_embedder_| should not be set.
+  // For more info, see comment above classes BrowserPluginEmbedder and
+  // BrowserPluginGuest.
+  CHECK(!browser_plugin_embedder_.get());
+
+  browser_plugin_embedder_.reset(
+      content::BrowserPluginEmbedder::Create(this, GetRenderViewHost()));
+  browser_plugin_embedder_->NavigateGuest(GetRenderViewHost(),
+                                          instance_id,
+                                          frame_id,
+                                          src,
+                                          size);
+}
+
 // Notifies the RenderWidgetHost instance about the fact that the page is
 // loading, or done loading and calls the base implementation.
 void WebContentsImpl::SetIsLoading(bool is_loading,
                                    LoadNotificationDetails* details) {
   if (is_loading == is_loading_)
     return;
 
   if (!is_loading) {
     load_state_ = net::LoadStateWithParam(net::LOAD_STATE_IDLE, string16());
     load_state_host_.clear();
@@ skipping 136 matching lines @@
 
 void WebContentsImpl::NotifySwapped() {
   // After sending out a swap notification, we need to send a disconnect
   // notification so that clients that pick up a pointer to |this| can NULL the
   // pointer.  See Bug 1230284.
   notify_disconnection_ = true;
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_WEB_CONTENTS_SWAPPED,
       content::Source<WebContents>(this),
       content::NotificationService::NoDetails());
+
+  // Ensure that the associated embedder gets cleared after a RenderViewHost
+  // gets swapped, so we don't reuse the same embedder next time a
+  // RenderViewHost is attached to this WebContents (for security concerns).
+  RemoveSwappedOutBrowserPluginEmbedder();
 }
 
 void WebContentsImpl::NotifyConnected() {
   notify_disconnection_ = true;
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
       content::Source<WebContents>(this),
       content::NotificationService::NoDetails());
 }
 
@@ skipping 25 matching lines @@
 WebContents* WebContentsImpl::GetAsWebContents() {
   return this;
 }
 
 gfx::Rect WebContentsImpl::GetRootWindowResizerRect() const {
   if (delegate_)
     return delegate_->GetRootWindowResizerRect();
   return gfx::Rect();
 }
 
+void WebContentsImpl::RemoveSwappedOutBrowserPluginEmbedder() {
+  if (browser_plugin_embedder_.get())
+    browser_plugin_embedder_.reset();
+}
+
 void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
   // Don't send notifications if we are just creating a swapped-out RVH for
   // the opener chain.  These won't be used for view-source or WebUI, so it's
   // ok to return early.
   if (static_cast<RenderViewHostImpl*>(render_view_host)->is_swapped_out())
     return;
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
       content::Source<WebContents>(this),
@@ skipping 768 matching lines @@
       old_browser_plugin_host()->embedder_render_process_host();
   *embedder_container_id = old_browser_plugin_host()->instance_id();
   int embedder_process_id =
       embedder_render_process_host ? embedder_render_process_host->GetID() : -1;
   if (embedder_process_id != -1) {
     *embedder_channel_name =
         StringPrintf("%d.r%d", render_view_host->GetProcess()->GetID(),
                      embedder_process_id);
   }
 }
+
+content::BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() {
+  return browser_plugin_guest_.get();
+}
+
+content::BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() {
+  return browser_plugin_embedder_.get();
+}