[PageLoadMetrics] Keep track of Ad Sizes on Pages

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>
@@ skipping 227 matching lines @@
     // correctly (for example Link: preloads).
     if (committed_load_ &&
         creation_time >= committed_load_->navigation_start()) {
       return committed_load_.get();
     }
   }
   return nullptr;
 }
 
 void MetricsWebContentsObserver::OnRequestComplete(
+    const GURL& url,
+    int frame_tree_node_id,
     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) {
   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);
+        std::move(url), frame_tree_node_id, was_cached, raw_body_bytes,

[Bryan McQuade, 2017/04/12 15:01:17]

we chatted about this & I think you concluded that we'd remove the std::move(),
but just to document our reasoning, we concluded:
calling std::move() on a const object doesn't end up avoiding a copy, as the
|const GURL&&| resulting from the std::move() can't be passed to the GURL move
constructor, which takes a non-const |GURL&&| (move constructors take non-const
rvalues since the rvalue is being modified). Instead, IIUC, the |const GURL&&|
is implicitly converted to a const GURL& and the GURL copy constructor gets
invoked.

[jkarlin, 2017/04/13 17:25:30]

Done.

+        used_data_reduction_proxy, was_cached ? 0 : original_content_length);
     tracker->OnLoadedResource(extra_request_info);
   }
 }
 
 const PageLoadExtraInfo
 MetricsWebContentsObserver::GetPageLoadExtraInfoForCommittedLoad() {
   DCHECK(committed_load_);
   return committed_load_->ComputePageLoadExtraInfo();
 }
 
 void MetricsWebContentsObserver::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
-  if (!navigation_handle->IsInMainFrame())
+  if (!navigation_handle->IsInMainFrame()) {
+    if (committed_load_ && navigation_handle->HasCommitted())
+      committed_load_->DidCommitSubFrame(navigation_handle);
     return;
+  }
 
   std::unique_ptr<PageLoadTracker> finished_nav(
       std::move(provisional_loads_[navigation_handle]));
   provisional_loads_.erase(navigation_handle);
 
   // Ignore same-document navigations.
   if (navigation_handle->HasCommitted() &&
       navigation_handle->IsSameDocument()) {
     if (finished_nav)
       finished_nav->StopTracking();
@@ skipping 288 matching lines @@
     content::NavigationHandle* navigation_handle) const {
   DCHECK(navigation_handle->IsInMainFrame());
   DCHECK(!navigation_handle->HasCommitted() ||
          !navigation_handle->IsSameDocument());
 
   return BrowserPageTrackDecider(embedder_interface_.get(), web_contents(),
                                  navigation_handle).ShouldTrack();
 }
 
 }  // namespace page_load_metrics