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

content/renderer/render_frame_impl.cc

 // Copyright 2013 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_impl.h"
 
 #include <map>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 524 matching lines @@
 
 // static
 void RenderFrameImpl::CreateFrame(
     int routing_id,
     int parent_routing_id,
     int previous_sibling_routing_id,
     int proxy_routing_id,
     const FrameReplicationState& replicated_state,
     CompositorDependencies* compositor_deps,
     const FrameMsg_NewFrame_WidgetParams& widget_params) {
+  // TODO(nasko): For now, this message is only sent for subframes, as the
+  // top level frame is created when the RenderView is created through the
+  // ViewMsg_New IPC.
+//  CHECK_NE(MSG_ROUTING_NONE, parent_routing_id);
+
+  LOG(ERROR) << "RF::CreateFrame:"
+    << " routing_id:" << routing_id
+    << " parent:" << parent_routing_id
+    << " proxy:" << proxy_routing_id
+    << " sibling:" << previous_sibling_routing_id;
+
   blink::WebLocalFrame* web_frame;
   RenderFrameImpl* render_frame;
   if (proxy_routing_id == MSG_ROUTING_NONE) {
     RenderFrameProxy* parent_proxy =
         RenderFrameProxy::FromRoutingID(parent_routing_id);
     // If the browser is sending a valid parent routing id, it should already
     // be created and registered.
     CHECK(parent_proxy);
     blink::WebRemoteFrame* parent_web_frame = parent_proxy->web_frame();
 
     blink::WebFrame* previous_sibling_web_frame = nullptr;
     RenderFrameProxy* previous_sibling_proxy =
         RenderFrameProxy::FromRoutingID(previous_sibling_routing_id);
     if (previous_sibling_proxy)
       previous_sibling_web_frame = previous_sibling_proxy->web_frame();
 
     // Create the RenderFrame and WebLocalFrame, linking the two.
     render_frame =
         RenderFrameImpl::Create(parent_proxy->render_view(), routing_id);
     web_frame = parent_web_frame->createLocalChild(
         replicated_state.scope, WebString::fromUTF8(replicated_state.name),
         replicated_state.sandbox_flags, render_frame,
         previous_sibling_web_frame);
   } else {
     RenderFrameProxy* proxy =
         RenderFrameProxy::FromRoutingID(proxy_routing_id);
     CHECK(proxy);
+    LOG(ERROR) << "RF::CreateFrame:"
+      << " parent_routing_id:" << parent_routing_id
+      << " proxy->web_frame->parent():" << proxy->web_frame()->parent();
     render_frame = RenderFrameImpl::Create(proxy->render_view(), routing_id);
     web_frame =
         blink::WebLocalFrame::create(replicated_state.scope, render_frame);
     render_frame->proxy_routing_id_ = proxy_routing_id;
     web_frame->initializeToReplaceRemoteFrame(
         proxy->web_frame(), WebString::fromUTF8(replicated_state.name),
         replicated_state.sandbox_flags);
   }
   render_frame->SetWebFrame(web_frame);
   CHECK_IMPLIES(parent_routing_id == MSG_ROUTING_NONE, !web_frame->parent());
@@ skipping 68 matching lines @@
 #endif
       devtools_agent_(nullptr),
       geolocation_dispatcher_(NULL),
       push_messaging_dispatcher_(NULL),
       presentation_dispatcher_(NULL),
       screen_orientation_dispatcher_(NULL),
       manifest_manager_(NULL),
       accessibility_mode_(AccessibilityModeOff),
       renderer_accessibility_(NULL),
       weak_factory_(this) {
+  LOG(ERROR) << "RF[" << this << "]::RF:"
+    << " routing_id:" << routing_id_;
+
   std::pair<RoutingIDFrameMap::iterator, bool> result =
       g_routing_id_frame_map.Get().insert(std::make_pair(routing_id_, this));
   CHECK(result.second) << "Inserting a duplicate item.";
 
   RenderThread::Get()->AddRoute(routing_id_, this);
 
   render_view_->RegisterRenderFrame(this);
 
   // Everything below subclasses RenderFrameObserver and is automatically
   // deleted when the RenderFrame gets deleted.
@@ skipping 11 matching lines @@
 RenderFrameImpl::~RenderFrameImpl() {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, RenderFrameGone());
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, OnDestruct());
 
 #if defined(VIDEO_HOLE)
   if (contains_media_player_)
     render_view_->UnregisterVideoHoleFrame(this);
 #endif
 
   if (!is_subframe_) {
-    // When not using --site-per-process, RenderFrameProxy is "owned" by
-    // RenderFrameImpl in the case it is the main frame. Ensure it is deleted
-    // along with this object.
-    if (render_frame_proxy_ &&
-        !base::CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kSitePerProcess)) {
-      // The following method calls back into this object and clears
-      // |render_frame_proxy_|.
-      render_frame_proxy_->frameDetached(
-          blink::WebRemoteFrameClient::DetachType::Remove);
-    }
-
     // Ensure the RenderView doesn't point to this object, once it is destroyed.
     // TODO(nasko): Add a check that the |main_render_frame_| of |render_view_|
     // is |this|, once the object is no longer leaked.
     // See https://crbug.com/464764.
     render_view_->main_render_frame_ = nullptr;
   }
 
   render_view_->UnregisterRenderFrame(this);
   g_routing_id_frame_map.Get().erase(routing_id_);
   RenderThread::Get()->RemoveRoute(routing_id_);
+  LOG(ERROR) << "RF[" << this << "]::~RF";
 }
 
 void RenderFrameImpl::SetWebFrame(blink::WebLocalFrame* web_frame) {
   DCHECK(!frame_);
 
   std::pair<FrameMap::iterator, bool> result = g_frame_map.Get().insert(
       std::make_pair(web_frame, this));
   CHECK(result.second) << "Inserting a duplicate item.";
 
   frame_ = web_frame;
 }
 
 void RenderFrameImpl::Initialize() {
   is_subframe_ = !!frame_->parent();
   is_local_root_ = !frame_->parent() || frame_->parent()->isWebRemoteFrame();
+  LOG(ERROR) << "RF[" << this << "]::Init:"
+    << " is_subframe_:" << is_subframe_
+    << " is_local_root_:" << is_local_root_
+    << " rv:" << render_view_.get();
 
 #if defined(ENABLE_PLUGINS)
   new PepperBrowserConnection(this);
 #endif
   new SharedWorkerRepository(this);
 
   if (!frame_->parent())
     new ImageLoadingHelper(this);
 
   if (is_local_root_ && !render_frame_proxy_) {
@@ skipping 364 matching lines @@
   base::TimeTicks before_unload_end_time = base::TimeTicks::Now();
   Send(new FrameHostMsg_BeforeUnload_ACK(routing_id_, proceed,
                                          before_unload_start_time,
                                          before_unload_end_time));
 }
 
 void RenderFrameImpl::OnSwapOut(
     int proxy_routing_id,
     bool is_loading,
     const FrameReplicationState& replicated_frame_state) {
+  LOG(ERROR) << "RF[" << this << "]::OnSwapOut:"
+    << " proxy:" << proxy_routing_id
+    << " is loading:" << is_loading;
+
   TRACE_EVENT1("navigation", "RenderFrameImpl::OnSwapOut", "id", routing_id_);
   RenderFrameProxy* proxy = NULL;
   bool is_site_per_process = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kSitePerProcess);
   bool is_main_frame = !frame_->parent();
+  bool swapped_out_forbidden = true;
+
+  // Chrome no longer supports swapped out RenderFrameImpl.
+  // TODO(nasko): Remove this check and the associated boolean variable once
+  // the removal work has had enough time to verify it works.
+  CHECK(!is_swapped_out_);
+
+  // This codepath should only be hit for subframes when in --site-per-process.
+  CHECK_IMPLIES(!is_main_frame, is_site_per_process);
 
   // Only run unload if we're not swapped out yet, but send the ack either way.
   if (!is_swapped_out_) {
     // Swap this RenderFrame out so the frame can navigate to a page rendered by
     // a different process.  This involves running the unload handler and
     // clearing the page.  We also allow this process to exit if there are no
     // other active RenderFrames in it.
 
     // Send an UpdateState message before we get swapped out.
     render_view_->SyncNavigationState();
@@ skipping 21 matching lines @@
     // willCheckAndDispatchMessageEvent() that needs the proxy.
     if (proxy)
       set_render_frame_proxy(proxy);
 
     // Now that we're swapped out and filtering IPC messages, stop loading to
     // ensure that no other in-progress navigation continues.  We do this here
     // to avoid sending a DidStopLoading message to the browser process.
     // TODO(creis): Should we be stopping all frames here and using
     // StopAltErrorPageFetcher with RenderView::OnStop, or just stopping this
     // frame?
-    if (!is_site_per_process)
+    if (!swapped_out_forbidden)
       OnStop();
 
     // Transfer settings such as initial drawing parameters to the remote frame,
     // if one is created, that will replace this frame.
     if (!is_main_frame && proxy)
       proxy->web_frame()->initializeFromFrame(frame_);
 
     // Replace the page with a blank dummy URL. The unload handler will not be
     // run a second time, thanks to a check in FrameLoader::stopLoading.
     // TODO(creis): Need to add a better way to do this that avoids running the
     // beforeunload handler. For now, we just run it a second time silently.
-    if (!is_site_per_process)
+    if (!swapped_out_forbidden)
       NavigateToSwappedOutURL();
 
     // Let WebKit know that this view is hidden so it can drop resources and
     // stop compositing.
     // TODO(creis): Support this for subframes as well.
     if (is_main_frame) {
       render_view_->webview()->setVisibilityState(
           blink::WebPageVisibilityStateHidden, false);
     }
   }
 
   // It is now safe to show modal dialogs again.
   // TODO(creis): Deal with modal dialogs from subframes.
   if (is_main_frame)
     render_view_->suppress_dialogs_until_swap_out_ = false;
 
   Send(new FrameHostMsg_SwapOut_ACK(routing_id_));
 
   RenderViewImpl* render_view = render_view_.get();
 
   // Now that all of the cleanup is complete and the browser side is notified,
   // start using the RenderFrameProxy, if one is created.
   if (proxy) {
-    if (is_site_per_process || !is_main_frame) {
+    if (swapped_out_forbidden) {
       frame_->swap(proxy->web_frame());
 
       if (is_loading)
         proxy->OnDidStartLoading();
     }
   }
 
   // In --site-per-process, initialize the WebRemoteFrame with the replication
   // state passed by the process that is now rendering the frame.
   // TODO(alexmos): We cannot yet do this for swapped-out main frames, because
   // in that case we leave the LocalFrame as the main frame visible to Blink
   // and don't call swap() above. Because swap() is what creates a RemoteFrame
   // in proxy->web_frame(), the RemoteFrame will not exist for main frames.
   // When we do an unconditional swap for all frames, we can remove
   // !is_main_frame below.
-  if (is_site_per_process && proxy)
+  if (swapped_out_forbidden && proxy)
     proxy->SetReplicatedState(replicated_frame_state);
 
   // Safe to exit if no one else is using the process.
   // TODO(nasko): Remove the dependency on RenderViewImpl here and ref count
   // the process based on the lifetime of this RenderFrameImpl object.
   if (is_main_frame) {
     render_view->WasSwappedOut();
   }
 }
 
@@ skipping 147 matching lines @@
 }
 
 void RenderFrameImpl::OnJavaScriptExecuteRequestForTests(
     const base::string16& jscript,
     int id,
     bool notify_result,
     bool has_user_gesture) {
   TRACE_EVENT_INSTANT0("test_tracing", "OnJavaScriptExecuteRequestForTests",
                        TRACE_EVENT_SCOPE_THREAD);
 
+  LOG(ERROR) << "RF[" << this << "]::OnJSExecForTests: "
+    << " id:" << id
+    << " script:|" << jscript << "|";
+
   // A bunch of tests expect to run code in the context of a user gesture, which
   // can grant additional privileges (e.g. the ability to create popups).
   scoped_ptr<blink::WebScopedUserGesture> gesture(
       has_user_gesture ? new blink::WebScopedUserGesture : nullptr);
   v8::HandleScope handle_scope(blink::mainThreadIsolate());
   v8::Local<v8::Value> result =
       frame_->executeScriptAndReturnValue(WebScriptSource(jscript));
 
   HandleJavascriptExecutionResult(jscript, id, notify_result, result);
 }
@@ skipping 152 matching lines @@
 }
 
 void RenderFrameImpl::OnSnapshotAccessibilityTree(int callback_id) {
   ui::AXTreeUpdate response;
   RendererAccessibility::SnapshotAccessibilityTree(this, &response);
   Send(new AccessibilityHostMsg_SnapshotResponse(
       routing_id_, callback_id, response));
 }
 
 void RenderFrameImpl::OnDisownOpener() {
+  LOG(ERROR) << "RF[" << 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(!frame_->parent());
 
   if (frame_->opener())
     frame_->setOpener(NULL);
 }
 
 void RenderFrameImpl::OnDidUpdateSandboxFlags(blink::WebSandboxFlags flags) {
@@ skipping 555 matching lines @@
 
 blink::WebFrame* RenderFrameImpl::createChildFrame(
     blink::WebLocalFrame* parent,
     const blink::WebString& name,
     blink::WebSandboxFlags sandbox_flags) {
   return createChildFrame(parent, blink::WebTreeScopeType::Document, name,
                           sandbox_flags);
 }
 
 void RenderFrameImpl::didDisownOpener(blink::WebLocalFrame* frame) {
+  LOG(ERROR) << "RF[" << this << "]::didDisownOpener";
+
   DCHECK(!frame_ || frame_ == frame);
   // We only need to notify the browser if the active, top-level frame clears
   // its opener.  We can ignore cases where a swapped out frame clears its
   // opener after hearing about it from the browser, and the browser does not
   // (yet) care about subframe openers.
-  if (is_swapped_out_ || frame->parent())
+  if (is_swapped_out_ || frame->parent()) {
+    LOG(ERROR) << "RF[" << this << "]::didDisownOpener:"
+      << " swapped_out:" << is_swapped_out_
+      << " parent:" << frame->parent();
     return;
+  }
 
   // Notify WebContents and all its swapped out RenderViews.
   Send(new FrameHostMsg_DidDisownOpener(routing_id_));
 }
 
 void RenderFrameImpl::frameDetached(blink::WebFrame* frame) {
   frameDetached(frame, DetachType::Remove);
 }
 
 void RenderFrameImpl::frameDetached(blink::WebFrame* frame, DetachType type) {
@@ skipping 337 matching lines @@
 
   TRACE_EVENT2("navigation", "RenderFrameImpl::didStartProvisionalLoad",
                "id", routing_id_, "url", ds->request().url().string().utf8());
   DocumentState* document_state = DocumentState::FromDataSource(ds);
 
   // We should only navigate to swappedout:// when is_swapped_out_ is true.
   CHECK((ds->request().url() != GURL(kSwappedOutURL)) ||
         is_swapped_out_) <<
         "Heard swappedout:// when not swapped out.";
 
+  LOG(ERROR) << "RF[" << this << "]::didStartProvLoad:"
+    << " url:" << ds->request().url();
+
   // Update the request time if WebKit has better knowledge of it.
   if (document_state->request_time().is_null() &&
           triggering_event_time != 0.0) {
     document_state->set_request_time(Time::FromDoubleT(triggering_event_time));
   }
 
   // Start time is only set after request time.
   document_state->set_start_load_time(Time::Now());
 
   bool is_top_most = !frame->parent();
@@ skipping 84 matching lines @@
     blink::WebHistoryCommitType commit_type) {
   TRACE_EVENT2("navigation", "RenderFrameImpl::didCommitProvisionalLoad",
                "id", routing_id_,
                "url", GetLoadingUrl().possibly_invalid_spec());
   DCHECK(!frame_ || frame_ == frame);
   DocumentState* document_state =
       DocumentState::FromDataSource(frame->dataSource());
   NavigationStateImpl* navigation_state =
       static_cast<NavigationStateImpl*>(document_state->navigation_state());
 
+  LOG(ERROR) << "RF[" << this << "]::didCommitProvLoad:"
+    << " url:" << GetLoadingUrl()
+    << " proxy_routing_id_:" << proxy_routing_id_;
+
   if (proxy_routing_id_ != MSG_ROUTING_NONE) {
     RenderFrameProxy* proxy =
         RenderFrameProxy::FromRoutingID(proxy_routing_id_);
     CHECK(proxy);
     proxy->web_frame()->swap(frame_);
     proxy_routing_id_ = MSG_ROUTING_NONE;
 
     // If this is the main frame going from a remote frame to a local frame,
     // it needs to set RenderViewImpl's pointer for the main frame to itself
     // and ensure RenderWidget is no longer in swapped out mode.
     if (!is_subframe_) {
       CHECK(!render_view_->main_render_frame_);
       render_view_->main_render_frame_ = this;
-      if (render_view_->is_swapped_out())
+      LOG(ERROR) << "RF[" << this << "]::didCommitProvLoad:"
+        << " main frame, rv swapped_out:" << render_view_->is_swapped_out();
+      if (render_view_->is_swapped_out()) {
         render_view_->SetSwappedOut(false);
+      }
     }
   }
 
   // When we perform a new navigation, we need to update the last committed
   // session history entry with state for the page we are leaving. Do this
   // before updating the HistoryController state.
   render_view_->UpdateSessionHistory(frame);
 
   render_view_->history_controller()->UpdateForCommit(
       this, item, commit_type, navigation_state->WasWithinSamePage());
@@ skipping 1825 matching lines @@
       if (!browser_side_navigation) {
         scoped_ptr<NavigationParams> navigation_params(
             new NavigationParams(*pending_navigation_params_.get()));
         if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
                 switches::kSitePerProcess)) {
           // By default, tell the HistoryController to go the deserialized
           // HistoryEntry.  This only works if all frames are in the same
           // process.
           DCHECK(!frame_->parent());
           render_view_->history_controller()->GoToEntry(
-              entry.Pass(), navigation_params.Pass(), cache_policy);
+              frame_, entry.Pass(), navigation_params.Pass(), cache_policy);
         } else {
           // In --site-per-process, the browser process sends a single
           // WebHistoryItem destined for this frame.
           // TODO(creis): Change PageState to FrameState.  In the meantime, we
           // store the relevant frame's WebHistoryItem in the root of the
           // PageState.
           SetPendingNavigationParams(navigation_params.Pass());
           blink::WebHistoryItem history_item = entry->root();
           blink::WebHistoryLoadType load_type =
               request_params.is_same_document_history_load
@@ skipping 506 matching lines @@
 #elif defined(ENABLE_BROWSER_CDMS)
         cdm_manager_,
 #endif
         this);
   }
 
   return cdm_factory_;
 }
 
 }  // namespace content