Allow RenderFrames to swap out for subframe navigations.

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/command_line.h"
@@ skipping 96 matching lines @@
 RenderFrameImpl* RenderFrameImpl::Create(RenderViewImpl* render_view,
                                          int32 routing_id) {
   DCHECK(routing_id != MSG_ROUTING_NONE);
 
   if (g_create_render_frame_impl)
     return g_create_render_frame_impl(render_view, routing_id);
   else
     return new RenderFrameImpl(render_view, routing_id);
 }
 
+RenderFrameImpl* RenderFrameImpl::FindByWebFrame(blink::WebFrame* web_frame) {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess)) {
+    FrameMap::iterator iter = g_child_frame_map.Get().find(web_frame);
+    if (iter != g_child_frame_map.Get().end())
+      return iter->second;
+  }
+
+  return NULL;
+}
+
 // static
 void RenderFrameImpl::InstallCreateHook(
     RenderFrameImpl* (*create_render_frame_impl)(RenderViewImpl*, int32)) {
   CHECK(!g_create_render_frame_impl);
   g_create_render_frame_impl = create_render_frame_impl;
 }
 
 // RenderFrameImpl ----------------------------------------------------------
 RenderFrameImpl::RenderFrameImpl(RenderViewImpl* render_view, int routing_id)
-    : render_view_(render_view),
+    : frame_(NULL),
+      render_view_(render_view),
       routing_id_(routing_id),
       is_swapped_out_(false),
       is_detaching_(false) {
   RenderThread::Get()->AddRoute(routing_id_, this);
 #if defined(ENABLE_PLUGINS)
   new PepperBrowserConnection(this);
 #endif
   new SharedWorkerRepository(this);
 
   GetContentClient()->renderer()->RenderFrameCreated(this);
 }
 
 RenderFrameImpl::~RenderFrameImpl() {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, RenderFrameGone());
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, OnDestruct());
   RenderThread::Get()->RemoveRoute(routing_id_);
 }
 
 void RenderFrameImpl::MainWebFrameCreated(blink::WebFrame* frame) {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_,
                     WebFrameCreated(frame));
 }
 
+void RenderFrameImpl::SetWebFrame(blink::WebFrame* web_frame) {
+  DCHECK(!frame_);
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess))
+    frame_ = web_frame;
+}
+
 RenderWidget* RenderFrameImpl::GetRenderWidget() {
   return render_view_;
 }
 
 #if defined(ENABLE_PLUGINS)
 void RenderFrameImpl::PepperPluginCreated(RendererPpapiHost* host) {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_,
                     DidCreatePepperPlugin(host));
 }
 
@@ skipping 294 matching lines @@
 }
 
 bool RenderFrameImpl::OnMessageReceived(const IPC::Message& msg) {
   ObserverListBase<RenderFrameObserver>::Iterator it(observers_);
   RenderFrameObserver* observer;
   while ((observer = it.GetNext()) != NULL) {
     if (observer->OnMessageReceived(msg))
       return true;
   }
 
-  // TODO(ajwong): Fill in with message handlers as various components
-  // are migrated over to understand frames.
-  return false;
+  bool handled = true;
+  bool msg_is_ok = true;
+  IPC_BEGIN_MESSAGE_MAP_EX(RenderFrameImpl, msg, msg_is_ok)
+    IPC_MESSAGE_HANDLER(FrameMsg_SwapOut, OnSwapOut)
+  IPC_END_MESSAGE_MAP_EX()
+
+  if (!msg_is_ok) {
+    // The message had a handler, but its deserialization failed.
+    // Kill the renderer to avoid potential spoofing attacks.
+    CHECK(false) << "Unable to deserialize message in RenderFrameImpl.";
+  }
+
+  return handled;
+ }
+
+void RenderFrameImpl::OnSwapOut() {
+  // Only run unload if we're not swapped out yet, but send the ack either way.
+  if (!is_swapped_out_) {
+    // Swap this RenderView out so the tab can navigate to a page rendered by a
+    // different process.  This involves running the unload handler and clearing
+    // the page.  Once WasSwappedOut is called, we also allow this process to
+    // exit if there are no other active RenderViews in it.
+
+    // Send an UpdateState message before we get swapped out.
+    render_view_->SyncNavigationState();
+
+    // Synchronously run the unload handler before sending the ACK.
+    // TODO(creis): Add a WebFrame::dispatchUnloadEvent and call it here.
+
+    // Swap out and stop sending any IPC messages that are not ACKs.
+    is_swapped_out_ = true;
+
+    // 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?
+    frame_->stopLoading();
+
+    // 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.
+    render_view_->NavigateToSwappedOutURL(frame_);
+  }
+
+  Send(new FrameHostMsg_SwapOut_ACK(routing_id_));
 }
 
 RenderView* RenderFrameImpl::GetRenderView() {
   return render_view_;
 }
 
 int RenderFrameImpl::GetRoutingID() {
   return routing_id_;
 }
 
@@ skipping 137 matching lines @@
                                            child_frame_identifier,
                                            UTF16ToUTF8(name),
                                            &routing_id));
     child_render_frame = RenderFrameImpl::Create(render_view_, routing_id);
   }
 
   blink::WebFrame* web_frame = WebFrame::create(child_render_frame,
                                                 child_frame_identifier);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess)) {
+    child_render_frame->SetWebFrame(web_frame);
     g_child_frame_map.Get().insert(
         std::make_pair(web_frame, child_render_frame));
   } else {
     FOR_EACH_OBSERVER(RenderFrameObserver, observers_,
                       WebFrameCreated(web_frame));
   }
 
   return web_frame;
 }
 
@@ skipping 164 matching lines @@
 
   // In fast/loader/stop-provisional-loads.html, we abort the load before this
   // callback is invoked.
   if (!ds)
     return;
 
   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_ ||
         render_view_->is_swapped_out()) <<
         "Heard swappedout:// when not swapped out.";
 
   // Update the request time if WebKit has better knowledge of it.
   if (document_state->request_time().is_null()) {
     double event_time = ds->triggeringEventTime();
     if (event_time != 0.0)
       document_state->set_request_time(Time::FromDoubleT(event_time));
   }
 
@@ skipping 557 matching lines @@
 void RenderFrameImpl::AddObserver(RenderFrameObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void RenderFrameImpl::RemoveObserver(RenderFrameObserver* observer) {
   observer->RenderFrameGone();
   observers_.RemoveObserver(observer);
 }
 
 }  // namespace content