Adding DRP specfic UMA for FirstContentfulPaint

content/browser/loader/navigation_resource_throttle.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 "content/browser/loader/navigation_resource_throttle.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/navigation_data.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_controller.h"
+#include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/referrer.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "ui/base/page_transition_types.h"
 
 namespace content {
 
@@ skipping 66 matching lines @@
       ->FilterURL(false, &new_validated_url);
   navigation_handle->WillRedirectRequest(
       new_validated_url, new_method, new_referrer_url, new_is_external_protocol,
       headers, base::Bind(&SendCheckResultToIOThread, callback));
 }
 
 void WillProcessResponseOnUIThread(
     UIChecksPerformedCallback callback,
     int render_process_id,
     int render_frame_host_id,
-    scoped_refptr<net::HttpResponseHeaders> headers) {
+    scoped_refptr<net::HttpResponseHeaders> headers,
+    std::unique_ptr<NavigationData> navigation_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RenderFrameHostImpl* render_frame_host =
       RenderFrameHostImpl::FromID(render_process_id, render_frame_host_id);
   if (!render_frame_host) {
     SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
     return;
   }
 
   NavigationHandleImpl* navigation_handle =
       render_frame_host->navigation_handle();
   if (!navigation_handle) {
     SendCheckResultToIOThread(callback, NavigationThrottle::PROCEED);
     return;
   }
 
+  if (navigation_data)
+    navigation_handle->set_navigation_data(std::move(navigation_data));
+
   navigation_handle->WillProcessResponse(
       render_frame_host, headers,
       base::Bind(&SendCheckResultToIOThread, callback));
 }
 
 }  // namespace
 
-NavigationResourceThrottle::NavigationResourceThrottle(net::URLRequest* request)
-    : request_(request), weak_ptr_factory_(this) {}
+NavigationResourceThrottle::NavigationResourceThrottle(
+    net::URLRequest* request,
+    ResourceDispatcherHostDelegate* resource_dispatcher_host_delegate)
+    : request_(request),
+      resource_dispatcher_host_delegate_(resource_dispatcher_host_delegate),
+      weak_ptr_factory_(this) {}
 
 NavigationResourceThrottle::~NavigationResourceThrottle() {}
 
 void NavigationResourceThrottle::WillStartRequest(bool* defer) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request_);
   if (!info)
     return;
 
   int render_process_id, render_frame_id;
@@ skipping 69 matching lines @@
     return;
 
   // Send a copy of the response headers to the NavigationHandle on the UI
   // thread.
   scoped_refptr<net::HttpResponseHeaders> response_headers;
   if (request_->response_headers()) {
     response_headers = new net::HttpResponseHeaders(
         request_->response_headers()->raw_headers());
   }
 
+  std::unique_ptr<NavigationData> cloned_data;
+  if (resource_dispatcher_host_delegate_) {
+    // Ask the embedder for a NavigationData instance.
+    NavigationData* navigation_data =
+        resource_dispatcher_host_delegate_->GetNavigationData(request_);
+
+    // Clone the embedder's NavigationData before moving it to the UI thread.
+    if (navigation_data)
+      cloned_data = navigation_data->Clone();
+  }
+
   UIChecksPerformedCallback callback =
       base::Bind(&NavigationResourceThrottle::OnUIChecksPerformed,
                  weak_ptr_factory_.GetWeakPtr());
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&WillProcessResponseOnUIThread, callback, render_process_id,
-                 render_frame_id, response_headers));
+                 render_frame_id, response_headers,
+                 base::Passed(&cloned_data)));
   *defer = true;
 }
 
 const char* NavigationResourceThrottle::GetNameForLogging() const {
   return "NavigationResourceThrottle";
 }
 
 void NavigationResourceThrottle::OnUIChecksPerformed(
     NavigationThrottle::ThrottleCheckResult result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 10 matching lines @@
     // block main frame navigations in the future, we'll need to carefully
     // consider the right thing to do here.
     DCHECK(!ResourceRequestInfo::ForRequest(request_)->IsMainFrame());
     controller()->CancelWithError(net::ERR_BLOCKED_BY_RESPONSE);
   } else {
     controller()->Resume();
   }
 }
 
 }  // namespace content