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 2246 matching lines @@
     completed_client_redirect_src_ = from;
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidCompleteClientRedirect(frame, from));
 }
 
 void RenderViewImpl::didCreateDataSource(WebFrame* frame, WebDataSource* ds) {
   // 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() :
+      NavigationState::CreateContentInitiated(ds) :
       pending_navigation_state_.release();
 
   // NavigationState::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
   // this value appropriately.
   // TODO(gavinp): catch the important case of navigation in a new
   // renderer process.
   if (webview()) {
@@ skipping 35 matching lines @@
 
   ds->setExtraData(state);
 
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidCreateDataSource(frame, ds));
 }
 
 void RenderViewImpl::didStartProvisionalLoad(WebFrame* frame) {
   WebDataSource* ds = frame->provisionalDataSource();
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
+  NavigationState::LoadTimes* load_times = navigation_state->load_times();
 
   // Update the request time if WebKit has better knowledge of it.
-  if (navigation_state->request_time().is_null()) {
+  if (load_times->request_time().is_null()) {
     double event_time = ds->triggeringEventTime();
     if (event_time != 0.0)
-      navigation_state->set_request_time(Time::FromDoubleT(event_time));
+      load_times->set_request_time(Time::FromDoubleT(event_time));
   }
 
   // Start time is only set after request time.
-  navigation_state->set_start_load_time(Time::Now());
+  load_times->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
@@ skipping 86 matching lines @@
       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()));
+        navigation_state->load_times()->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);
 }
 
 void RenderViewImpl::didCommitProvisionalLoad(WebFrame* frame,
                                               bool is_new_navigation) {
   NavigationState* navigation_state =
       NavigationState::FromDataSource(frame->dataSource());
+  NavigationState::LoadTimes* load_times = navigation_state->load_times();
 
-  navigation_state->set_commit_load_time(Time::Now());
+  if (load_times->commit_load_time().is_null())
+    load_times->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 85 matching lines @@
 
 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());
+  NavigationState::LoadTimes* load_times = navigation_state->load_times();
+  load_times->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());
+  NavigationState::LoadTimes* load_times = navigation_state->load_times();
+  load_times->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
@@ skipping 80 matching lines @@
     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);
+  NavigationState::LoadTimes* load_times = navigation_state->load_times();
   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(
+  load_times->set_was_fetched_via_spdy(response.wasFetchedViaSPDY());
+  load_times->set_was_npn_negotiated(response.wasNpnNegotiated());
+  load_times->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);
+  load_times->set_was_fetched_via_proxy(response.wasFetchedViaProxy());
+  load_times->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);
 }
 
 void RenderViewImpl::didFinishResourceLoad(
     WebFrame* frame, unsigned identifier) {
   NavigationState* navigation_state =
       NavigationState::FromDataSource(frame->dataSource());
+  NavigationState::LoadTimes* load_times = navigation_state->load_times();
   if (!navigation_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 = load_times->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;
@@ skipping 1275 matching lines @@
   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);
+    NavigationState::LoadTimes* load_times = navigation_state->load_times();
 
     // 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 (load_times->first_paint_time().is_null()) {
+      load_times->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 (load_times->first_paint_after_load_time().is_null() &&
+        !load_times->finish_load_time().is_null()) {
+      load_times->set_first_paint_after_load_time(now);
     }
   }
 }
 
 void RenderViewImpl::OnViewContextSwapBuffersPosted() {
   RenderWidget::OnSwapBuffersPosted();
 }
 
 void RenderViewImpl::OnViewContextSwapBuffersComplete() {
   RenderWidget::OnSwapBuffersComplete();
@@ skipping 628 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
 }