chrome.loadTimes() shouldn't be affected by in-document navigation.

content/renderer/render_view_impl.cc

 // Copyright (c) 2011 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_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 24 matching lines @@
 #include "content/common/pepper_messages.h"
 #include "content/common/pepper_plugin_registry.h"
 #include "content/common/quota_dispatcher.h"
 #include "content/common/request_extra_data.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/bindings_policy.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/render_view_observer.h"
 #include "content/public/renderer/render_view_visitor.h"
 #include "content/renderer/device_orientation_dispatcher.h"
 #include "content/renderer/devtools_agent.h"
 #include "content/renderer/external_popup_menu.h"
 #include "content/renderer/geolocation_dispatcher.h"
 #include "content/renderer/gpu/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/renderer/intents_dispatcher.h"
 #include "content/renderer/java/java_bridge_dispatcher.h"
@@ skipping 175 matching lines @@
 using WebKit::WebURLResponse;
 using WebKit::WebVector;
 using WebKit::WebView;
 using WebKit::WebWidget;
 using WebKit::WebWindowFeatures;
 using WebKit::WebWorker;
 using WebKit::WebWorkerClient;
 using appcache::WebApplicationCacheHostImpl;
 using base::Time;
 using base::TimeDelta;
+using content::DocumentState;
 using content::NavigationState;
 using content::RenderThread;
 using content::RenderViewObserver;
 using content::RenderViewVisitor;
 using content::V8ValueConverter;
 using webkit_glue::AltErrorPageResourceFetcher;
 using webkit_glue::FormField;
 using webkit_glue::PasswordForm;
 using webkit_glue::PasswordFormDomManager;
 using webkit_glue::ResourceFetcher;
@@ skipping 24 matching lines @@
 static const float kScalingIncrementForGesture = 0.01f;
 
 static void GetRedirectChain(WebDataSource* ds, std::vector<GURL>* result) {
   WebVector<WebURL> urls;
   ds->redirectChain(urls);
   result->reserve(urls.size());
   for (size_t i = 0; i < urls.size(); ++i)
     result->push_back(urls[i]);
 }
 
-// If |data_source| is non-null and has a NavigationState associated with it,
+// If |data_source| is non-null and has a DocumentState associated with it,
 // the AltErrorPageResourceFetcher is reset.
 static void StopAltErrorPageFetcher(WebDataSource* data_source) {
   if (data_source) {
-    NavigationState* state = NavigationState::FromDataSource(data_source);
-    if (state)
-      state->set_alt_error_page_fetcher(NULL);
+    DocumentState* document_state = DocumentState::FromDataSource(data_source);
+    if (document_state)
+      document_state->set_alt_error_page_fetcher(NULL);
   }
 }
 
+static bool IsReload(const ViewMsg_Navigate_Params& params) {
+  return
+      params.navigation_type == ViewMsg_Navigate_Type::RELOAD ||
+      params.navigation_type == ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 int32 RenderViewImpl::next_page_id_ = 1;
 
 struct RenderViewImpl::PendingFileChooser {
   PendingFileChooser(const ViewHostMsg_RunFileChooser_Params& p,
                      WebFileChooserCompletion* c)
       : params(p),
         completion(c) {
   }
@@ skipping 389 matching lines @@
 
   return handled;
 }
 
 void RenderViewImpl::OnNavigate(const ViewMsg_Navigate_Params& params) {
   if (!webview())
     return;
 
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, Navigate(params.url));
 
-  bool is_reload =
-      params.navigation_type == ViewMsg_Navigate_Type::RELOAD ||
-      params.navigation_type == ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE;
+  bool is_reload = IsReload(params);
 
   // If this is a stale back/forward (due to a recent navigation the browser
   // didn't know about), ignore it.
   if (IsBackForwardToStaleEntry(params, is_reload))
     return;
 
   // Swap this renderer back in if necessary.
   if (is_swapped_out_)
     SetSwappedOut(false);
 
   history_list_offset_ = params.current_history_list_offset;
   history_list_length_ = params.current_history_list_length;
   if (history_list_length_ >= 0)
     history_page_ids_.resize(history_list_length_, -1);
   if (params.pending_history_list_offset >= 0 &&
       params.pending_history_list_offset < history_list_length_)
     history_page_ids_[params.pending_history_list_offset] = params.page_id;
 
   content::GetContentClient()->SetActiveURL(params.url);
 
   WebFrame* main_frame = webview()->mainFrame();
   if (is_reload && main_frame->currentHistoryItem().isNull()) {
     // We cannot reload if we do not have any history state.  This happens, for
     // example, when recovering from a crash.  Our workaround here is a bit of
     // a hack since it means that reload after a crashed tab does not cause an
     // end-to-end cache validation.
     is_reload = false;
   }
 
-  // A navigation resulting from loading a javascript URL should not be treated
-  // as a browser initiated event.  Instead, we want it to look as if the page
-  // initiated any load resulting from JS execution.
-  if (!params.url.SchemeIs(chrome::kJavaScriptScheme)) {
-    NavigationState* state = NavigationState::CreateBrowserInitiated(
-        params.page_id,
-        params.pending_history_list_offset,
-        params.transition,
-        params.request_time);
-    if (params.navigation_type == ViewMsg_Navigate_Type::RESTORE) {
-      // We're doing a load of a page that was restored from the last session.
-      // By default this prefers the cache over loading (LOAD_PREFERRING_CACHE)
-      // which can result in stale data for pages that are set to expire. We
-      // explicitly override that by setting the policy here so that as
-      // necessary we load from the network.
-      state->set_cache_policy_override(WebURLRequest::UseProtocolCachePolicy);
-    }
-    pending_navigation_state_.reset(state);
-  }
-
-  NavigationState* navigation_state = pending_navigation_state_.get();
-
-  if (navigation_state) {
-    // New loads need to reset the error page fetcher. Otherwise if there is an
-    // outstanding error page fetcher it may complete and clobber the current
-    // page load.
-    navigation_state->set_alt_error_page_fetcher(NULL);
-  }
+  pending_navigation_params_.reset(new ViewMsg_Navigate_Params);
+  *pending_navigation_params_.get() = params;
 
   // If we are reloading, then WebKit will use the history state of the current
   // page, so we should just ignore any given history state.  Otherwise, if we
   // have history state, then we need to navigate to it, which corresponds to a
   // back/forward navigation event.
   if (is_reload) {
-    if (navigation_state)
-      navigation_state->set_load_type(NavigationState::RELOAD);
     bool ignore_cache = (params.navigation_type ==
                              ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE);
     main_frame->reload(ignore_cache);
   } else if (!params.state.empty()) {
     // We must know the page ID of the page we are navigating back to.
     DCHECK_NE(params.page_id, -1);
-    if (navigation_state)
-      navigation_state->set_load_type(NavigationState::HISTORY_LOAD);
     main_frame->loadHistoryItem(
         webkit_glue::HistoryItemFromString(params.state));
   } else {
     // Navigate to the given URL.
     WebURLRequest request(params.url);
 
     // A session history navigation should have been accompanied by state.
     DCHECK_EQ(params.page_id, -1);
 
     if (main_frame->isViewSourceModeEnabled())
@@ skipping 10 matching lines @@
 
     if (!params.extra_headers.empty()) {
       for (net::HttpUtil::HeadersIterator i(params.extra_headers.begin(),
                                             params.extra_headers.end(), "\n");
            i.GetNext(); ) {
         request.addHTTPHeaderField(WebString::fromUTF8(i.name()),
                                    WebString::fromUTF8(i.values()));
       }
     }
 
-    if (navigation_state)
-      navigation_state->set_load_type(NavigationState::NORMAL_LOAD);
     main_frame->loadRequest(request);
   }
 
   // In case LoadRequest failed before DidCreateDataSource was called.
-  pending_navigation_state_.reset();
+  pending_navigation_params_.reset();
 }
 
 bool RenderViewImpl::IsBackForwardToStaleEntry(
     const ViewMsg_Navigate_Params& params,
     bool is_reload) {
   // Make sure this isn't a back/forward to an entry we have already cropped
   // or replaced from our history, before the browser knew about it.  If so,
   // a new navigation has committed in the mean time, and we can ignore this.
   bool is_back_forward = !is_reload && !params.state.empty();
 
@@ skipping 219 matching lines @@
 
 // Tell the embedding application that the URL of the active page has changed
 void RenderViewImpl::UpdateURL(WebFrame* frame) {
   WebDataSource* ds = frame->dataSource();
   DCHECK(ds);
 
   const WebURLRequest& request = ds->request();
   const WebURLRequest& original_request = ds->originalRequest();
   const WebURLResponse& response = ds->response();
 
-  NavigationState* navigation_state = NavigationState::FromDataSource(ds);
-  DCHECK(navigation_state);
+  DocumentState* document_state = DocumentState::FromDataSource(ds);
+  NavigationState* navigation_state = document_state->navigation_state();
 
   ViewHostMsg_FrameNavigate_Params params;
   params.http_status_code = response.httpStatusCode();
   params.is_post = false;
   params.page_id = page_id_;
   params.frame_id = frame->identifier();
   params.socket_address.set_host(response.remoteIPAddress().utf8());
   params.socket_address.set_port(response.remotePort());
   params.was_fetched_via_proxy = response.wasFetchedViaProxy();
   params.was_within_same_page = navigation_state->was_within_same_page();
-  if (!navigation_state->security_info().empty()) {
+  if (!document_state->security_info().empty()) {
     // SSL state specified in the request takes precedence over the one in the
     // response.
     // So far this is only intended for error pages that are not expected to be
     // over ssl, so we should not get any clash.
     DCHECK(response.securityInfo().isEmpty());
-    params.security_info = navigation_state->security_info();
+    params.security_info = document_state->security_info();
   } else {
     params.security_info = response.securityInfo();
   }
 
   // Set the URL to be displayed in the browser UI to the user.
   if (ds->hasUnreachableURL()) {
     params.url = ds->unreachableURL();
   } else {
     params.url = request.url();
   }
 
   GetRedirectChain(ds, &params.redirects);
   params.should_update_history = !ds->hasUnreachableURL() &&
       !response.isMultipartPayload() && (response.httpStatusCode() != 404);
 
-  params.searchable_form_url = navigation_state->searchable_form_url();
+  params.searchable_form_url = document_state->searchable_form_url();
   params.searchable_form_encoding =
-      navigation_state->searchable_form_encoding();
+      document_state->searchable_form_encoding();
 
   const PasswordForm* password_form_data =
-      navigation_state->password_form_data();
+      document_state->password_form_data();
   if (password_form_data)
     params.password_form = *password_form_data;
 
   params.gesture = navigation_gesture_;
   navigation_gesture_ = NavigationGestureUnknown;
 
   // Make navigation state a part of the FrameNavigate message so that commited
   // entry had it at all times.
   const WebHistoryItem& item = frame->currentHistoryItem();
   if (!item.isNull()) {
@@ skipping 900 matching lines @@
   }
 
   // Webkit is asking whether to navigate to a new URL.
   // This is fine normally, except if we're showing UI from one security
   // context and they're trying to navigate to a different context.
   const GURL& url = request.url();
 
   // A content initiated navigation may have originated from a link-click,
   // script, drag-n-drop operation, etc.
   bool is_content_initiated =
-      NavigationState::FromDataSource(frame->provisionalDataSource())->
-          is_content_initiated();
+      DocumentState::FromDataSource(frame->provisionalDataSource())->
+          navigation_state()->is_content_initiated();
 
   // Experimental:
   // If --enable-strict-site-isolation is enabled, send all top-level
   // navigations to the browser to let it swap processes when crossing site
   // boundaries.  This is currently expected to break some script calls and
   // navigations, such as form submissions.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (!frame->parent() && (is_content_initiated || is_redirect) &&
       command_line.HasSwitch(switches::kEnableStrictSiteIsolation)) {
     GURL referrer(request.httpHeaderField(WebString::fromUTF8("Referer")));
@@ skipping 158 matching lines @@
     WebFrame*, const WebURLError&) {
   NOTREACHED();  // Since we said we can handle all requests.
 }
 
 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.
-  NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->dataSource());
-  navigation_state->set_password_form_data(
+  DocumentState* document_state =
+      DocumentState::FromDataSource(frame->dataSource());
+  document_state->set_password_form_data(
       PasswordFormDomManager::CreatePasswordForm(form));
 }
 
 void RenderViewImpl::willSubmitForm(WebFrame* frame,
                                     const WebFormElement& form) {
-  NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->provisionalDataSource());
+  DocumentState* document_state =
+      DocumentState::FromDataSource(frame->provisionalDataSource());
+  NavigationState* navigation_state = document_state->navigation_state();
 
   if (navigation_state->transition_type() == content::PAGE_TRANSITION_LINK)
     navigation_state->set_transition_type(content::PAGE_TRANSITION_FORM_SUBMIT);
 
   // Save these to be processed when the ensuing navigation is committed.
   WebSearchableFormData web_searchable_form_data(form);
-  navigation_state->set_searchable_form_url(web_searchable_form_data.url());
-  navigation_state->set_searchable_form_encoding(
+  document_state->set_searchable_form_url(web_searchable_form_data.url());
+  document_state->set_searchable_form_encoding(
       web_searchable_form_data.encoding().utf8());
   PasswordForm* password_form_data =
       PasswordFormDomManager::CreatePasswordForm(form);
-  navigation_state->set_password_form_data(password_form_data);
+  document_state->set_password_form_data(password_form_data);
 
   // 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) {
-    NavigationState* old_navigation_state =
-        NavigationState::FromDataSource(frame->dataSource());
-    if (old_navigation_state) {
-      PasswordForm* old_form_data = old_navigation_state->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;
     }
   }
 
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, WillSubmitForm(frame, form));
 }
 
 void RenderViewImpl::willPerformClientRedirect(
@@ skipping 11 matching lines @@
 
 void RenderViewImpl::didCompleteClientRedirect(
     WebFrame* frame, const WebURL& from) {
   if (!frame->parent())
     completed_client_redirect_src_ = from;
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidCompleteClientRedirect(frame, from));
 }
 
 void RenderViewImpl::didCreateDataSource(WebFrame* frame, WebDataSource* ds) {
+  DocumentState* document_state = DocumentState::FromDataSource(ds);
+  if (!document_state) {
+    document_state = new DocumentState;
+    ds->setExtraData(document_state);
+  }
+
   // The rest of RenderView assumes that a WebDataSource will always have a
   // non-null NavigationState.
-  bool content_initiated = !pending_navigation_state_.get();
-  NavigationState* state = content_initiated ?
-      NavigationState::CreateContentInitiated() :
-      pending_navigation_state_.release();
+  bool content_initiated = !pending_navigation_params_.get();
+  if (content_initiated)
+    document_state->set_navigation_state(
+        NavigationState::CreateContentInitiated());
+  else
+    PopulateStateFromPendingNavigationParams(document_state);
 
-  // NavigationState::referred_by_prefetcher_ is true if we are
+  // DocumentState::referred_by_prefetcher_ is true if we are
   // navigating from a page that used prefetching using a link on that
   // page.  We are early enough in the request process here that we
-  // can still see the NavigationState of the previous page and set
+  // can still see the DocumentState of the previous page and set
   // this value appropriately.
   // TODO(gavinp): catch the important case of navigation in a new
   // renderer process.
   if (webview()) {
     if (WebFrame* old_frame = webview()->mainFrame()) {
       const WebURLRequest& original_request = ds->originalRequest();
       const GURL referrer(
           original_request.httpHeaderField(WebString::fromUTF8("Referer")));
       if (!referrer.is_empty() &&
-          NavigationState::FromDataSource(
+          DocumentState::FromDataSource(
               old_frame->dataSource())->was_prefetcher()) {
         for (;old_frame;old_frame = old_frame->traverseNext(false)) {
           WebDataSource* old_frame_ds = old_frame->dataSource();
           if (old_frame_ds && referrer == GURL(old_frame_ds->request().url())) {
-            state->set_was_referred_by_prefetcher(true);
+            document_state->set_was_referred_by_prefetcher(true);
             break;
           }
         }
       }
     }
   }
 
   if (content_initiated) {
     const WebURLRequest& request = ds->request();
     switch (request.cachePolicy()) {
       case WebURLRequest::UseProtocolCachePolicy:  // normal load.
-        state->set_load_type(NavigationState::LINK_LOAD_NORMAL);
+        document_state->set_load_type(DocumentState::LINK_LOAD_NORMAL);
         break;
       case WebURLRequest::ReloadIgnoringCacheData:  // reload.
-        state->set_load_type(NavigationState::LINK_LOAD_RELOAD);
+        document_state->set_load_type(DocumentState::LINK_LOAD_RELOAD);
         break;
       case WebURLRequest::ReturnCacheDataElseLoad:  // allow stale data.
-        state->set_load_type(NavigationState::LINK_LOAD_CACHE_STALE_OK);
+        document_state->set_load_type(
+            DocumentState::LINK_LOAD_CACHE_STALE_OK);
         break;
       case WebURLRequest::ReturnCacheDataDontLoad:  // Don't re-post.
-        state->set_load_type(NavigationState::LINK_LOAD_CACHE_ONLY);
+        document_state->set_load_type(DocumentState::LINK_LOAD_CACHE_ONLY);
         break;
     }
   }
 
-  ds->setExtraData(state);
-
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidCreateDataSource(frame, ds));
 }
 
+void RenderViewImpl::PopulateStateFromPendingNavigationParams(
+    DocumentState* document_state) {
+  const ViewMsg_Navigate_Params& params = *pending_navigation_params_.get();
+
+  if (document_state->request_time().is_null())
+    document_state->set_request_time(params.request_time);
+
+  // A navigation resulting from loading a javascript URL should not be treated
+  // as a browser initiated event.  Instead, we want it to look as if the page
+  // initiated any load resulting from JS execution.
+  if (!params.url.SchemeIs(chrome::kJavaScriptScheme)) {
+    NavigationState* navigation_state = NavigationState::CreateBrowserInitiated(
+        params.page_id,
+        params.pending_history_list_offset,
+        params.transition);
+    if (params.navigation_type == ViewMsg_Navigate_Type::RESTORE) {
+      // We're doing a load of a page that was restored from the last session.
+      // By default this prefers the cache over loading (LOAD_PREFERRING_CACHE)
+      // which can result in stale data for pages that are set to expire. We
+      // explicitly override that by setting the policy here so that as
+      // necessary we load from the network.
+      document_state->set_cache_policy_override(
+          WebURLRequest::UseProtocolCachePolicy);
+    }
+    document_state->set_navigation_state(navigation_state);
+  } else {
+    document_state->set_navigation_state(
+        NavigationState::CreateContentInitiated());
+  }
+
+  if (IsReload(params))
+    document_state->set_load_type(DocumentState::RELOAD);
+  else if (!params.state.empty())
+    document_state->set_load_type(DocumentState::HISTORY_LOAD);
+  else
+    document_state->set_load_type(DocumentState::NORMAL_LOAD);
+
+  pending_navigation_params_.reset();
+}
+
 void RenderViewImpl::didStartProvisionalLoad(WebFrame* frame) {
   WebDataSource* ds = frame->provisionalDataSource();
-  NavigationState* navigation_state = NavigationState::FromDataSource(ds);
+  DocumentState* document_state = DocumentState::FromDataSource(ds);
 
   // Update the request time if WebKit has better knowledge of it.
-  if (navigation_state->request_time().is_null()) {
+  if (document_state->request_time().is_null()) {
     double event_time = ds->triggeringEventTime();
     if (event_time != 0.0)
-      navigation_state->set_request_time(Time::FromDoubleT(event_time));
+      document_state->set_request_time(Time::FromDoubleT(event_time));
   }
 
   // Start time is only set after request time.
-  navigation_state->set_start_load_time(Time::Now());
+  document_state->set_start_load_time(Time::Now());
 
   bool is_top_most = !frame->parent();
   if (is_top_most) {
     navigation_gesture_ = frame->isProcessingUserGesture() ?
         NavigationGestureUser : NavigationGestureAuto;
 
     // Make sure redirect tracking state is clear for the new load.
     completed_client_redirect_src_ = GURL();
   } else if (frame->parent()->isLoading()) {
     // Take note of AUTO_SUBFRAME loads here, so that we can know how to
     // load an error page.  See didFailProvisionalLoad.
-    navigation_state->set_transition_type(
+    document_state->navigation_state()->set_transition_type(
         content::PAGE_TRANSITION_AUTO_SUBFRAME);
   }
 
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidStartProvisionalLoad(frame));
 
   Send(new ViewHostMsg_DidStartProvisionalLoadForFrame(
        routing_id_, frame->identifier(), is_top_most, GetOpenerUrl(),
        ds->request().url()));
 }
@@ skipping 52 matching lines @@
       routing_id_, params));
 
   // Don't display an error page if this is simply a cancelled load.  Aside
   // from being dumb, WebCore doesn't expect it and it will cause a crash.
   if (error.reason == net::ERR_ABORTED)
     return;
 
   // Make sure we never show errors in view source mode.
   frame->enableViewSourceMode(false);
 
-  NavigationState* navigation_state = NavigationState::FromDataSource(ds);
+  DocumentState* document_state = DocumentState::FromDataSource(ds);
+  NavigationState* navigation_state = document_state->navigation_state();
 
   // If this is a failed back/forward/reload navigation, then we need to do a
   // 'replace' load.  This is necessary to avoid messing up session history.
   // Otherwise, we do a normal load, which simulates a 'go' navigation as far
   // as session history is concerned.
   //
   // AUTO_SUBFRAME loads should always be treated as loads that do not advance
   // the page id.
   //
   bool replace =
       navigation_state->pending_page_id() != -1 ||
       navigation_state->transition_type() ==
           content::PAGE_TRANSITION_AUTO_SUBFRAME;
 
   // If we failed on a browser initiated request, then make sure that our error
   // page load is regarded as the same browser initiated request.
   if (!navigation_state->is_content_initiated()) {
-    pending_navigation_state_.reset(NavigationState::CreateBrowserInitiated(
-        navigation_state->pending_page_id(),
-        navigation_state->pending_history_list_offset(),
-        navigation_state->transition_type(),
-        navigation_state->request_time()));
+    pending_navigation_params_.reset(new ViewMsg_Navigate_Params);
+    pending_navigation_params_->page_id =
+        navigation_state->pending_page_id();
+    pending_navigation_params_->pending_history_list_offset =
+        navigation_state->pending_history_list_offset();
+    pending_navigation_params_->transition =
+        navigation_state->transition_type();
+    pending_navigation_params_->request_time =
+        document_state->request_time();
   }
 
   // Provide the user with a more helpful error page?
   if (MaybeLoadAlternateErrorPage(frame, error, replace))
     return;
 
   // Fallback to a local error page.
   LoadNavigationErrorPage(frame, failed_request, error, std::string(), replace);
 }
 
 void RenderViewImpl::didReceiveDocumentData(
     WebFrame* frame, const char* data, size_t data_len,
     bool& prevent_default) {
-  NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->dataSource());
-  navigation_state->set_use_error_page(false);
+  DocumentState* document_state =
+      DocumentState::FromDataSource(frame->dataSource());
+  document_state->set_use_error_page(false);
 }
 
 void RenderViewImpl::didCommitProvisionalLoad(WebFrame* frame,
                                               bool is_new_navigation) {
-  NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->dataSource());
+  DocumentState* document_state =
+      DocumentState::FromDataSource(frame->dataSource());
+  NavigationState* navigation_state = document_state->navigation_state();
 
-  navigation_state->set_commit_load_time(Time::Now());
+  if (document_state->commit_load_time().is_null())
+    document_state->set_commit_load_time(Time::Now());
+
   if (is_new_navigation) {
     // When we perform a new navigation, we need to update the last committed
     // session history entry with state for the page we are leaving.
     UpdateSessionHistory(frame);
 
     // We bump our Page ID to correspond with the new session history entry.
     page_id_ = next_page_id_++;
 
     // Advance our offset in session history, applying the length limit.  There
     // is now no forward history.
@@ skipping 83 matching lines @@
   UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
 }
 
 void RenderViewImpl::didChangeIcon(WebFrame* frame, WebIconURL::Type type) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidChangeIcon(frame, type));
 }
 
 void RenderViewImpl::didFinishDocumentLoad(WebFrame* frame) {
   WebDataSource* ds = frame->dataSource();
-  NavigationState* navigation_state = NavigationState::FromDataSource(ds);
-  DCHECK(navigation_state);
-  navigation_state->set_finish_document_load_time(Time::Now());
+  DocumentState* document_state = DocumentState::FromDataSource(ds);
+  document_state->set_finish_document_load_time(Time::Now());
 
   Send(new ViewHostMsg_DocumentLoadedInFrame(routing_id_, frame->identifier()));
 
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidFinishDocumentLoad(frame));
 
   // Check whether we have new encoding name.
   UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
 }
 
 void RenderViewImpl::didHandleOnloadEvents(WebFrame* frame) {
   if (webview()->mainFrame() == frame) {
     Send(new ViewHostMsg_DocumentOnLoadCompletedInMainFrame(routing_id_,
                                                             page_id_));
   }
 }
 
 void RenderViewImpl::didFailLoad(WebFrame* frame, const WebURLError& error) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidFailLoad(frame, error));
 }
 
 void RenderViewImpl::didFinishLoad(WebFrame* frame) {
   WebDataSource* ds = frame->dataSource();
-  NavigationState* navigation_state = NavigationState::FromDataSource(ds);
-  DCHECK(navigation_state);
-  navigation_state->set_finish_load_time(Time::Now());
+  DocumentState* document_state = DocumentState::FromDataSource(ds);
+  if (document_state->finish_load_time().is_null())
+    document_state->set_finish_load_time(Time::Now());
 
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidFinishLoad(frame));
 
   Send(new ViewHostMsg_DidFinishLoad(routing_id_, frame->identifier()));
 }
 
 void RenderViewImpl::didNavigateWithinPage(
     WebFrame* frame, bool is_new_navigation) {
   // If this was a reference fragment navigation that we initiated, then we
-  // could end up having a non-null pending navigation state.  We just need to
+  // could end up having a non-null pending navigation params.  We just need to
   // update the ExtraData on the datasource so that others who read the
   // ExtraData will get the new NavigationState.  Similarly, if we did not
   // initiate this navigation, then we need to take care to reset any pre-
   // existing navigation state to a content-initiated navigation state.
   // DidCreateDataSource conveniently takes care of this for us.
   didCreateDataSource(frame, frame->dataSource());
 
-  NavigationState* new_state =
-      NavigationState::FromDataSource(frame->dataSource());
+  DocumentState* document_state =
+      DocumentState::FromDataSource(frame->dataSource());
+  NavigationState* new_state = document_state->navigation_state();
   new_state->set_was_within_same_page(true);
 
   didCommitProvisionalLoad(frame, is_new_navigation);
 
   WebDataSource* datasource = frame->view()->mainFrame()->dataSource();
   UpdateTitle(frame, datasource->pageTitle(), datasource->pageTitleDirection());
 }
 
 void RenderViewImpl::didUpdateCurrentHistoryItem(WebFrame* frame) {
   StartNavStateSyncTimerIfNecessary();
@@ skipping 17 matching lines @@
       provisional_data_source ? provisional_data_source : top_data_source;
 
   GURL request_url(request.url());
   GURL new_url;
   if (content::GetContentClient()->renderer()->WillSendRequest(
           frame, request_url, &new_url)) {
     request.setURL(WebURL(new_url));
   }
 
   content::PageTransition transition_type = content::PAGE_TRANSITION_LINK;
-  NavigationState* data_state = NavigationState::FromDataSource(data_source);
-  if (data_state) {
-    if (data_state->is_cache_policy_override_set())
-      request.setCachePolicy(data_state->cache_policy_override());
-    transition_type = data_state->transition_type();
+  DocumentState* document_state = DocumentState::FromDataSource(data_source);
+  NavigationState* navigation_state = document_state->navigation_state();
+  if (document_state) {
+    if (document_state->is_cache_policy_override_set())
+      request.setCachePolicy(document_state->cache_policy_override());
+    transition_type = navigation_state->transition_type();
   }
 
   request.setExtraData(
       new RequestExtraData((frame == top_frame),
                            frame->identifier(),
                            frame->parent() == top_frame,
                            frame->parent() ? frame->parent()->identifier() : -1,
                            transition_type));
 
-  NavigationState* top_data_state =
-      NavigationState::FromDataSource(top_data_source);
+  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_data_state &&
+  if (top_document_state &&
       (request.targetType() == WebURLRequest::TargetIsPrefetch ||
        request.targetType() == WebURLRequest::TargetIsPrerender))
-    top_data_state->set_was_prefetcher(true);
+    top_document_state->set_was_prefetcher(true);
 
   request.setRequestorID(routing_id_);
   request.setHasUserGesture(frame->isProcessingUserGesture());
 
   if (!renderer_preferences_.enable_referrers)
     request.clearHTTPHeaderField("Referer");
 }
 
 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;
 
-  NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->provisionalDataSource());
-  CHECK(navigation_state);
+  DocumentState* document_state =
+      DocumentState::FromDataSource(frame->provisionalDataSource());
   int http_status_code = response.httpStatusCode();
 
   // Record page load flags.
-  navigation_state->set_was_fetched_via_spdy(response.wasFetchedViaSPDY());
-  navigation_state->set_was_npn_negotiated(response.wasNpnNegotiated());
-  navigation_state->set_was_alternate_protocol_available(
+  document_state->set_was_fetched_via_spdy(response.wasFetchedViaSPDY());
+  document_state->set_was_npn_negotiated(response.wasNpnNegotiated());
+  document_state->set_was_alternate_protocol_available(
       response.wasAlternateProtocolAvailable());
-  navigation_state->set_was_fetched_via_proxy(response.wasFetchedViaProxy());
-  navigation_state->set_http_status_code(http_status_code);
+  document_state->set_was_fetched_via_proxy(response.wasFetchedViaProxy());
+  document_state->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.
-  navigation_state->set_use_error_page(true);
+  document_state->set_use_error_page(true);
 }
 
 void RenderViewImpl::didFinishResourceLoad(
     WebFrame* frame, unsigned identifier) {
-  NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->dataSource());
-  if (!navigation_state->use_error_page())
+  DocumentState* document_state =
+      DocumentState::FromDataSource(frame->dataSource());
+  if (!document_state->use_error_page())
     return;
 
   // Do not show error page when DevTools is attached.
   if (devtools_agent_->IsAttached())
     return;
 
   // Display error page, if appropriate.
-  int http_status_code = navigation_state->http_status_code();
+  int http_status_code = document_state->http_status_code();
   if (http_status_code == 404) {
     // On 404s, try a remote search page as a fallback.
     const GURL& document_url = frame->document().url();
 
     const GURL& error_page_url =
         GetAlternateErrorPageURL(document_url, HTTP_404);
     if (error_page_url.is_valid()) {
       WebURLError original_error;
       original_error.domain = "http";
       original_error.reason = 404;
       original_error.unreachableURL = document_url;
 
-      navigation_state->set_alt_error_page_fetcher(
+      document_state->set_alt_error_page_fetcher(
           new AltErrorPageResourceFetcher(
               error_page_url, frame, original_error,
               NewCallback(this, &RenderViewImpl::AltErrorPageFinished)));
       return;
     }
   }
 
   std::string error_domain;
   if (content::GetContentClient()->renderer()->HasErrorPage(
           http_status_code, &error_domain)) {
@@ skipping 1239 matching lines @@
   // Load an empty page first so there is an immediate response to the error,
   // and then kick off a request for the alternate error page.
   frame->loadHTMLString(std::string(),
                         GURL(chrome::kUnreachableWebDataURL),
                         error.unreachableURL,
                         replace);
 
   // Now, create a fetcher for the error page and associate it with the data
   // source we just created via the LoadHTMLString call.  That way if another
   // navigation occurs, the fetcher will get destroyed.
-  NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->provisionalDataSource());
-  navigation_state->set_alt_error_page_fetcher(
+  DocumentState* document_state =
+      DocumentState::FromDataSource(frame->provisionalDataSource());
+  document_state->set_alt_error_page_fetcher(
       new AltErrorPageResourceFetcher(
           error_page_url, frame, error,
           NewCallback(this, &RenderViewImpl::AltErrorPageFinished)));
   return true;
 }
 
 void RenderViewImpl::AltErrorPageFinished(WebFrame* frame,
                                           const WebURLError& original_error,
                                           const std::string& html) {
   // Here, we replace the blank page we loaded previously.
@@ skipping 33 matching lines @@
   // our set, possibly invalidating the iterator. So we iterate on a copy that
   // won't change out from under us.
   pepper_delegate_.ViewFlushedPaint();
 
   WebFrame* main_frame = webview()->mainFrame();
 
   // If we have a provisional frame we are between the start and commit stages
   // of loading and we don't want to save stats.
   if (!main_frame->provisionalDataSource()) {
     WebDataSource* ds = main_frame->dataSource();
-    NavigationState* navigation_state = NavigationState::FromDataSource(ds);
-    DCHECK(navigation_state);
+    DocumentState* document_state = DocumentState::FromDataSource(ds);
 
     // TODO(jar): The following code should all be inside a method, probably in
     // NavigatorState.
     Time now = Time::Now();
-    if (navigation_state->first_paint_time().is_null()) {
-      navigation_state->set_first_paint_time(now);
+    if (document_state->first_paint_time().is_null()) {
+      document_state->set_first_paint_time(now);
     }
-    if (navigation_state->first_paint_after_load_time().is_null() &&
-        !navigation_state->finish_load_time().is_null()) {
-      navigation_state->set_first_paint_after_load_time(now);
+    if (document_state->first_paint_after_load_time().is_null() &&
+        !document_state->finish_load_time().is_null()) {
+      document_state->set_first_paint_after_load_time(now);
     }
   }
 }
 
 void RenderViewImpl::OnViewContextSwapBuffersPosted() {
   RenderWidget::OnSwapBuffersPosted();
 }
 
 void RenderViewImpl::OnViewContextSwapBuffersComplete() {
   RenderWidget::OnSwapBuffersComplete();
@@ skipping 630 matching lines @@
   return webview()->settings()->useThreadedCompositor();
 }
 
 void RenderViewImpl::OnJavaBridgeInit(
     const IPC::ChannelHandle& channel_handle) {
   DCHECK(!java_bridge_dispatcher_.get());
 #if defined(ENABLE_JAVA_BRIDGE)
   java_bridge_dispatcher_.reset(new JavaBridgeDispatcher(this, channel_handle));
 #endif
 }