Make <webview> use out-of-process iframe architecture.

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 <algorithm>
 
+#include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/pickle.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/browser_plugin/browser_plugin_embedder.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/frame_host/render_widget_host_view_guest.h"
 #include "content/browser/loader/resource_dispatcher_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/render_widget_host_view_base.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/web_contents/web_contents_view_guest.h"
 #include "content/common/browser_plugin/browser_plugin_constants.h"
 #include "content/common/browser_plugin/browser_plugin_messages.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/drag_messages.h"
 #include "content/common/frame_messages.h"
 #include "content/common/host_shared_bitmap_manager.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_plugin_guest_manager.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/guest_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents_observer.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/common/drop_data.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 #if defined(OS_MACOSX)
 #include "content/browser/browser_plugin/browser_plugin_popup_menu_helper_mac.h"
 #endif
 
 namespace content {
 
 class BrowserPluginGuest::EmbedderVisibilityObserver
@@ skipping 48 matching lines @@
       delegate_(delegate),
       weak_ptr_factory_(this) {
   DCHECK(web_contents);
   DCHECK(delegate);
   RecordAction(base::UserMetricsAction("BrowserPlugin.Guest.Create"));
   web_contents->SetBrowserPluginGuest(this);
   delegate->SetGuestHost(this);
 }
 
 int BrowserPluginGuest::GetGuestProxyRoutingID() {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess)) {
+    // We don't directly use the proxy to send postMessage in
+    // --site-per-process, since we use the contentWindow directly from
+    // the frame element instead.
+    return MSG_ROUTING_NONE;
+  }
+
   if (guest_proxy_routing_id_ != MSG_ROUTING_NONE)
     return guest_proxy_routing_id_;
 
   // Create a swapped out RenderView 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 swapped out RenderView 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
@@ skipping 139 matching lines @@
              focused_,
              blink::WebFocusTypeNone);
 
   guest_visible_ = params.visible;
   UpdateVisibility();
 
   is_full_page_plugin_ = params.is_full_page_plugin;
   guest_window_rect_ = params.view_rect;
 
   if (owner_web_contents_ != owner_web_contents) {
-    WebContentsViewGuest* new_view =
-        static_cast<WebContentsViewGuest*>(GetWebContents()->GetView());
-    if (owner_web_contents_)
+    WebContentsViewGuest* new_view = nullptr;
+    if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kSitePerProcess)) {
+      new_view =
+          static_cast<WebContentsViewGuest*>(GetWebContents()->GetView());
+    }
+
+    if (owner_web_contents_ && new_view)
       new_view->OnGuestDetached(owner_web_contents_->GetView());
 
     // Once a BrowserPluginGuest has an embedder WebContents, it's considered to
     // be attached.
     owner_web_contents_ = owner_web_contents;
-    new_view->OnGuestAttached(owner_web_contents_->GetView());
+    if (new_view)
+      new_view->OnGuestAttached(owner_web_contents_->GetView());
   }
 
   RendererPreferences* renderer_prefs =
       GetWebContents()->GetMutableRendererPrefs();
   std::string guest_user_agent_override = renderer_prefs->user_agent_override;
   // Copy renderer preferences (and nothing else) from the embedder's
   // WebContents to the guest.
   //
   // For GTK and Aura this is necessary to get proper renderer configuration
   // values for caret blinking interval, colors related to selection and
@@ skipping 355 matching lines @@
   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));
 }
 
 void BrowserPluginGuest::OnWillAttachComplete(
     WebContentsImpl* embedder_web_contents,
     const BrowserPluginHostMsg_Attach_Params& params) {
+  bool use_site_per_process = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kSitePerProcess);
   // If a RenderView has already been created for this new window, then we need
   // to initialize the browser-side state now so that the RenderFrameHostManager
   // does not create a new RenderView on navigation.
-  if (has_render_view_) {
+  if (!use_site_per_process && has_render_view_) {
     // This will trigger a callback to RenderViewReady after a round-trip IPC.
     static_cast<RenderViewHostImpl*>(
         GetWebContents()->GetRenderViewHost())->Init();
     WebContentsViewGuest* web_contents_view =
         static_cast<WebContentsViewGuest*>(GetWebContents()->GetView());
     if (!web_contents()->GetRenderViewHost()->GetView()) {
       web_contents_view->CreateViewForWidget(
           web_contents()->GetRenderViewHost(), true);
     }
   }
 
   InitInternal(params, embedder_web_contents);
 
   attached_ = true;
   SendQueuedMessages();
 
   delegate_->DidAttach(GetGuestProxyRoutingID());
 
-  has_render_view_ = true;
+  if (!use_site_per_process) {
+    has_render_view_ = true;
 
-  // Enable input method for guest if it's enabled for the embedder.
-  if (static_cast<RenderViewHostImpl*>(
-      owner_web_contents_->GetRenderViewHost())->input_method_active()) {
-    RenderViewHostImpl* guest_rvh = static_cast<RenderViewHostImpl*>(
-        GetWebContents()->GetRenderViewHost());
-    guest_rvh->SetInputMethodActive(true);
+    // Enable input method for guest if it's enabled for the embedder.
+    if (static_cast<RenderViewHostImpl*>(
+            owner_web_contents_->GetRenderViewHost())->input_method_active()) {
+      RenderViewHostImpl* guest_rvh = static_cast<RenderViewHostImpl*>(
+          GetWebContents()->GetRenderViewHost());
+      guest_rvh->SetInputMethodActive(true);
+    }
   }
 
   RecordAction(base::UserMetricsAction("BrowserPlugin.Guest.Attached"));
 }
 
 void BrowserPluginGuest::OnCompositorFrameSwappedACK(
     int browser_plugin_instance_id,
     const FrameHostMsg_CompositorFrameSwappedACK_Params& params) {
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(params.producing_route_id,
                                                    params.output_surface_id,
@@ skipping 233 matching lines @@
 void BrowserPluginGuest::OnImeCompositionRangeChanged(
       const gfx::Range& range,
       const std::vector<gfx::Rect>& character_bounds) {
   static_cast<RenderWidgetHostViewBase*>(
       web_contents()->GetRenderWidgetHostView())->ImeCompositionRangeChanged(
           range, character_bounds);
 }
 #endif
 
 }  // namespace content