Associate a main resource request with its PageLoadTracker.

chrome/browser/page_load_metrics/metrics_web_contents_observer.cc

 // Copyright 2015 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 "chrome/browser/page_load_metrics/metrics_web_contents_observer.h"
 
 #include <algorithm>
 #include <ostream>
 #include <string>
 #include <utility>
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics.h"
 #include "chrome/browser/page_load_metrics/browser_page_track_decider.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_embedder_interface.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_util.h"
 #include "chrome/browser/page_load_metrics/page_load_tracker.h"
 #include "chrome/common/page_load_metrics/page_load_metrics_messages.h"
 #include "chrome/common/page_load_metrics/page_load_timing.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/global_request_id.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/net_errors.h"
@@ skipping 135 matching lines @@
   // after the PageLoadTracker. The PageLoadTracker does not hold on to
   // committed_load_ or navigation_handle beyond the scope of the constructor.
   provisional_loads_.insert(std::make_pair(
       navigation_handle,
       base::MakeUnique<PageLoadTracker>(
           in_foreground_, embedder_interface_.get(), currently_committed_url,
           navigation_handle, user_initiated_info, chain_size,
           chain_size_same_url)));
 }
 
+void MetricsWebContentsObserver::WillProcessNavigationResponse(
+    content::NavigationHandle* navigation_handle) {
+  auto it = provisional_loads_.find(navigation_handle);
+  if (it == provisional_loads_.end())
+    return;
+  it->second->WillProcessNavigationResponse(navigation_handle);
+}
+
+PageLoadTracker* MetricsWebContentsObserver::GetTrackerOrNullForRequest(
+    const content::GlobalRequestID& request_id,
+    content::ResourceType resource_type,
+    base::TimeTicks creation_time) {
+  if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME) {
+    // The main frame request can complete either before or after commit, so we
+    // look at both provisional loads and the committed load to find a
+    // PageLoadTracker with a matching request id. See https://goo.gl/6TzCYN for
+    // more details.
+    for (const auto& kv : provisional_loads_) {
+      PageLoadTracker* candidate = kv.second.get();
+      if (candidate->HasMatchingNavigationRequestID(request_id)) {
+        return candidate;
+      }
+    }
+    if (committed_load_ &&
+        committed_load_->HasMatchingNavigationRequestID(request_id)) {
+      return committed_load_.get();
+    }
+  } else {
+    // Non main frame resources are always associated with the currently
+    // committed load. If the resource request was started before this
+    // navigation then it should be ignored.
+
+    // TODO(jkarlin): There is a race here. Consider the following sequence:
+    // 1. renderer has a committed page A
+    // 2. navigation is initiated to page B
+    // 3. page A initiates URLRequests (e.g. in the unload handler)
+    // 4. page B commits
+    // 5. the URLRequests initiated by A complete
+    // In the above example, the URLRequests initiated by A will be attributed
+    // to page load B. This should be relatively rare but we may want to fix
+    // this at some point. We could fix this by comparing the URLRequest
+    // creation time against the committed load's commit time, however more
+    // investigation is needed to confirm that all cases would be handled
+    // correctly (for example Link: preloads).
+    if (committed_load_ &&
+        creation_time >= committed_load_->navigation_start()) {
+      return committed_load_.get();
+    }
+  }
+  return nullptr;
+}
+
 void MetricsWebContentsObserver::OnRequestComplete(
+    const content::GlobalRequestID& request_id,
     content::ResourceType resource_type,
     bool was_cached,
     bool used_data_reduction_proxy,
     int64_t raw_body_bytes,
     int64_t original_content_length,
     base::TimeTicks creation_time) {
-  // If the navigation hasn't committed yet then we'll miss the resource (this
-  // happens on the new tab page). Also, if the resource request was started
-  // before this navigation then it should be ignored.
-  // TODO(jkarlin): There is a race here. If a renderer starts URLRequests for
-  // page A after navigating (but before comitting) to page B, then page A's
-  // requests might wind up counting toward page B's size. This should be
-  // relatively rare but we may want to fix this at some point.
-  if (!committed_load_ || creation_time < committed_load_->navigation_start()) {
-    return;
+  PageLoadTracker* tracker =
+      GetTrackerOrNullForRequest(request_id, resource_type, creation_time);
+  if (tracker) {
+    ExtraRequestInfo extra_request_info(
+        was_cached, raw_body_bytes, used_data_reduction_proxy,
+        was_cached ? 0 : original_content_length);
+    tracker->OnLoadedResource(extra_request_info);
   }
-
-  ExtraRequestInfo extra_request_info(was_cached, raw_body_bytes,
-                                      used_data_reduction_proxy,
-                                      was_cached ? 0 : original_content_length);
-
-  committed_load_->OnLoadedResource(extra_request_info);
 }
 
 const PageLoadExtraInfo
 MetricsWebContentsObserver::GetPageLoadExtraInfoForCommittedLoad() {
   DCHECK(committed_load_);
   return committed_load_->ComputePageLoadExtraInfo();
 }
 
 void MetricsWebContentsObserver::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
@@ skipping 272 matching lines @@
     content::NavigationHandle* navigation_handle) const {
   DCHECK(navigation_handle->IsInMainFrame());
   DCHECK(!navigation_handle->HasCommitted() ||
          !navigation_handle->IsSamePage());
 
   return BrowserPageTrackDecider(embedder_interface_.get(), web_contents(),
                                  navigation_handle).ShouldTrack();
 }
 
 }  // namespace page_load_metrics