Disable support for swapped out RenderFrame(Host) on desktop.

content/renderer/render_frame_proxy.cc

 // Copyright 2014 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/renderer/render_frame_proxy.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 26 matching lines @@
 base::LazyInstance<FrameMap> g_frame_map = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // static
 RenderFrameProxy* RenderFrameProxy::CreateProxyToReplaceFrame(
     RenderFrameImpl* frame_to_replace,
     int routing_id,
     blink::WebTreeScopeType scope) {
   CHECK_NE(routing_id, MSG_ROUTING_NONE);
+  LOG(ERROR) << "RFP::CreateProxyToReplaceFrame:"
+    << " routing_id:" << routing_id
+    << " frame_to_replace:" << frame_to_replace;
 
   scoped_ptr<RenderFrameProxy> proxy(
       new RenderFrameProxy(routing_id, frame_to_replace->GetRoutingID()));
 
   // When a RenderFrame is replaced by a RenderProxy, the WebRemoteFrame should
   // always come from WebRemoteFrame::create and a call to WebFrame::swap must
   // follow later.
   blink::WebRemoteFrame* web_frame =
       blink::WebRemoteFrame::create(scope, proxy.get());
   proxy->Init(web_frame, frame_to_replace->render_view());
   return proxy.release();
 }
 
 RenderFrameProxy* RenderFrameProxy::CreateFrameProxy(
     int routing_id,
     int parent_routing_id,
     int render_view_routing_id,
     const FrameReplicationState& replicated_state) {
+  LOG(ERROR) << "RFP::CreateFrameProxy:"
+    << " routing_id:" << routing_id
+    << " parent routing id:" << parent_routing_id;
+
   scoped_ptr<RenderFrameProxy> proxy(
       new RenderFrameProxy(routing_id, MSG_ROUTING_NONE));
   RenderViewImpl* render_view = NULL;
   blink::WebRemoteFrame* web_frame = NULL;
   if (parent_routing_id == MSG_ROUTING_NONE) {
     // Create a top level WebRemoteFrame.
     render_view = RenderViewImpl::FromRoutingID(render_view_routing_id);
+    LOG(ERROR) << "RFP::CreateFrameProxy:"
+      << " rv:" << render_view;
     web_frame =
         blink::WebRemoteFrame::create(replicated_state.scope, proxy.get());
     render_view->webview()->setMainFrame(web_frame);
   } else {
     // Create a frame under an existing parent. The parent is always expected
     // to be a RenderFrameProxy, because navigations initiated by local frames
     // should not wind up here.
     RenderFrameProxy* parent =
         RenderFrameProxy::FromRoutingID(parent_routing_id);
     web_frame = parent->web_frame()->createRemoteChild(
@@ skipping 30 matching lines @@
   if (iter != g_frame_map.Get().end()) {
     RenderFrameProxy* proxy = iter->second;
     DCHECK_EQ(web_frame, proxy->web_frame());
     return proxy;
   }
   return NULL;
 }
 
 // static
 bool RenderFrameProxy::IsSwappedOutStateForbidden() {
-  return base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kSitePerProcess);
+  return true;
 }
 
 RenderFrameProxy::RenderFrameProxy(int routing_id, int frame_routing_id)
     : routing_id_(routing_id),
       frame_routing_id_(frame_routing_id),
       web_frame_(NULL),
       render_view_(NULL) {
+  LOG(ERROR) << "RFP[" << this << "]::RFP:"
+    << " routing_id:" << routing_id_
+    << " frame:" << frame_routing_id;
+
   std::pair<RoutingIDProxyMap::iterator, bool> result =
       g_routing_id_proxy_map.Get().insert(std::make_pair(routing_id_, this));
   CHECK(result.second) << "Inserting a duplicate item.";
   RenderThread::Get()->AddRoute(routing_id_, this);
 }
 
 RenderFrameProxy::~RenderFrameProxy() {
   // TODO(nasko): Set the render_frame_proxy to null to avoid a double deletion
   // when detaching the main frame. This can be removed once RenderFrameImpl and
   // RenderFrameProxy have been completely decoupled. See
   // https://crbug.com/357747.
   RenderFrameImpl* render_frame =
       RenderFrameImpl::FromRoutingID(frame_routing_id_);
   if (render_frame)
     render_frame->set_render_frame_proxy(nullptr);
 
   render_view()->UnregisterRenderFrameProxy(this);
 
   CHECK(!web_frame_);
   RenderThread::Get()->RemoveRoute(routing_id_);
   g_routing_id_proxy_map.Get().erase(routing_id_);
+  LOG(ERROR) << "RFP[" << this << "]::~RFP";
 }
 
 void RenderFrameProxy::Init(blink::WebRemoteFrame* web_frame,
                             RenderViewImpl* render_view) {
   CHECK(web_frame);
   CHECK(render_view);
 
   web_frame_ = web_frame;
   render_view_ = render_view;
 
@@ skipping 123 matching lines @@
   if (!compositing_helper_.get()) {
     compositing_helper_ =
         ChildFrameCompositingHelper::CreateForRenderFrameProxy(this);
     compositing_helper_->EnableCompositing(true);
   }
   compositing_helper_->OnSetSurface(surface_id, frame_size, scale_factor,
                                     sequence);
 }
 
 void RenderFrameProxy::OnDisownOpener() {
+  LOG(ERROR) << "RFP[" << this << "]::OnDisownOpener";
   // TODO(creis): We should only see this for main frames for now.  To support
   // disowning the opener on subframes, we will need to move WebContentsImpl's
   // opener_ to FrameTreeNode.
   CHECK(!web_frame_->parent());
 
   // When there is a RenderFrame for this proxy, tell it to disown its opener.
   // TODO(creis): Remove this when we only have WebRemoteFrames and make sure
   // they know they have an opener.
   if (!RenderFrameProxy::IsSwappedOutStateForbidden()) {
     RenderFrameImpl* render_frame =
         RenderFrameImpl::FromRoutingID(frame_routing_id_);
     if (render_frame) {
+      CHECK(false);
       if (render_frame->GetWebFrame()->opener())
         render_frame->GetWebFrame()->setOpener(NULL);
       return;
     }
   }
 
   if (web_frame_->opener())
     web_frame_->setOpener(NULL);
 }
 
@@ skipping 103 matching lines @@
       blink::WebUserGestureIndicator::isProcessingUserGesture();
   blink::WebUserGestureIndicator::consumeUserGesture();
   Send(new FrameHostMsg_OpenURL(routing_id_, params));
 }
 
 void RenderFrameProxy::forwardInputEvent(const blink::WebInputEvent* event) {
   Send(new FrameHostMsg_ForwardInputEvent(routing_id_, event));
 }
 
 }  // namespace