Send an event to the page load metrics to track resource starting.

chrome/browser/loader/chrome_resource_dispatcher_host_delegate.cc

 // Copyright (c) 2012 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/loader/chrome_resource_dispatcher_host_delegate.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 327 matching lines @@
     if (net_error == net::OK) {
       UMA_HISTOGRAM_LONG_TIMES("Net.NTP.Local.RequestTime2.Success",
                                request_loading_time);
     } else if (net_error == net::ERR_ABORTED) {
       UMA_HISTOGRAM_LONG_TIMES("Net.NTP.Local.RequestTime2.ErrAborted",
                                request_loading_time);
     }
   }
 }
 
+void NotifyUIThreadOfRequestStarted(

[Charlie Harrison, 2017/04/18 16:51:32]

Can we use WebContentsObserver::DidGetResourceResponseStart instead?

[RyanSturm, 2017/04/18 17:23:57]

This seems to be called when headers are received. I think that won't track the
pending requests very well considering we can only have 6 sockets open to the
same host (I'm assuming each request takes 1 socket, but I'm not sure). Suppose
the page wanted to start 100 image requests, when 12 finish it would look like
12/18 are done, which might seem good enough. WDY?T

https://cs.chromium.org/chromium/src/net/socket/client_socket_pool_manager.cc...

[Charlie Harrison, 2017/04/18 17:38:35]

Woops, you're right I completely misread the name :P

+    const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
+    const content::GlobalRequestID& request_id,
+    ResourceType resource_type,
+    base::TimeTicks request_creation_time) {
+  content::WebContents* web_contents = web_contents_getter.Run();
+
+  if (!web_contents)
+    return;
+
+  page_load_metrics::MetricsWebContentsObserver* metrics_observer =
+      page_load_metrics::MetricsWebContentsObserver::FromWebContents(
+          web_contents);
+
+  if (metrics_observer) {
+    metrics_observer->OnRequestStarted(request_id, resource_type,
+                                       request_creation_time);
+  }
+}
+
 void NotifyUIThreadOfRequestComplete(
     const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
     const GURL& url,
     const content::GlobalRequestID& request_id,
     ResourceType resource_type,
     bool was_cached,
     bool used_data_reduction_proxy,
     int net_error,
     int64_t total_received_bytes,
     int64_t raw_body_bytes,
@@ skipping 78 matching lines @@
 void ChromeResourceDispatcherHostDelegate::RequestBeginning(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     content::AppCacheService* appcache_service,
     ResourceType resource_type,
     std::vector<std::unique_ptr<content::ResourceThrottle>>* throttles) {
   if (safe_browsing_.get())
     safe_browsing_->OnResourceRequest(request);
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
+
+  // TODO(petewil): Unify the safe browsing request and the metrics observer
+  // request if possible so we only have to cross to the main thread once.
+  // http://crbug.com/712312.
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&NotifyUIThreadOfRequestStarted,
+                 info->GetWebContentsGetterForRequest(),
+                 info->GetGlobalRequestID(), info->GetResourceType(),
+                 request->creation_time()));
+
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(
       resource_context);
 
 #if defined(OS_ANDROID)
   if (resource_type != content::RESOURCE_TYPE_MAIN_FRAME)
     InterceptNavigationDelegate::UpdateUserGestureCarryoverInfo(request);
 #endif
 
 #if defined(OS_CHROMEOS)
   // Check if we need to add merge session throttle. This throttle will postpone
@@ skipping 456 matching lines @@
           base::Bind(&ChromeResourceDispatcherHostDelegate::OnAbortedFrameLoad,
                     base::Unretained(this), url, request_loading_time));
       return;
   }
 
   std::string metric_name = (request_loading_time.InMilliseconds() < 100 ?
       "Net.ErrAborted.Fast" : "Net.ErrAborted.Slow");
   rappor::SampleDomainAndRegistryFromGURL(
       g_browser_process->rappor_service(), metric_name, url);
 }