Add partial WebFrameClient implementation to RenderFrame.

This is the first step of moving frame specific code away from RenderView into RenderFrame. The CL moves all methods that don't change any state and leaves the state in the RenderView object.

BUG=245126

Review URL: https://chromiumcodereview.appspot.com/16418003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@212956 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 625 insertions, 443 deletions

diff --git a/content/renderer/render_frame_impl.cc b/content/renderer/render_frame_impl.cc
index 83e86e8..ec350bc 100644
--- a/content/renderer/render_frame_impl.cc
+++ b/content/renderer/render_frame_impl.cc
@@ -4,8 +4,74 @@
 
 #include "content/renderer/render_frame_impl.h"
 
+#include "base/strings/utf_string_conversions.h"
+#include "base/time/time.h"
+#include "content/child/appcache_dispatcher.h"
+#include "content/child/fileapi/file_system_dispatcher.h"
+#include "content/child/fileapi/webfilesystem_callback_adapters.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/view_messages.h"
+#include "content/public/common/content_constants.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"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/renderer_webapplicationcachehost_impl.h"
+#include "content/renderer/webplugin_impl.h"
+#include "content/renderer/websharedworker_proxy.h"
+#include "net/base/net_errors.h"
+#include "net/http/http_util.h"
+#include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/platform/WebURL.h"
+#include "third_party/WebKit/public/platform/WebURLError.h"
+#include "third_party/WebKit/public/platform/WebURLResponse.h"
+#include "third_party/WebKit/public/platform/WebVector.h"
+#include "third_party/WebKit/public/web/WebDocument.h"
+#include "third_party/WebKit/public/web/WebFileSystemCallbacks.h"
+#include "third_party/WebKit/public/web/WebFrame.h"
+#include "third_party/WebKit/public/web/WebNavigationPolicy.h"
+#include "third_party/WebKit/public/web/WebPlugin.h"
+#include "third_party/WebKit/public/web/WebPluginParams.h"
+#include "third_party/WebKit/public/web/WebSearchableFormData.h"
+#include "third_party/WebKit/public/web/WebSecurityOrigin.h"
+#include "third_party/WebKit/public/web/WebStorageQuotaCallbacks.h"
+#include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
+#include "third_party/WebKit/public/web/WebView.h"
+#include "webkit/glue/weburlresponse_extradata_impl.h"
+
+using WebKit::WebDataSource;
+using WebKit::WebDocument;
+using WebKit::WebFileSystemCallbacks;
+using WebKit::WebFrame;
+using WebKit::WebNavigationPolicy;
+using WebKit::WebPluginParams;
+using WebKit::WebReferrerPolicy;
+using WebKit::WebSearchableFormData;
+using WebKit::WebSecurityOrigin;
+using WebKit::WebStorageQuotaCallbacks;
+using WebKit::WebString;
+using WebKit::WebURL;
+using WebKit::WebURLError;
+using WebKit::WebURLRequest;
+using WebKit::WebURLResponse;
+using WebKit::WebUserGestureIndicator;
+using WebKit::WebVector;
+using WebKit::WebView;
+
+using appcache::WebApplicationCacheHostImpl;
+using base::Time;
+using base::TimeDelta;
+
+using webkit_glue::WebURLResponseExtraDataImpl;
 
 namespace content {
 
@@ -34,6 +100,7 @@ void RenderFrameImpl::InstallCreateHook(
   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) {
@@ -42,6 +109,13 @@ RenderFrameImpl::RenderFrameImpl(RenderViewImpl* render_view, int routing_id)
 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();
+}
+
 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.
@@ -59,7 +133,32 @@ bool RenderFrameImpl::OnMessageReceived(const IPC::Message& msg) {
 WebKit::WebPlugin* RenderFrameImpl::createPlugin(
     WebKit::WebFrame* frame,
     const WebKit::WebPluginParams& params) {
-  return render_view_->createPlugin(frame, params);
+  WebKit::WebPlugin* plugin = NULL;
+  if (GetContentClient()->renderer()->OverrideCreatePlugin(
+          render_view_, frame, params, &plugin)) {
+    return plugin;
+  }
+
+#if defined(ENABLE_PLUGINS)
+  if (UTF16ToASCII(params.mimeType) == kBrowserPluginMimeType) {
+    return render_view_->GetBrowserPluginManager()->CreateBrowserPlugin(
+        render_view_, frame, params);
+  }
+
+  WebPluginInfo info;
+  std::string mime_type;
+  bool found = render_view_->GetPluginInfo(
+      params.url, frame->top()->document().url(), params.mimeType.utf8(),
+      &info, &mime_type);
+  if (!found)
+    return NULL;
+
+  WebPluginParams params_to_use = params;
+  params_to_use.mimeType = WebString::fromUTF8(mime_type);
+  return render_view_->CreatePlugin(frame, info, params_to_use);
+#else
+  return NULL;
+#endif  // defined(ENABLE_PLUGINS)
 }
 
 WebKit::WebSharedWorker* RenderFrameImpl::createSharedWorker(
@@ -67,20 +166,47 @@ WebKit::WebSharedWorker* RenderFrameImpl::createSharedWorker(
     const WebKit::WebURL& url,
     const WebKit::WebString& name,
     unsigned long long document_id) {
-  return render_view_->createSharedWorker(frame, url, name, 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.route_id = MSG_ROUTING_NONE;
+  params.script_resource_appcache_id = 0;
+  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());
+  }
 }
 
 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.
   return render_view_->createMediaPlayer(frame, url, client);
 }
 
 WebKit::WebApplicationCacheHost* RenderFrameImpl::createApplicationCacheHost(
     WebKit::WebFrame* frame,
     WebKit::WebApplicationCacheHostClient* client) {
-  return render_view_->createApplicationCacheHost(frame, client);
+  if (!frame || !frame->view())
+    return NULL;
+  return new RendererWebApplicationCacheHostImpl(
+      RenderViewImpl::FromWebView(frame->view()), client,
+      RenderThreadImpl::current()->appcache_dispatcher()->backend_proxy());
 }
 
 WebKit::WebCookieJar* RenderFrameImpl::cookieJar(WebKit::WebFrame* frame) {
@@ -93,7 +219,8 @@ void RenderFrameImpl::didAccessInitialDocument(WebKit::WebFrame* frame) {
 
 void RenderFrameImpl::didCreateFrame(WebKit::WebFrame* parent,
                                      WebKit::WebFrame* child) {
-  render_view_->didCreateFrame(parent, child);
+  Send(new ViewHostMsg_FrameAttached(GetRoutingID(), parent->identifier(),
+      child->identifier(), UTF16ToUTF8(child->assignedName())));
 }
 
 void RenderFrameImpl::didDisownOpener(WebKit::WebFrame* frame) {
@@ -101,22 +228,39 @@ void RenderFrameImpl::didDisownOpener(WebKit::WebFrame* frame) {
 }
 
 void RenderFrameImpl::frameDetached(WebKit::WebFrame* frame) {
+  int64 parent_frame_id = -1;
+  if (frame->parent())
+    parent_frame_id = frame->parent()->identifier();
+
+  Send(new ViewHostMsg_FrameDetached(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) {
-  render_view_->didChangeName(frame, name);
+  if (!render_view_->renderer_preferences_.report_frame_name_changes)
+    return;
+
+  Send(new ViewHostMsg_UpdateFrameName(GetRoutingID(),
+                                       frame->identifier(),
+                                       !frame->parent(),
+                                       UTF16ToUTF8(name)));
 }
 
 void RenderFrameImpl::loadURLExternally(WebKit::WebFrame* frame,
                                         const WebKit::WebURLRequest& request,
                                         WebKit::WebNavigationPolicy policy) {
-  render_view_->loadURLExternally(frame, request, policy);
+  loadURLExternally(frame, request, policy, WebString());
 }
 
 void RenderFrameImpl::loadURLExternally(
@@ -124,7 +268,15 @@ void RenderFrameImpl::loadURLExternally(
     const WebKit::WebURLRequest& request,
     WebKit::WebNavigationPolicy policy,
     const WebKit::WebString& suggested_name) {
-  render_view_->loadURLExternally(frame, request, policy, suggested_name);
+  Referrer referrer(
+      GURL(request.httpHeaderField(WebString::fromUTF8("Referer"))),
+      RenderViewImpl::GetReferrerPolicyFromRequest(frame, request));
+  if (policy == WebKit::WebNavigationPolicyDownload) {
+    Send(new ViewHostMsg_DownloadUrl(GetRoutingID(), request.url(), referrer,
+                                     suggested_name));
+  } else {
+    render_view_->OpenURL(frame, request.url(), referrer, policy);
+  }
 }
 
 WebKit::WebNavigationPolicy RenderFrameImpl::decidePolicyForNavigation(
@@ -140,28 +292,77 @@ WebKit::WebNavigationPolicy RenderFrameImpl::decidePolicyForNavigation(
 WebKit::WebURLError RenderFrameImpl::cannotHandleRequestError(
     WebKit::WebFrame* frame,
     const WebKit::WebURLRequest& request) {
-  return render_view_->cannotHandleRequestError(frame, request);
+  NOTREACHED();  // Since we said we can handle all requests.
+  return WebURLError();
 }
 
 WebKit::WebURLError RenderFrameImpl::cancelledError(
     WebKit::WebFrame* frame,
     const WebKit::WebURLRequest& request) {
-  return render_view_->cancelledError(frame, request);
+  WebURLError error;
+  error.domain = WebString::fromUTF8(net::kErrorDomain);
+  error.reason = net::ERR_ABORTED;
+  error.unreachableURL = request.url();
+  return error;
 }
 
 void RenderFrameImpl::unableToImplementPolicyWithError(
     WebKit::WebFrame* frame,
     const WebKit::WebURLError& error) {
-  render_view_->unableToImplementPolicyWithError(frame, error);
+  NOTREACHED();  // Since we said we can handle all requests.
 }
 
 void RenderFrameImpl::willSendSubmitEvent(WebKit::WebFrame* frame,
                                           const WebKit::WebFormElement& form) {
-  render_view_->willSendSubmitEvent(frame, form);
+  // Some login forms have onSubmit handlers that put a hash of the password
+  // into a hidden field and then clear the password. (Issue 28910.)
+  // This method gets called before any of those handlers run, so save away
+  // a copy of the password in case it gets lost.
+  DocumentState* document_state =
+      DocumentState::FromDataSource(frame->dataSource());
+  document_state->set_password_form_data(CreatePasswordForm(form));
 }
 
 void RenderFrameImpl::willSubmitForm(WebKit::WebFrame* frame,
                                      const WebKit::WebFormElement& form) {
+  DocumentState* document_state =
+      DocumentState::FromDataSource(frame->provisionalDataSource());
+  NavigationState* navigation_state = document_state->navigation_state();
+  InternalDocumentStateData* internal_data =
+      InternalDocumentStateData::FromDocumentState(document_state);
+
+  if (PageTransitionCoreTypeIs(navigation_state->transition_type(),
+                               PAGE_TRANSITION_LINK)) {
+    navigation_state->set_transition_type(PAGE_TRANSITION_FORM_SUBMIT);
+  }
+
+  // Save these to be processed when the ensuing navigation is committed.
+  WebSearchableFormData web_searchable_form_data(form);
+  internal_data->set_searchable_form_url(web_searchable_form_data.url());
+  internal_data->set_searchable_form_encoding(
+      web_searchable_form_data.encoding().utf8());
+  scoped_ptr<PasswordForm> password_form_data =
+      CreatePasswordForm(form);
+
+  // In order to save the password that the user actually typed and not one
+  // that may have gotten transformed by the site prior to submit, recover it
+  // from the form contents already stored by |willSendSubmitEvent| into the
+  // dataSource's NavigationState (as opposed to the provisionalDataSource's,
+  // which is what we're storing into now.)
+  if (password_form_data) {
+    DocumentState* old_document_state =
+        DocumentState::FromDataSource(frame->dataSource());
+    if (old_document_state) {
+      PasswordForm* old_form_data = old_document_state->password_form_data();
+      if (old_form_data && old_form_data->action == password_form_data->action)
+        password_form_data->password_value = old_form_data->password_value;
+    }
+  }
+
+  document_state->set_password_form_data(password_form_data.Pass());
+
+  // Call back to RenderViewImpl for observers to be notified.
+  // TODO(nasko): Remove once we have RenderFrameObserver.
   render_view_->willSubmitForm(frame, form);
 }
 
@@ -170,85 +371,147 @@ void RenderFrameImpl::willPerformClientRedirect(WebKit::WebFrame* frame,
                                                 const WebKit::WebURL& to,
                                                 double interval,
                                                 double fire_time) {
+  // Call back to RenderViewImpl for observers to be notified.
+  // TODO(nasko): Remove once we have RenderFrameObserver.
   render_view_->willPerformClientRedirect(frame, from, to, interval, fire_time);
 }
 
 void RenderFrameImpl::didCancelClientRedirect(WebKit::WebFrame* frame) {
+  // Call back to RenderViewImpl for observers to be notified.
+  // TODO(nasko): Remove once we have RenderFrameObserver.
   render_view_->didCancelClientRedirect(frame);
 }
 
 void RenderFrameImpl::didCompleteClientRedirect(WebKit::WebFrame* frame,
                                                 const WebKit::WebURL& from) {
+  // Call back to RenderViewImpl for observers to be notified.
+  // TODO(nasko): Remove once we have RenderFrameObserver.
   render_view_->didCompleteClientRedirect(frame, from);
 }
 
 void RenderFrameImpl::didCreateDataSource(WebKit::WebFrame* frame,
                                           WebKit::WebDataSource* datasource) {
+  // TODO(nasko): Move implementation here. Needed state:
+  // * pending_navigation_params_
+  // * webview
+  // Needed methods:
+  // * PopulateDocumentStateFromPending
+  // * CreateNavigationStateFromPending
   render_view_->didCreateDataSource(frame, datasource);
 }
 
 void RenderFrameImpl::didStartProvisionalLoad(WebKit::WebFrame* frame) {
+  // TODO(nasko): Move implementation here. Needed state:
+  // * is_swapped_out_
+  // * navigation_gesture_
+  // * completed_client_redirect_src_
   render_view_->didStartProvisionalLoad(frame);
 }
 
 void RenderFrameImpl::didReceiveServerRedirectForProvisionalLoad(
     WebKit::WebFrame* frame) {
+  // TODO(nasko): Move implementation here. Needed state:
+  // * page_id_
   render_view_->didReceiveServerRedirectForProvisionalLoad(frame);
 }
 
 void RenderFrameImpl::didFailProvisionalLoad(
     WebKit::WebFrame* frame,
     const WebKit::WebURLError& error) {
+  // TODO(nasko): Move implementation here. Needed state:
+  // * page_id_
+  // * pending_navigation_params_
+  // Needed methods
+  // * MaybeLoadAlternateErrorPage
+  // * LoadNavigationErrorPage
   render_view_->didFailProvisionalLoad(frame, error);
 }
 
 void RenderFrameImpl::didCommitProvisionalLoad(WebKit::WebFrame* frame,
                                                bool is_new_navigation) {
+  // TODO(nasko): Move implementation here. Needed state:
+  // * page_id_
+  // * next_page_id_
+  // * history_list_offset_
+  // * history_list_length_
+  // * history_page_ids_
+  // Needed methods
+  // * webview
+  // * UpdateSessionHistory
+  // * GetLoadingUrl
   render_view_->didCommitProvisionalLoad(frame, is_new_navigation);
 }
 
 void RenderFrameImpl::didClearWindowObject(WebKit::WebFrame* frame) {
+  // TODO(nasko): Move implementation here. Needed state:
+  // * enabled_bindings_
+  // * dom_automation_controller_
+  // * 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()));
+  }
+
+  // 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) {
+  // TODO(nasko): Investigate wheather implementation should move here.
   render_view_->didReceiveTitle(frame, title, direction);
 }
 
 void RenderFrameImpl::didChangeIcon(WebKit::WebFrame* frame,
                                     WebKit::WebIconURL::Type icon_type) {
+  // TODO(nasko): Investigate wheather implementation should move here.
   render_view_->didChangeIcon(frame, icon_type);
 }
 
 void RenderFrameImpl::didFinishDocumentLoad(WebKit::WebFrame* frame) {
+  // TODO(nasko): Move implementation here. No state needed, just observers
+  // notification in before updating encoding.
   render_view_->didFinishDocumentLoad(frame);
 }
 
 void RenderFrameImpl::didHandleOnloadEvents(WebKit::WebFrame* frame) {
+  // TODO(nasko): Move implementation here. Needed state:
+  // * page_id_
   render_view_->didHandleOnloadEvents(frame);
 }
 
 void RenderFrameImpl::didFailLoad(WebKit::WebFrame* frame,
                                   const WebKit::WebURLError& error) {
+  // TODO(nasko): Move implementation here. No state needed.
   render_view_->didFailLoad(frame, error);
 }
 
 void RenderFrameImpl::didFinishLoad(WebKit::WebFrame* frame) {
+  // TODO(nasko): Move implementation here. No state needed, just observers
+  // notification before sending message to the browser process.
   render_view_->didFinishLoad(frame);
 }
 
 void RenderFrameImpl::didNavigateWithinPage(WebKit::WebFrame* frame,
                                             bool is_new_navigation) {
+  // TODO(nasko): Move implementation here. No state needed, just observers
+  // notification before sending message to the browser process.
   render_view_->didNavigateWithinPage(frame, is_new_navigation);
 }
 
 void RenderFrameImpl::didUpdateCurrentHistoryItem(WebKit::WebFrame* frame) {
+  // TODO(nasko): Move implementation here. Needed methods:
+  // * StartNavStateSyncTimerIfNecessary
   render_view_->didUpdateCurrentHistoryItem(frame);
 }
 
@@ -257,62 +520,223 @@ void RenderFrameImpl::willSendRequest(
     unsigned identifier,
     WebKit::WebURLRequest& request,
     const WebKit::WebURLResponse& redirect_response) {
-  render_view_->willSendRequest(frame, identifier, request, redirect_response);
+  // The request my be empty during tests.
+  if (request.url().isEmpty())
+    return;
+
+  WebFrame* top_frame = frame->top();
+  if (!top_frame)
+    top_frame = frame;
+  WebDataSource* provisional_data_source = top_frame->provisionalDataSource();
+  WebDataSource* top_data_source = top_frame->dataSource();
+  WebDataSource* data_source =
+      provisional_data_source ? provisional_data_source : top_data_source;
+
+  PageTransition transition_type = PAGE_TRANSITION_LINK;
+  DocumentState* document_state = DocumentState::FromDataSource(data_source);
+  DCHECK(document_state);
+  InternalDocumentStateData* internal_data =
+      InternalDocumentStateData::FromDocumentState(document_state);
+  NavigationState* navigation_state = document_state->navigation_state();
+  transition_type = navigation_state->transition_type();
+
+  GURL request_url(request.url());
+  GURL new_url;
+  if (GetContentClient()->renderer()->WillSendRequest(
+          frame,
+          transition_type,
+          request_url,
+          request.firstPartyForCookies(),
+          &new_url)) {
+    request.setURL(WebURL(new_url));
+  }
+
+  if (internal_data->is_cache_policy_override_set())
+    request.setCachePolicy(internal_data->cache_policy_override());
+
+  WebKit::WebReferrerPolicy referrer_policy;
+  if (internal_data->is_referrer_policy_set()) {
+    referrer_policy = internal_data->referrer_policy();
+    internal_data->clear_referrer_policy();
+  } else {
+    referrer_policy = frame->document().referrerPolicy();
+  }
+
+  // The request's extra data may indicate that we should set a custom user
+  // agent. This needs to be done here, after WebKit is through with setting the
+  // user agent on its own.
+  WebString custom_user_agent;
+  if (request.extraData()) {
+    webkit_glue::WebURLRequestExtraDataImpl* old_extra_data =
+        static_cast<webkit_glue::WebURLRequestExtraDataImpl*>(
+            request.extraData());
+    custom_user_agent = old_extra_data->custom_user_agent();
+
+    if (!custom_user_agent.isNull()) {
+      if (custom_user_agent.isEmpty())
+        request.clearHTTPHeaderField("User-Agent");
+      else
+        request.setHTTPHeaderField("User-Agent", custom_user_agent);
+    }
+  }
+
+  request.setExtraData(
+      new RequestExtraData(referrer_policy,
+                           custom_user_agent,
+                           (frame == top_frame),
+                           frame->identifier(),
+                           frame->parent() == top_frame,
+                           frame->parent() ? frame->parent()->identifier() : -1,
+                           navigation_state->allow_download(),
+                           transition_type,
+                           navigation_state->transferred_request_child_id(),
+                           navigation_state->transferred_request_request_id()));
+
+  DocumentState* top_document_state =
+      DocumentState::FromDataSource(top_data_source);
+  // TODO(gavinp): separate out prefetching and prerender field trials
+  // if the rel=prerender rel type is sticking around.
+  if (top_document_state &&
+      request.targetType() == WebURLRequest::TargetIsPrefetch)
+    top_document_state->set_was_prefetcher(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.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()));
+    }
+  }
+
+  if (!render_view_->renderer_preferences_.enable_referrers)
+    request.clearHTTPHeaderField("Referer");
 }
 
 void RenderFrameImpl::didReceiveResponse(
     WebKit::WebFrame* frame,
     unsigned identifier,
     const WebKit::WebURLResponse& response) {
-  render_view_->didReceiveResponse(frame, identifier, response);
+  // Only do this for responses that correspond to a provisional data source
+  // of the top-most frame.  If we have a provisional data source, then we
+  // can't have any sub-resources yet, so we know that this response must
+  // correspond to a frame load.
+  if (!frame->provisionalDataSource() || frame->parent())
+    return;
+
+  // If we are in view source mode, then just let the user see the source of
+  // the server's error page.
+  if (frame->isViewSourceModeEnabled())
+    return;
+
+  DocumentState* document_state =
+      DocumentState::FromDataSource(frame->provisionalDataSource());
+  int http_status_code = response.httpStatusCode();
+
+  // Record page load flags.
+  WebURLResponseExtraDataImpl* extra_data =
+      RenderViewImpl::GetExtraDataFromResponse(response);
+  if (extra_data) {
+    document_state->set_was_fetched_via_spdy(
+        extra_data->was_fetched_via_spdy());
+    document_state->set_was_npn_negotiated(
+        extra_data->was_npn_negotiated());
+    document_state->set_npn_negotiated_protocol(
+        extra_data->npn_negotiated_protocol());
+    document_state->set_was_alternate_protocol_available(
+        extra_data->was_alternate_protocol_available());
+    document_state->set_connection_info(
+        extra_data->connection_info());
+    document_state->set_was_fetched_via_proxy(
+        extra_data->was_fetched_via_proxy());
+  }
+  InternalDocumentStateData* internal_data =
+      InternalDocumentStateData::FromDocumentState(document_state);
+  internal_data->set_http_status_code(http_status_code);
+  // Whether or not the http status code actually corresponds to an error is
+  // only checked when the page is done loading, if |use_error_page| is
+  // still true.
+  internal_data->set_use_error_page(true);
 }
 
 void RenderFrameImpl::didFinishResourceLoad(WebKit::WebFrame* frame,
                                             unsigned identifier) {
+  // TODO(nasko): Move implementation here. Needed state:
+  // * devtools_agent_
+  // Needed methods:
+  // * LoadNavigationErrorPage
   render_view_->didFinishResourceLoad(frame, identifier);
 }
 
 void RenderFrameImpl::didFailResourceLoad(WebKit::WebFrame* frame,
                                           unsigned identifier,
                                           const WebKit::WebURLError& error) {
-  render_view_->didFailResourceLoad(frame, identifier, error);
+  // Ignore
 }
 
 void RenderFrameImpl::didLoadResourceFromMemoryCache(
     WebKit::WebFrame* frame,
     const WebKit::WebURLRequest& request,
     const WebKit::WebURLResponse& response) {
-  render_view_->didLoadResourceFromMemoryCache(frame, request, response);
+  // 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(),
+      url,
+      response.securityInfo(),
+      request.httpMethod().utf8(),
+      response.mimeType().utf8(),
+      ResourceType::FromTargetType(request.targetType())));
 }
 
 void RenderFrameImpl::didDisplayInsecureContent(WebKit::WebFrame* frame) {
-  render_view_->didDisplayInsecureContent(frame);
+  Send(new ViewHostMsg_DidDisplayInsecureContent(GetRoutingID()));
 }
 
 void RenderFrameImpl::didRunInsecureContent(
     WebKit::WebFrame* frame,
     const WebKit::WebSecurityOrigin& origin,
     const WebKit::WebURL& target) {
-  render_view_->didRunInsecureContent(frame, origin, target);
+  Send(new ViewHostMsg_DidRunInsecureContent(
+      GetRoutingID(),
+      origin.toString().utf8(),
+      target));
 }
 
 void RenderFrameImpl::didExhaustMemoryAvailableForScript(
     WebKit::WebFrame* frame) {
-  render_view_->didExhaustMemoryAvailableForScript(frame);
+  Send(new ViewHostMsg_JSOutOfMemory(GetRoutingID()));
 }
 
 void RenderFrameImpl::didCreateScriptContext(WebKit::WebFrame* frame,
                                              v8::Handle<v8::Context> context,
                                              int extension_group,
                                              int world_id) {
-  render_view_->didCreateScriptContext(
+  GetContentClient()->renderer()->DidCreateScriptContext(
       frame, context, extension_group, world_id);
 }
 
 void RenderFrameImpl::willReleaseScriptContext(WebKit::WebFrame* frame,
                                                v8::Handle<v8::Context> context,
                                                int world_id) {
-  render_view_->willReleaseScriptContext(frame, context, world_id);
+  GetContentClient()->renderer()->WillReleaseScriptContext(
+      frame, context, world_id);
 }
 
 void RenderFrameImpl::didFirstVisuallyNonEmptyLayout(WebKit::WebFrame* frame) {
@@ -321,28 +745,48 @@ void RenderFrameImpl::didFirstVisuallyNonEmptyLayout(WebKit::WebFrame* frame) {
 
 void RenderFrameImpl::didChangeContentsSize(WebKit::WebFrame* frame,
                                             const WebKit::WebSize& size) {
+  // TODO(nasko): Move implementation here. Needed state:
+  // * cached_has_main_frame_horizontal_scrollbar_
+  // * cached_has_main_frame_vertical_scrollbar_
   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) {
-  render_view_->willInsertBody(frame);
+  if (!frame->parent())
+    Send(new ViewHostMsg_WillInsertBody(GetRoutingID()));
 }
 
 void RenderFrameImpl::reportFindInPageMatchCount(int request_id,
                                                  int count,
                                                  bool final_update) {
-  render_view_->reportFindInPageMatchCount(request_id, count, final_update);
-}
-
-void RenderFrameImpl::reportFindInPageSelection(int request_id,
-                                                int active_match_ordinal,
-                                                const WebKit::WebRect& sel) {
-  render_view_->reportFindInPageSelection(
-      request_id, active_match_ordinal, sel);
+  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));
+}
+
+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));
 }
 
 void RenderFrameImpl::openFileSystem(
@@ -351,21 +795,56 @@ void RenderFrameImpl::openFileSystem(
     long long size,
     bool create,
     WebKit::WebFileSystemCallbacks* callbacks) {
-  render_view_->openFileSystem(frame, type, size, create, callbacks);
+  DCHECK(callbacks);
+
+  WebSecurityOrigin origin = frame->document().securityOrigin();
+  if (origin.isUnique()) {
+    // Unique origins cannot store persistent state.
+    callbacks->didFail(WebKit::WebFileErrorAbort);
+    return;
+  }
+
+  ChildThread::current()->file_system_dispatcher()->OpenFileSystem(
+      GURL(origin.toString()), static_cast<fileapi::FileSystemType>(type),
+      size, create,
+      base::Bind(&OpenFileSystemCallbackAdapter, callbacks),
+      base::Bind(&FileStatusCallbackAdapter, callbacks));
 }
 
 void RenderFrameImpl::deleteFileSystem(
     WebKit::WebFrame* frame,
     WebKit::WebFileSystemType type,
     WebKit::WebFileSystemCallbacks* callbacks) {
-  render_view_->deleteFileSystem(frame, type, callbacks);
+  DCHECK(callbacks);
+
+  WebSecurityOrigin origin = frame->document().securityOrigin();
+  if (origin.isUnique()) {
+    // Unique origins cannot store persistent state.
+    callbacks->didSucceed();
+    return;
+  }
+
+  ChildThread::current()->file_system_dispatcher()->DeleteFileSystem(
+      GURL(origin.toString()),
+      static_cast<fileapi::FileSystemType>(type),
+      base::Bind(&FileStatusCallbackAdapter, callbacks));
 }
 
 void RenderFrameImpl::queryStorageUsageAndQuota(
     WebKit::WebFrame* frame,
     WebKit::WebStorageQuotaType type,
     WebKit::WebStorageQuotaCallbacks* callbacks) {
-  render_view_->queryStorageUsageAndQuota(frame, type, 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()->QueryStorageUsageAndQuota(
+      GURL(origin.toString()),
+      static_cast<quota::StorageType>(type),
+      QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(callbacks));
 }
 
 void RenderFrameImpl::requestStorageQuota(
@@ -373,18 +852,30 @@ void RenderFrameImpl::requestStorageQuota(
     WebKit::WebStorageQuotaType type,
     unsigned long long requested_size,
     WebKit::WebStorageQuotaCallbacks* callbacks) {
-  render_view_->requestStorageQuota(frame, type, requested_size, 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()),
+      static_cast<quota::StorageType>(type), requested_size,
+      QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(callbacks));
 }
 
 void RenderFrameImpl::willOpenSocketStream(
     WebKit::WebSocketStreamHandle* handle) {
-  render_view_->willOpenSocketStream(handle);
+  SocketStreamHandleData::AddToHandle(handle, GetRoutingID());
 }
 
 void RenderFrameImpl::willStartUsingPeerConnectionHandler(
     WebKit::WebFrame* frame,
     WebKit::WebRTCPeerConnectionHandler* handler) {
-  render_view_->willStartUsingPeerConnectionHandler(frame, handler);
+#if defined(ENABLE_WEBRTC)
+  static_cast<RTCPeerConnectionHandler*>(handler)->associateWithFrame(frame);
+#endif
 }
 
 bool RenderFrameImpl::willCheckAndDispatchMessageEvent(
@@ -392,6 +883,8 @@ bool RenderFrameImpl::willCheckAndDispatchMessageEvent(
     WebKit::WebFrame* targetFrame,
     WebKit::WebSecurityOrigin targetOrigin,
     WebKit::WebDOMMessageEvent event) {
+  // TODO(nasko): Move implementation here. Needed state:
+  // * is_swapped_out_
   return render_view_->willCheckAndDispatchMessageEvent(
       sourceFrame, targetFrame, targetOrigin, event);
 }
@@ -399,20 +892,53 @@ bool RenderFrameImpl::willCheckAndDispatchMessageEvent(
 WebKit::WebString RenderFrameImpl::userAgentOverride(
     WebKit::WebFrame* frame,
     const WebKit::WebURL& url) {
-  return render_view_->userAgentOverride(frame, url);
+  if (!render_view_->webview() || !render_view_->webview()->mainFrame() ||
+      render_view_->renderer_preferences_.user_agent_override.empty()) {
+    return WebKit::WebString();
+  }
+
+  // If we're in the middle of committing a load, the data source we need
+  // will still be provisional.
+  WebFrame* main_frame = render_view_->webview()->mainFrame();
+  WebDataSource* data_source = NULL;
+  if (main_frame->provisionalDataSource())
+    data_source = main_frame->provisionalDataSource();
+  else
+    data_source = main_frame->dataSource();
+
+  InternalDocumentStateData* internal_data = data_source ?
+      InternalDocumentStateData::FromDataSource(data_source) : NULL;
+  if (internal_data && internal_data->is_overriding_user_agent())
+    return WebString::fromUTF8(
+        render_view_->renderer_preferences_.user_agent_override);
+  return WebKit::WebString();
 }
 
 WebKit::WebString RenderFrameImpl::doNotTrackValue(WebKit::WebFrame* frame) {
-  return render_view_->doNotTrackValue(frame);
+  if (render_view_->renderer_preferences_.enable_do_not_track)
+    return WebString::fromUTF8("1");
+  return WebString();
 }
 
 bool RenderFrameImpl::allowWebGL(WebKit::WebFrame* frame, bool default_value) {
-  return render_view_->allowWebGL(frame, default_value);
+  if (!default_value)
+    return false;
+
+  bool blocked = true;
+  Send(new ViewHostMsg_Are3DAPIsBlocked(
+      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) {
-  render_view_->didLoseWebGLContext(frame, arb_robustness_status_code);
+  Send(new ViewHostMsg_DidLose3DContext(
+      GURL(frame->top()->document().securityOrigin().toString()),
+      THREE_D_API_TYPE_WEBGL,
+      arb_robustness_status_code));
 }
 
 }  // namespace content
diff --git a/content/renderer/render_frame_impl.h b/content/renderer/render_frame_impl.h
index b8e75da..e108edd 100644
--- a/content/renderer/render_frame_impl.h
+++ b/content/renderer/render_frame_impl.h
@@ -201,7 +201,7 @@ class CONTENT_EXPORT RenderFrameImpl
                                    int arb_robustness_status_code);
 
   // RenderFrameImpl methods
-  int routing_id() { return routing_id_; }
+  int GetRoutingID() const;
 
  protected:
   RenderFrameImpl(RenderViewImpl* render_view, int32 routing_id);
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index 288b405..fa39c07 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -414,7 +414,8 @@ static bool IsReload(const ViewMsg_Navigate_Params& params) {
           ViewMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL;
 }
 
-static WebReferrerPolicy GetReferrerPolicyFromRequest(
+// static
+WebReferrerPolicy RenderViewImpl::GetReferrerPolicyFromRequest(
     WebFrame* frame,
     const WebURLRequest& request) {
   return request.extraData() ?
@@ -422,7 +423,8 @@ static WebReferrerPolicy GetReferrerPolicyFromRequest(
       frame->document().referrerPolicy();
 }
 
-static WebURLResponseExtraDataImpl* GetExtraDataFromResponse(
+// static
+WebURLResponseExtraDataImpl* RenderViewImpl::GetExtraDataFromResponse(
     const WebURLResponse& response) {
   return static_cast<WebURLResponseExtraDataImpl*>(
       response.extraData());
@@ -2819,57 +2821,15 @@ void RenderViewImpl::didHandleGestureEvent(
 
 WebKit::WebPlugin* RenderViewImpl::createPlugin(WebFrame* frame,
                                                 const WebPluginParams& params) {
-  WebKit::WebPlugin* plugin = NULL;
-  if (GetContentClient()->renderer()->OverrideCreatePlugin(
-          this, frame, params, &plugin)) {
-    return plugin;
-  }
-
-#if defined(ENABLE_PLUGINS)
-  if (UTF16ToASCII(params.mimeType) == kBrowserPluginMimeType) {
-    return GetBrowserPluginManager()->CreateBrowserPlugin(this, frame, params);
-  }
-
-  WebPluginInfo info;
-  std::string mime_type;
-  bool found = GetPluginInfo(params.url, frame->top()->document().url(),
-                             params.mimeType.utf8(), &info, &mime_type);
-  if (!found)
-    return NULL;
-
-  WebPluginParams params_to_use = params;
-  params_to_use.mimeType = WebString::fromUTF8(mime_type);
-  return CreatePlugin(frame, info, params_to_use);
-#else
+  NOTREACHED();
   return NULL;
-#endif  // defined(ENABLE_PLUGINS)
 }
 
 WebSharedWorker* RenderViewImpl::createSharedWorker(
     WebFrame* frame, const WebURL& url, const 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 = routing_id_;
-  params.route_id = MSG_ROUTING_NONE;
-  params.script_resource_appcache_id = 0;
-  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,
-                                    routing_id_);
-  }
+  NOTREACHED();
+  return NULL;
 }
 
 WebMediaPlayer* RenderViewImpl::createMediaPlayer(
@@ -2966,11 +2926,8 @@ WebMediaPlayer* RenderViewImpl::createMediaPlayer(
 
 WebApplicationCacheHost* RenderViewImpl::createApplicationCacheHost(
     WebFrame* frame, WebApplicationCacheHostClient* client) {
-  if (!frame || !frame->view())
-    return NULL;
-  return new RendererWebApplicationCacheHostImpl(
-      FromWebView(frame->view()), client,
-      RenderThreadImpl::current()->appcache_dispatcher()->backend_proxy());
+  NOTREACHED();
+  return NULL;
 }
 
 WebCookieJar* RenderViewImpl::cookieJar(WebFrame* frame) {
@@ -2985,8 +2942,7 @@ void RenderViewImpl::didAccessInitialDocument(WebFrame* frame) {
 }
 
 void RenderViewImpl::didCreateFrame(WebFrame* parent, WebFrame* child) {
-  Send(new ViewHostMsg_FrameAttached(routing_id_, parent->identifier(),
-      child->identifier(), UTF16ToUTF8(child->assignedName())));
+  NOTREACHED();
 }
 
 void RenderViewImpl::didDisownOpener(WebKit::WebFrame* frame) {
@@ -3002,13 +2958,6 @@ void RenderViewImpl::didDisownOpener(WebKit::WebFrame* frame) {
 }
 
 void RenderViewImpl::frameDetached(WebFrame* frame) {
-  int64 parent_frame_id = -1;
-  if (frame->parent())
-    parent_frame_id = frame->parent()->identifier();
-
-  Send(new ViewHostMsg_FrameDetached(routing_id_, parent_frame_id,
-      frame->identifier()));
-
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, FrameDetached(frame));
 }
 
@@ -3018,19 +2967,13 @@ void RenderViewImpl::willClose(WebFrame* frame) {
 
 void RenderViewImpl::didChangeName(WebFrame* frame,
                                    const WebString& name)  {
-  if (!renderer_preferences_.report_frame_name_changes)
-    return;
-
-  Send(new ViewHostMsg_UpdateFrameName(routing_id_,
-                                       frame->identifier(),
-                                       !frame->parent(),
-                                       UTF16ToUTF8(name)));
+  NOTREACHED();
 }
 
 void RenderViewImpl::loadURLExternally(
     WebFrame* frame, const WebURLRequest& request,
     WebNavigationPolicy policy) {
-  loadURLExternally(frame, request, policy, WebString());
+  NOTREACHED();
 }
 
 void RenderViewImpl::Repaint(const gfx::Size& size) {
@@ -3056,15 +2999,7 @@ void RenderViewImpl::loadURLExternally(
     WebFrame* frame, const WebURLRequest& request,
     WebNavigationPolicy policy,
     const WebString& suggested_name) {
-  Referrer referrer(
-      GURL(request.httpHeaderField(WebString::fromUTF8("Referer"))),
-      GetReferrerPolicyFromRequest(frame, request));
-  if (policy == WebKit::WebNavigationPolicyDownload) {
-    Send(new ViewHostMsg_DownloadUrl(routing_id_, request.url(), referrer,
-                                     suggested_name));
-  } else {
-    OpenURL(frame, request.url(), referrer, policy);
-  }
+  NOTREACHED();
 }
 
 WebNavigationPolicy RenderViewImpl::decidePolicyForNavigation(
@@ -3290,11 +3225,8 @@ WebURLError RenderViewImpl::cannotHandleRequestError(
 
 WebURLError RenderViewImpl::cancelledError(
     WebFrame* frame, const WebURLRequest& request) {
-  WebURLError error;
-  error.domain = WebString::fromUTF8(net::kErrorDomain);
-  error.reason = net::ERR_ABORTED;
-  error.unreachableURL = request.url();
-  return error;
+  NOTREACHED();
+  return WebURLError();
 }
 
 void RenderViewImpl::unableToImplementPolicyWithError(
@@ -3304,53 +3236,11 @@ void RenderViewImpl::unableToImplementPolicyWithError(
 
 void RenderViewImpl::willSendSubmitEvent(WebKit::WebFrame* frame,
     const WebKit::WebFormElement& form) {
-  // Some login forms have onSubmit handlers that put a hash of the password
-  // into a hidden field and then clear the password. (Issue 28910.)
-  // This method gets called before any of those handlers run, so save away
-  // a copy of the password in case it gets lost.
-  DocumentState* document_state =
-      DocumentState::FromDataSource(frame->dataSource());
-  document_state->set_password_form_data(CreatePasswordForm(form));
+  NOTREACHED();
 }
 
 void RenderViewImpl::willSubmitForm(WebFrame* frame,
                                     const WebFormElement& form) {
-  DocumentState* document_state =
-      DocumentState::FromDataSource(frame->provisionalDataSource());
-  NavigationState* navigation_state = document_state->navigation_state();
-  InternalDocumentStateData* internal_data =
-      InternalDocumentStateData::FromDocumentState(document_state);
-
-  if (PageTransitionCoreTypeIs(navigation_state->transition_type(),
-                               PAGE_TRANSITION_LINK)) {
-    navigation_state->set_transition_type(PAGE_TRANSITION_FORM_SUBMIT);
-  }
-
-  // Save these to be processed when the ensuing navigation is committed.
-  WebSearchableFormData web_searchable_form_data(form);
-  internal_data->set_searchable_form_url(web_searchable_form_data.url());
-  internal_data->set_searchable_form_encoding(
-      web_searchable_form_data.encoding().utf8());
-  scoped_ptr<PasswordForm> password_form_data =
-      CreatePasswordForm(form);
-
-  // In order to save the password that the user actually typed and not one
-  // that may have gotten transformed by the site prior to submit, recover it
-  // from the form contents already stored by |willSendSubmitEvent| into the
-  // dataSource's NavigationState (as opposed to the provisionalDataSource's,
-  // which is what we're storing into now.)
-  if (password_form_data) {
-    DocumentState* old_document_state =
-        DocumentState::FromDataSource(frame->dataSource());
-    if (old_document_state) {
-      PasswordForm* old_form_data = old_document_state->password_form_data();
-      if (old_form_data && old_form_data->action == password_form_data->action)
-        password_form_data->password_value = old_form_data->password_value;
-    }
-  }
-
-  document_state->set_password_form_data(password_form_data.Pass());
-
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, WillSubmitForm(frame, form));
 }
@@ -3857,13 +3747,6 @@ void RenderViewImpl::didClearWindowObject(WebFrame* frame) {
 }
 
 void RenderViewImpl::didCreateDocumentElement(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) {
-    if (frame == webview()->mainFrame())
-      Send(new ViewHostMsg_DocumentAvailableInMainFrame(routing_id_));
-  }
-
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidCreateDocumentElement(frame));
 }
@@ -3991,145 +3874,12 @@ void RenderViewImpl::willSendRequest(WebFrame* frame,
                                      unsigned identifier,
                                      WebURLRequest& request,
                                      const WebURLResponse& redirect_response) {
-  // The request my be empty during tests.
-  if (request.url().isEmpty())
-    return;
-
-  WebFrame* top_frame = frame->top();
-  if (!top_frame)
-    top_frame = frame;
-  WebDataSource* provisional_data_source = top_frame->provisionalDataSource();
-  WebDataSource* top_data_source = top_frame->dataSource();
-  WebDataSource* data_source =
-      provisional_data_source ? provisional_data_source : top_data_source;
-
-  PageTransition transition_type = PAGE_TRANSITION_LINK;
-  DocumentState* document_state = DocumentState::FromDataSource(data_source);
-  DCHECK(document_state);
-  InternalDocumentStateData* internal_data =
-      InternalDocumentStateData::FromDocumentState(document_state);
-  NavigationState* navigation_state = document_state->navigation_state();
-  transition_type = navigation_state->transition_type();
-
-  GURL request_url(request.url());
-  GURL new_url;
-  if (GetContentClient()->renderer()->WillSendRequest(
-          frame,
-          transition_type,
-          request_url,
-          request.firstPartyForCookies(),
-          &new_url)) {
-    request.setURL(WebURL(new_url));
-  }
-
-  if (internal_data->is_cache_policy_override_set())
-    request.setCachePolicy(internal_data->cache_policy_override());
-
-  WebKit::WebReferrerPolicy referrer_policy;
-  if (internal_data->is_referrer_policy_set()) {
-    referrer_policy = internal_data->referrer_policy();
-    internal_data->clear_referrer_policy();
-  } else {
-    referrer_policy = frame->document().referrerPolicy();
-  }
-
-  // The request's extra data may indicate that we should set a custom user
-  // agent. This needs to be done here, after WebKit is through with setting the
-  // user agent on its own.
-  WebString custom_user_agent;
-  if (request.extraData()) {
-    webkit_glue::WebURLRequestExtraDataImpl* old_extra_data =
-        static_cast<webkit_glue::WebURLRequestExtraDataImpl*>(
-            request.extraData());
-    custom_user_agent = old_extra_data->custom_user_agent();
-
-    if (!custom_user_agent.isNull()) {
-      if (custom_user_agent.isEmpty())
-        request.clearHTTPHeaderField("User-Agent");
-      else
-        request.setHTTPHeaderField("User-Agent", custom_user_agent);
-    }
-  }
-
-  request.setExtraData(
-      new RequestExtraData(referrer_policy,
-                           custom_user_agent,
-                           (frame == top_frame),
-                           frame->identifier(),
-                           frame->parent() == top_frame,
-                           frame->parent() ? frame->parent()->identifier() : -1,
-                           navigation_state->allow_download(),
-                           transition_type,
-                           navigation_state->transferred_request_child_id(),
-                           navigation_state->transferred_request_request_id()));
-
-  DocumentState* top_document_state =
-      DocumentState::FromDataSource(top_data_source);
-  // TODO(gavinp): separate out prefetching and prerender field trials
-  // if the rel=prerender rel type is sticking around.
-  if (top_document_state &&
-      request.targetType() == WebURLRequest::TargetIsPrefetch)
-    top_document_state->set_was_prefetcher(true);
-
-  request.setRequestorID(routing_id_);
-  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()));
-    }
-  }
-
-  if (!renderer_preferences_.enable_referrers)
-    request.clearHTTPHeaderField("Referer");
+  NOTREACHED();
 }
 
 void RenderViewImpl::didReceiveResponse(
     WebFrame* frame, unsigned identifier, const WebURLResponse& response) {
-
-  // Only do this for responses that correspond to a provisional data source
-  // of the top-most frame.  If we have a provisional data source, then we
-  // can't have any sub-resources yet, so we know that this response must
-  // correspond to a frame load.
-  if (!frame->provisionalDataSource() || frame->parent())
-    return;
-
-  // If we are in view source mode, then just let the user see the source of
-  // the server's error page.
-  if (frame->isViewSourceModeEnabled())
-    return;
-
-  DocumentState* document_state =
-      DocumentState::FromDataSource(frame->provisionalDataSource());
-  int http_status_code = response.httpStatusCode();
-
-  // Record page load flags.
-  WebURLResponseExtraDataImpl* extra_data = GetExtraDataFromResponse(response);
-  if (extra_data) {
-    document_state->set_was_fetched_via_spdy(
-        extra_data->was_fetched_via_spdy());
-    document_state->set_was_npn_negotiated(
-        extra_data->was_npn_negotiated());
-    document_state->set_npn_negotiated_protocol(
-        extra_data->npn_negotiated_protocol());
-    document_state->set_was_alternate_protocol_available(
-        extra_data->was_alternate_protocol_available());
-    document_state->set_connection_info(
-        extra_data->connection_info());
-    document_state->set_was_fetched_via_proxy(
-        extra_data->was_fetched_via_proxy());
-  }
-  InternalDocumentStateData* internal_data =
-      InternalDocumentStateData::FromDocumentState(document_state);
-  internal_data->set_http_status_code(http_status_code);
-  // Whether or not the http status code actually corresponds to an error is
-  // only checked when the page is done loading, if |use_error_page| is
-  // still true.
-  internal_data->set_use_error_page(true);
+  NOTREACHED();
 }
 
 void RenderViewImpl::didFinishResourceLoad(
@@ -4188,54 +3938,33 @@ void RenderViewImpl::didFailResourceLoad(
 void RenderViewImpl::didLoadResourceFromMemoryCache(
     WebFrame* frame, const WebURLRequest& request,
     const WebURLResponse& response) {
-  // 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(
-      routing_id_,
-      url,
-      response.securityInfo(),
-      request.httpMethod().utf8(),
-      response.mimeType().utf8(),
-      ResourceType::FromTargetType(request.targetType())));
+  NOTREACHED();
 }
 
 void RenderViewImpl::didDisplayInsecureContent(WebFrame* frame) {
-  Send(new ViewHostMsg_DidDisplayInsecureContent(routing_id_));
+  NOTREACHED();
 }
 
 void RenderViewImpl::didRunInsecureContent(
     WebFrame* frame, const WebSecurityOrigin& origin, const WebURL& target) {
-  Send(new ViewHostMsg_DidRunInsecureContent(
-      routing_id_,
-      origin.toString().utf8(),
-      target));
+  NOTREACHED();
 }
 
 void RenderViewImpl::didExhaustMemoryAvailableForScript(WebFrame* frame) {
-  Send(new ViewHostMsg_JSOutOfMemory(routing_id_));
+  NOTREACHED();
 }
 
 void RenderViewImpl::didCreateScriptContext(WebFrame* frame,
                                             v8::Handle<v8::Context> context,
                                             int extension_group,
                                             int world_id) {
-  GetContentClient()->renderer()->DidCreateScriptContext(
-      frame, context, extension_group, world_id);
+  NOTREACHED();
 }
 
 void RenderViewImpl::willReleaseScriptContext(WebFrame* frame,
                                               v8::Handle<v8::Context> context,
                                               int world_id) {
-  GetContentClient()->renderer()->WillReleaseScriptContext(
-      frame, context, world_id);
+  NOTREACHED();
 }
 
 void RenderViewImpl::CheckPreferredSize() {
@@ -4337,9 +4066,7 @@ void RenderViewImpl::didChangeScrollOffset(WebFrame* frame) {
 }
 
 void RenderViewImpl::willInsertBody(WebKit::WebFrame* frame) {
-  if (!frame->parent()) {
-    Send(new ViewHostMsg_WillInsertBody(routing_id()));
-  }
+  NOTREACHED();
 }
 
 void RenderViewImpl::didFirstVisuallyNonEmptyLayout(WebFrame* frame) {
@@ -4361,7 +4088,8 @@ void RenderViewImpl::didFirstVisuallyNonEmptyLayout(WebFrame* frame) {
 
   if (bg_color != body_background_color_) {
     body_background_color_ = bg_color;
-    Send(new ViewHostMsg_DidChangeBodyBackgroundColor(routing_id_, bg_color));
+    Send(new ViewHostMsg_DidChangeBodyBackgroundColor(
+        GetRoutingID(), bg_color));
   }
 #endif
 }
@@ -4402,26 +4130,13 @@ bool RenderViewImpl::ShouldUpdateSelectionTextFromContextMenuParams(
 void RenderViewImpl::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 the search result over to the browser process.
-  SendFindReply(request_id,
-                count,
-                active_match_ordinal,
-                gfx::Rect(),
-                final_update);
+  NOTREACHED();
 }
 
 void RenderViewImpl::reportFindInPageSelection(int request_id,
                                                int active_match_ordinal,
                                                const WebRect& selection_rect) {
-  SendFindReply(request_id,
-                -1,
-                active_match_ordinal,
-                selection_rect,
-                false);
+  NOTREACHED();
 }
 
 void RenderViewImpl::openFileSystem(
@@ -4430,56 +4145,21 @@ void RenderViewImpl::openFileSystem(
     long long size,
     bool create,
     WebFileSystemCallbacks* callbacks) {
-  DCHECK(callbacks);
-
-  WebSecurityOrigin origin = frame->document().securityOrigin();
-  if (origin.isUnique()) {
-    // Unique origins cannot store persistent state.
-    callbacks->didFail(WebKit::WebFileErrorAbort);
-    return;
-  }
-
-  ChildThread::current()->file_system_dispatcher()->OpenFileSystem(
-      GURL(origin.toString()), static_cast<fileapi::FileSystemType>(type),
-      size, create,
-      base::Bind(&OpenFileSystemCallbackAdapter, callbacks),
-      base::Bind(&FileStatusCallbackAdapter, callbacks));
+  NOTREACHED();
 }
 
 void RenderViewImpl::deleteFileSystem(
     WebFrame* frame,
     WebKit::WebFileSystemType type ,
     WebFileSystemCallbacks* callbacks) {
-  DCHECK(callbacks);
-
-  WebSecurityOrigin origin = frame->document().securityOrigin();
-  if (origin.isUnique()) {
-    // Unique origins cannot store persistent state.
-    callbacks->didSucceed();
-    return;
-  }
-
-  ChildThread::current()->file_system_dispatcher()->DeleteFileSystem(
-      GURL(origin.toString()),
-      static_cast<fileapi::FileSystemType>(type),
-      base::Bind(&FileStatusCallbackAdapter, callbacks));
+  NOTREACHED();
 }
 
 void RenderViewImpl::queryStorageUsageAndQuota(
     WebFrame* frame,
     WebStorageQuotaType type,
     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()->QueryStorageUsageAndQuota(
-      GURL(origin.toString()),
-      static_cast<quota::StorageType>(type),
-      QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(callbacks));
+  NOTREACHED();
 }
 
 void RenderViewImpl::requestStorageQuota(
@@ -4487,17 +4167,7 @@ void RenderViewImpl::requestStorageQuota(
     WebStorageQuotaType type,
     unsigned long long requested_size,
     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(
-      routing_id(), GURL(origin.toString()),
-      static_cast<quota::StorageType>(type), requested_size,
-      QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(callbacks));
+  NOTREACHED();
 }
 
 bool RenderViewImpl::willCheckAndDispatchMessageEvent(
@@ -4528,14 +4198,12 @@ bool RenderViewImpl::willCheckAndDispatchMessageEvent(
 
 void RenderViewImpl::willOpenSocketStream(
     WebSocketStreamHandle* handle) {
-  SocketStreamHandleData::AddToHandle(handle, routing_id_);
+  NOTREACHED();
 }
 
 void RenderViewImpl::willStartUsingPeerConnectionHandler(
     WebKit::WebFrame* frame, WebKit::WebRTCPeerConnectionHandler* handler) {
-#if defined(ENABLE_WEBRTC)
-  static_cast<RTCPeerConnectionHandler*>(handler)->associateWithFrame(frame);
-#endif
+  NOTREACHED();
 }
 
 WebKit::WebString RenderViewImpl::acceptLanguages() {
@@ -4545,53 +4213,24 @@ WebKit::WebString RenderViewImpl::acceptLanguages() {
 WebKit::WebString RenderViewImpl::userAgentOverride(
     WebKit::WebFrame* frame,
     const WebKit::WebURL& url) {
-  if (!webview() || !webview()->mainFrame() ||
-      renderer_preferences_.user_agent_override.empty()) {
-    return WebKit::WebString();
-  }
-
-  // If we're in the middle of committing a load, the data source we need
-  // will still be provisional.
-  WebFrame* main_frame = webview()->mainFrame();
-  WebDataSource* data_source = NULL;
-  if (main_frame->provisionalDataSource())
-    data_source = main_frame->provisionalDataSource();
-  else
-    data_source = main_frame->dataSource();
-
-  InternalDocumentStateData* internal_data = data_source ?
-      InternalDocumentStateData::FromDataSource(data_source) : NULL;
-  if (internal_data && internal_data->is_overriding_user_agent())
-    return WebString::fromUTF8(renderer_preferences_.user_agent_override);
+  NOTREACHED();
   return WebKit::WebString();
 }
 
 WebString RenderViewImpl::doNotTrackValue(WebFrame* frame) {
-  if (renderer_preferences_.enable_do_not_track)
-    return WebString::fromUTF8("1");
-  return WebString();
+  NOTREACHED();
+  return WebKit::WebString();
 }
 
 bool RenderViewImpl::allowWebGL(WebFrame* frame, bool default_value) {
-  if (!default_value)
-    return false;
-
-  bool blocked = true;
-  Send(new ViewHostMsg_Are3DAPIsBlocked(
-      routing_id_,
-      GURL(frame->top()->document().securityOrigin().toString()),
-      THREE_D_API_TYPE_WEBGL,
-      &blocked));
-  return !blocked;
+  NOTREACHED();
+  return false;
 }
 
 void RenderViewImpl::didLoseWebGLContext(
     WebKit::WebFrame* frame,
     int arb_robustness_status_code) {
-  Send(new ViewHostMsg_DidLose3DContext(
-      GURL(frame->top()->document().securityOrigin().toString()),
-      THREE_D_API_TYPE_WEBGL,
-      arb_robustness_status_code));
+  NOTREACHED();
 }
 
 // WebKit::WebPageSerializerClient implementation ------------------------------
@@ -4763,7 +4402,7 @@ void RenderViewImpl::LoadURLExternally(
     WebKit::WebFrame* frame,
     const WebKit::WebURLRequest& request,
     WebKit::WebNavigationPolicy policy) {
-  loadURLExternally(frame, request, policy);
+  main_render_frame_->loadURLExternally(frame, request, policy);
 }
 
 void RenderViewImpl::DidPlay(WebKit::WebMediaPlayer* player) {
diff --git a/content/renderer/render_view_impl.h b/content/renderer/render_view_impl.h
index 6e0e87d0..0a4f135 100644
--- a/content/renderer/render_view_impl.h
+++ b/content/renderer/render_view_impl.h
@@ -132,6 +132,10 @@ class WebHitTestResult;
 #endif
 }
 
+namespace webkit_glue {
+class WebURLResponseExtraDataImpl;
+}
+
 namespace content {
 class BrowserPluginManager;
 class DeviceOrientationDispatcher;
@@ -826,6 +830,11 @@ class CONTENT_EXPORT RenderViewImpl
   friend class RendererAccessibilityTest;
   friend class RenderViewTest;
 
+  // TODO(nasko): Temporarily friend RenderFrameImpl, so we don't duplicate
+  // utility functions needed in both classes, while we move frame specific
+  // code away from this class.
+  friend class RenderFrameImpl;
+
   FRIEND_TEST_ALL_PREFIXES(ExternalPopupMenuRemoveTest, RemoveOnChange);
   FRIEND_TEST_ALL_PREFIXES(ExternalPopupMenuTest, NormalCase);
   FRIEND_TEST_ALL_PREFIXES(ExternalPopupMenuTest, ShowPopupThenNavigate);
@@ -876,6 +885,13 @@ class CONTENT_EXPORT RenderViewImpl
     CONNECTION_ERROR,
   };
 
+  static WebKit::WebReferrerPolicy GetReferrerPolicyFromRequest(
+      WebKit::WebFrame* frame,
+      const WebKit::WebURLRequest& request);
+
+  static webkit_glue::WebURLResponseExtraDataImpl* GetExtraDataFromResponse(
+      const WebKit::WebURLResponse& response);
+
   void UpdateURL(WebKit::WebFrame* frame);
   void UpdateTitle(WebKit::WebFrame* frame, const string16& title,
                    WebKit::WebTextDirection title_direction);
diff --git a/content/test/layouttest_support.cc b/content/test/layouttest_support.cc
index 2698330..3f1a0f6 100644
--- a/content/test/layouttest_support.cc
+++ b/content/test/layouttest_support.cc
@@ -61,6 +61,7 @@ RenderFrameImpl* CreateWebFrameTestProxy(
   WebTestProxyBase* base = static_cast<WebTestProxyBase*>(render_view_proxy);
   FrameProxy* render_frame_proxy = new FrameProxy(render_view, routing_id);
   render_frame_proxy->setBaseProxy(base);
+  render_frame_proxy->setVersion(2);
 
   return render_frame_proxy;
 }