Adding DRP specfic UMA for FirstContentfulPaint

content/browser/loader/navigation_resource_handler.cc

 // Copyright 2014 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_handler.h"
 
+#include <memory>
+
 #include "base/logging.h"
 #include "content/browser/devtools/devtools_netlog_observer.h"
 #include "content/browser/loader/navigation_url_loader_impl_core.h"
+#include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/resource_context_impl.h"
 #include "content/browser/streams/stream.h"
 #include "content/browser/streams/stream_context.h"
+#include "content/public/browser/navigation_data.h"
 #include "content/public/browser/resource_controller.h"
+#include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/stream_handle.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
 
 namespace content {
 
 NavigationResourceHandler::NavigationResourceHandler(
     net::URLRequest* request,
-    NavigationURLLoaderImplCore* core)
+    NavigationURLLoaderImplCore* core,
+    ResourceDispatcherHostImpl* resource_dispatcher_host)
     : ResourceHandler(request),
-      core_(core) {
+      core_(core),
+      resource_dispatcher_host_(resource_dispatcher_host) {
   core_->set_resource_handler(this);
   writer_.set_immediate_mode(true);
 }
 
 NavigationResourceHandler::~NavigationResourceHandler() {
   if (core_) {
     core_->NotifyRequestFailed(false, net::ERR_ABORTED);
     DetachFromCore();
   }
 }
@@ skipping 48 matching lines @@
   // dispatched at the navigation layer.
   if (info->IsDownload() || info->is_stream())
     return true;
 
   StreamContext* stream_context =
       GetStreamContextForResourceContext(info->GetContext());
   writer_.InitializeStream(stream_context->registry(),
                            request()->url().GetOrigin());
 
   DevToolsNetLogObserver::PopulateResponseInfo(request(), response);
-  core_->NotifyResponseStarted(response, writer_.stream()->CreateHandle());
+
+  // Ask the embedder for a NavigationData instance.
+  std::unique_ptr<NavigationData> navigation_data;
+  std::unique_ptr<NavigationData> cloned_data;
+  if (resource_dispatcher_host_ && resource_dispatcher_host_->delegate()) {
+    navigation_data =
+        resource_dispatcher_host_->delegate()->GetNavigationData(request());

[mmenke, 2016/05/03 16:06:24]

Accessing the RDH and/or its delegate here seems fine.  I am a bit concerned
about all the cloning going on here, though.

GetNavigationData creates the navigation data from scratch.  Then you copy it
all immediately to pass to another thread...

Also, should ChromeNavigationData really depend on every single module that
wants to smuggle data over to the UI thread?

[bengr, 2016/05/03 17:41:55]

So we started with a unique_ptr, so we could simply transfer ownership when
moving it to a new thread, but got push back from nasko and ncarter that that
was a messier contract than simply cloning the object for use on a new thread.
We're fine either way, but all owners need to agree. 

[RyanSturm, 2016/05/03 18:14:13]

Switching to RDHDelegate.
Like bengr@ said, this makes a cleaner contract, so there needs to be ownership
agreement.
If a different module needs to smuggle data, they can implement a clone-able
version of SupportsUserData, or some other workaround. If they need to get
something off of URLRequest and move it to NavigationData without chrome or
content knowing about the key would be a copyable version of SupportsUserData or
the like. It seems like chrome should know about anything that crosses from net/
to content/ like this, so in some ways, this explicit ownership is helpful.

[mmenke, 2016/05/03 19:32:53]

The thing is, the object is created on demand, and *then* it's copied to pass
over to the UI thread.

It seems to me like either the object should be kept around (And possibly
updated by consumers) and then copied as needed to pass over to the UI thread. 
Or it should be created as needed, and then ownership passed over to the UI
thread.

I think create on demand and then copy doesn't really make any sense.  Also not
a big fan of punting cleanup to the next unfortunate who finds himself in need
of passing data along the same path.

+
+    // Clone the embedder's NavigationData before moving it to the UI thread.
+    if (navigation_data)
+      cloned_data = navigation_data->Clone();
+  }
+
+  core_->NotifyResponseStarted(response, writer_.stream()->CreateHandle(),
+                               std::move(cloned_data));
   *defer = true;
+
   return true;
 }
 
 bool NavigationResourceHandler::OnWillStart(const GURL& url, bool* defer) {
   return true;
 }
 
 bool NavigationResourceHandler::OnBeforeNetworkStart(const GURL& url,
                                                      bool* defer) {
   return true;
@@ skipping 36 matching lines @@
   NOTREACHED();
 }
 
 void NavigationResourceHandler::DetachFromCore() {
   DCHECK(core_);
   core_->set_resource_handler(nullptr);
   core_ = nullptr;
 }
 
 }  // namespace content