Make RenderFrame{Host} objects routable.

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 "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/child/appcache/appcache_dispatcher.h"
 #include "content/child/quota_dispatcher.h"
 #include "content/child/request_extra_data.h"
 #include "content/common/socket_stream_handle_data.h"
+#include "content/common/swapped_out_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_constants.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/password_form_conversion_utils.h"
 #include "content/renderer/browser_plugin/browser_plugin.h"
 #include "content/renderer/browser_plugin/browser_plugin_manager.h"
 #include "content/renderer/internal_document_state_data.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #include "content/renderer/render_thread_impl.h"
@@ skipping 62 matching lines @@
 // 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),
-      routing_id_(routing_id) {
+      routing_id_(routing_id),
+      is_swapped_out_(false),
+      is_detaching_(false) {
 }
 
 RenderFrameImpl::~RenderFrameImpl() {
 }
 
 int RenderFrameImpl::GetRoutingID() const {
-  // TODO(nasko): Until we register RenderFrameHost in the browser process as
-  // a listener, we must route all messages to the RenderViewHost, so use the
-  // routing id of the RenderView for now.
-  return render_view_->GetRoutingID();
+  return routing_id_;
 }
 
 bool RenderFrameImpl::Send(IPC::Message* message) {
-  // TODO(nasko): Move away from using the RenderView's Send method once we
-  // have enough infrastructure and state to make the right checks here.
-  return render_view_->Send(message);
+  if (is_detaching_ ||
+      (is_swapped_out_ &&
+       !SwappedOutMessages::CanSendWhileSwappedOut(message))) {
+    delete message;
+    return false;
+  }
+
+  if (message->routing_id() == MSG_ROUTING_NONE)
+    message->set_routing_id(routing_id_);
+
+  return RenderThread::Get()->Send(message);
 }
 
 bool RenderFrameImpl::OnMessageReceived(const IPC::Message& msg) {
-  // Pass the message up to the RenderView, until we have enough
-  // infrastructure to start processing messages in this object.
-  return render_view_->OnMessageReceived(msg);
+  // TODO(ajwong): Fill in with message handlers as various components
+  // are migrated over to understand frames.
+  return false;
 }
 
 // WebKit::WebFrameClient implementation -------------------------------------
 
 WebKit::WebPlugin* RenderFrameImpl::createPlugin(
     WebKit::WebFrame* frame,
     const WebKit::WebPluginParams& params) {
   WebKit::WebPlugin* plugin = NULL;
   if (GetContentClient()->renderer()->OverrideCreatePlugin(
           render_view_, frame, params, &plugin)) {
@@ skipping 27 matching lines @@
     const WebKit::WebURL& url,
     const WebKit::WebString& name,
     unsigned long long document_id) {
   int route_id = MSG_ROUTING_NONE;
   bool exists = false;
   bool url_mismatch = false;
   ViewHostMsg_CreateWorker_Params params;
   params.url = url;
   params.name = name;
   params.document_id = document_id;
-  params.render_view_route_id = GetRoutingID();
+  params.render_view_route_id = render_view_->GetRoutingID();
   params.route_id = MSG_ROUTING_NONE;
   params.script_resource_appcache_id = 0;
-  Send(new ViewHostMsg_LookupSharedWorker(
+  render_view_->Send(new ViewHostMsg_LookupSharedWorker(
       params, &exists, &route_id, &url_mismatch));
   if (url_mismatch) {
     return NULL;
   } else {
     return new WebSharedWorkerProxy(RenderThreadImpl::current(),
                                     document_id,
                                     exists,
                                     route_id,
-                                    GetRoutingID());
+                                    render_view_->GetRoutingID());
   }
 }
 
 WebKit::WebMediaPlayer* RenderFrameImpl::createMediaPlayer(
     WebKit::WebFrame* frame,
     const WebKit::WebURL& url,
     WebKit::WebMediaPlayerClient* client) {
   // TODO(nasko): Moving the implementation here involves moving a few media
   // related client objects here or referencing them in the RenderView. Needs
   // more work to understand where the proper place for those objects is.
@@ skipping 13 matching lines @@
 WebKit::WebCookieJar* RenderFrameImpl::cookieJar(WebKit::WebFrame* frame) {
   return render_view_->cookieJar(frame);
 }
 
 void RenderFrameImpl::didAccessInitialDocument(WebKit::WebFrame* frame) {
   render_view_->didAccessInitialDocument(frame);
 }
 
 void RenderFrameImpl::didCreateFrame(WebKit::WebFrame* parent,
                                      WebKit::WebFrame* child) {
-  Send(new ViewHostMsg_FrameAttached(GetRoutingID(), parent->identifier(),
+  render_view_->Send(
+      new ViewHostMsg_FrameAttached(render_view_->GetRoutingID(),
+                                    parent->identifier(),
       child->identifier(), UTF16ToUTF8(child->assignedName())));
 }
 
 void RenderFrameImpl::didDisownOpener(WebKit::WebFrame* frame) {
   render_view_->didDisownOpener(frame);
 }
 
 void RenderFrameImpl::frameDetached(WebKit::WebFrame* frame) {
+  // Currently multiple WebCore::Frames can send frameDetached to a single
+  // RenderFrameImpl. This is legacy behavior from when RenderViewImpl served
+  // as a shared WebFrameClient for multiple Webcore::Frame objects. It also
+  // prevents this class from entering the |is_detaching_| state because
+  // even though one WebCore::Frame may have detached itself, others will
+  // still need to use this object.
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess)) {
+    // TODO(ajwong): Add CHECK(!is_detaching_) once we guarantee each
+    // RenderFrameImpl is only used by one WebCore::Frame.
+    is_detaching_ = true;
+  }
+
   int64 parent_frame_id = -1;
   if (frame->parent())
     parent_frame_id = frame->parent()->identifier();
 
-  Send(new ViewHostMsg_FrameDetached(GetRoutingID(), parent_frame_id,
-      frame->identifier()));
+  render_view_->Send(new ViewHostMsg_FrameDetached(render_view_->GetRoutingID(),
+                                                   parent_frame_id,
+                                                   frame->identifier()));
 
   // Call back to RenderViewImpl for observers to be notified.
   // TODO(nasko): Remove once we have RenderFrameObserver.
   render_view_->frameDetached(frame);
 }
 
 void RenderFrameImpl::willClose(WebKit::WebFrame* frame) {
   // Call back to RenderViewImpl for observers to be notified.
   // TODO(nasko): Remove once we have RenderFrameObserver.
   render_view_->willClose(frame);
 }
 
 void RenderFrameImpl::didChangeName(WebKit::WebFrame* frame,
                                     const WebKit::WebString& name) {
   if (!render_view_->renderer_preferences_.report_frame_name_changes)
     return;
 
-  Send(new ViewHostMsg_UpdateFrameName(GetRoutingID(),
-                                       frame->identifier(),
-                                       !frame->parent(),
-                                       UTF16ToUTF8(name)));
+  render_view_->Send(
+      new ViewHostMsg_UpdateFrameName(render_view_->GetRoutingID(),
+                                      frame->identifier(),
+                                      !frame->parent(),
+                                      UTF16ToUTF8(name)));
 }
 
 void RenderFrameImpl::loadURLExternally(WebKit::WebFrame* frame,
                                         const WebKit::WebURLRequest& request,
                                         WebKit::WebNavigationPolicy policy) {
   loadURLExternally(frame, request, policy, WebString());
 }
 
 void RenderFrameImpl::loadURLExternally(
     WebKit::WebFrame* frame,
     const WebKit::WebURLRequest& request,
     WebKit::WebNavigationPolicy policy,
     const WebKit::WebString& suggested_name) {
   Referrer referrer(RenderViewImpl::GetReferrerFromRequest(frame, request));
   if (policy == WebKit::WebNavigationPolicyDownload) {
-    Send(new ViewHostMsg_DownloadUrl(GetRoutingID(), request.url(), referrer,
-                                     suggested_name));
+    render_view_->Send(new ViewHostMsg_DownloadUrl(render_view_->GetRoutingID(),
+                                                   request.url(), referrer,
+                                                   suggested_name));
   } else {
     render_view_->OpenURL(frame, request.url(), referrer, policy);
   }
 }
 
 WebKit::WebNavigationPolicy RenderFrameImpl::decidePolicyForNavigation(
     WebKit::WebFrame* frame,
     WebKit::WebDataSource::ExtraData* extra_data,
     const WebKit::WebURLRequest& request,
     WebKit::WebNavigationType type,
@@ skipping 104 matching lines @@
   // * stats_collection_controller_
   render_view_->didClearWindowObject(frame);
 }
 
 void RenderFrameImpl::didCreateDocumentElement(WebKit::WebFrame* frame) {
   // Notify the browser about non-blank documents loading in the top frame.
   GURL url = frame->document().url();
   if (url.is_valid() && url.spec() != kAboutBlankURL) {
     // TODO(nasko): Check if webview()->mainFrame() is the same as the
     // frame->tree()->top().
-    if (frame == render_view_->webview()->mainFrame())
-      Send(new ViewHostMsg_DocumentAvailableInMainFrame(GetRoutingID()));
+    if (frame == render_view_->webview()->mainFrame()) {
+      render_view_->Send(new ViewHostMsg_DocumentAvailableInMainFrame(
+          render_view_->GetRoutingID()));
+    }
   }
 
   // Call back to RenderViewImpl for observers to be notified.
   // TODO(nasko): Remove once we have RenderFrameObserver.
   render_view_->didCreateDocumentElement(frame);
 }
 
 void RenderFrameImpl::didReceiveTitle(WebKit::WebFrame* frame,
                                       const WebKit::WebString& title,
                                       WebKit::WebTextDirection direction) {
@@ skipping 159 matching lines @@
       top_document_state->set_was_prefetcher(true);
 
     if (was_after_preconnect_request)
       top_document_state->set_was_after_preconnect_request(true);
   }
 
   // This is an instance where we embed a copy of the routing id
   // into the data portion of the message. This can cause problems if we
   // don't register this id on the browser side, since the download manager
   // expects to find a RenderViewHost based off the id.
-  request.setRequestorID(GetRoutingID());
+  request.setRequestorID(render_view_->GetRoutingID());
   request.setHasUserGesture(WebUserGestureIndicator::isProcessingUserGesture());
 
   if (!navigation_state->extra_headers().empty()) {
     for (net::HttpUtil::HeadersIterator i(
         navigation_state->extra_headers().begin(),
         navigation_state->extra_headers().end(), "\n");
         i.GetNext(); ) {
       request.setHTTPHeaderField(WebString::fromUTF8(i.name()),
                                  WebString::fromUTF8(i.values()));
     }
@@ skipping 65 matching lines @@
   // The recipients of this message have no use for data: URLs: they don't
   // affect the page's insecure content list and are not in the disk cache. To
   // prevent large (1M+) data: URLs from crashing in the IPC system, we simply
   // filter them out here.
   GURL url(request.url());
   if (url.SchemeIs("data"))
     return;
 
   // Let the browser know we loaded a resource from the memory cache.  This
   // message is needed to display the correct SSL indicators.
-  Send(new ViewHostMsg_DidLoadResourceFromMemoryCache(
-      GetRoutingID(),
+  render_view_->Send(new ViewHostMsg_DidLoadResourceFromMemoryCache(
+      render_view_->GetRoutingID(),
       url,
       response.securityInfo(),
       request.httpMethod().utf8(),
       response.mimeType().utf8(),
       ResourceType::FromTargetType(request.targetType())));
 }
 
 void RenderFrameImpl::didDisplayInsecureContent(WebKit::WebFrame* frame) {
-  Send(new ViewHostMsg_DidDisplayInsecureContent(GetRoutingID()));
+  render_view_->Send(new ViewHostMsg_DidDisplayInsecureContent(
+      render_view_->GetRoutingID()));
 }
 
 void RenderFrameImpl::didRunInsecureContent(
     WebKit::WebFrame* frame,
     const WebKit::WebSecurityOrigin& origin,
     const WebKit::WebURL& target) {
-  Send(new ViewHostMsg_DidRunInsecureContent(
-      GetRoutingID(),
+  render_view_->Send(new ViewHostMsg_DidRunInsecureContent(
+      render_view_->GetRoutingID(),
       origin.toString().utf8(),
       target));
 }
 
 void RenderFrameImpl::didExhaustMemoryAvailableForScript(
     WebKit::WebFrame* frame) {
-  Send(new ViewHostMsg_JSOutOfMemory(GetRoutingID()));
+  render_view_->Send(new ViewHostMsg_JSOutOfMemory(
+      render_view_->GetRoutingID()));
 }
 
 void RenderFrameImpl::didCreateScriptContext(WebKit::WebFrame* frame,
                                              v8::Handle<v8::Context> context,
                                              int extension_group,
                                              int world_id) {
   GetContentClient()->renderer()->DidCreateScriptContext(
       frame, context, extension_group, world_id);
 }
 
@@ skipping 16 matching lines @@
   render_view_->didChangeContentsSize(frame, size);
 }
 
 void RenderFrameImpl::didChangeScrollOffset(WebKit::WebFrame* frame) {
   // TODO(nasko): Move implementation here. Needed methods:
   // * StartNavStateSyncTimerIfNecessary
   render_view_->didChangeScrollOffset(frame);
 }
 
 void RenderFrameImpl::willInsertBody(WebKit::WebFrame* frame) {
-  if (!frame->parent())
-    Send(new ViewHostMsg_WillInsertBody(GetRoutingID()));
+  if (!frame->parent()) {
+    render_view_->Send(new ViewHostMsg_WillInsertBody(
+        render_view_->GetRoutingID()));
+  }
 }
 
 void RenderFrameImpl::reportFindInPageMatchCount(int request_id,
                                                  int count,
                                                  bool final_update) {
   int active_match_ordinal = -1;  // -1 = don't update active match ordinal
   if (!count)
     active_match_ordinal = 0;
 
-  Send(new ViewHostMsg_Find_Reply(GetRoutingID(),
-                                  request_id,
-                                  count,
-                                  gfx::Rect(),
-                                  active_match_ordinal,
-                                  final_update));
+  render_view_->Send(new ViewHostMsg_Find_Reply(
+      render_view_->GetRoutingID(), request_id, count,
+      gfx::Rect(), active_match_ordinal, final_update));
 }
 
 void RenderFrameImpl::reportFindInPageSelection(
     int request_id,
     int active_match_ordinal,
     const WebKit::WebRect& selection_rect) {
-  Send(new ViewHostMsg_Find_Reply(GetRoutingID(),
-                                  request_id,
-                                  -1,
-                                  selection_rect,
-                                  active_match_ordinal,
-                                  false));
+  render_view_->Send(new ViewHostMsg_Find_Reply(
+      render_view_->GetRoutingID(), request_id, -1, selection_rect,
+      active_match_ordinal, false));
 }
 
 void RenderFrameImpl::requestStorageQuota(
     WebKit::WebFrame* frame,
     WebKit::WebStorageQuotaType type,
     unsigned long long requested_size,
     WebKit::WebStorageQuotaCallbacks* callbacks) {
   DCHECK(frame);
   WebSecurityOrigin origin = frame->document().securityOrigin();
   if (origin.isUnique()) {
     // Unique origins cannot store persistent state.
     callbacks->didFail(WebKit::WebStorageQuotaErrorAbort);
     return;
   }
   ChildThread::current()->quota_dispatcher()->RequestStorageQuota(
-      GetRoutingID(), GURL(origin.toString()),
+      render_view_->GetRoutingID(), GURL(origin.toString()),
       static_cast<quota::StorageType>(type), requested_size,
       QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(callbacks));
 }
 
 void RenderFrameImpl::willOpenSocketStream(
     WebKit::WebSocketStreamHandle* handle) {
-  SocketStreamHandleData::AddToHandle(handle, GetRoutingID());
+  SocketStreamHandleData::AddToHandle(handle, render_view_->GetRoutingID());
 }
 
 void RenderFrameImpl::willStartUsingPeerConnectionHandler(
     WebKit::WebFrame* frame,
     WebKit::WebRTCPeerConnectionHandler* handler) {
 #if defined(ENABLE_WEBRTC)
   static_cast<RTCPeerConnectionHandler*>(handler)->associateWithFrame(frame);
 #endif
 }
 
@@ skipping 37 matching lines @@
   if (render_view_->renderer_preferences_.enable_do_not_track)
     return WebString::fromUTF8("1");
   return WebString();
 }
 
 bool RenderFrameImpl::allowWebGL(WebKit::WebFrame* frame, bool default_value) {
   if (!default_value)
     return false;
 
   bool blocked = true;
-  Send(new ViewHostMsg_Are3DAPIsBlocked(
-      GetRoutingID(),
+  render_view_->Send(new ViewHostMsg_Are3DAPIsBlocked(
+      render_view_->GetRoutingID(),
       GURL(frame->top()->document().securityOrigin().toString()),
       THREE_D_API_TYPE_WEBGL,
       &blocked));
   return !blocked;
 }
 
 void RenderFrameImpl::didLoseWebGLContext(WebKit::WebFrame* frame,
                                           int arb_robustness_status_code) {
-  Send(new ViewHostMsg_DidLose3DContext(
+  render_view_->Send(new ViewHostMsg_DidLose3DContext(
       GURL(frame->top()->document().securityOrigin().toString()),
       THREE_D_API_TYPE_WEBGL,
       arb_robustness_status_code));
 }
 
 }  // namespace content