Report transfer size updates, resource starts and completes to chrome

Background:
Currently page load metrics tracks data usage when requests complete.
This misses canceled requests when the tab closes. The current codepath
will also deprecated due to the upcoming network servicification work.

This CL reports the continuous data use to page load metrics in renderer.
Response starts and completions are reported as well so that the observer
can keep track of data per resource. Subsequent CLs will send this to
browser process via the existing PageLoadMetrics mojo.

Bug: 836029
Change-Id: I023ea08b2b8f1974ea40586afeee3a27b9900782
Reviewed-on: https://chromium-review.googlesource.com/1042795
Commit-Queue: rajendrant <rajendrant@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#568353}

chrome/renderer/page_load_metrics/metrics_render_frame_observer.cc

@@ -85,6 +85,20 @@ void MetricsRenderFrameObserver::DidObserveNewCssPropertyUsage(
   }
 }
 
+void MetricsRenderFrameObserver::DidStartResponse(
+    int request_id,
+    const network::ResourceResponseHead& response_head) {}
+
+void MetricsRenderFrameObserver::DidCompleteResponse(
+    int request_id,
+    const network::URLLoaderCompletionStatus& status) {}
+
+void MetricsRenderFrameObserver::DidCancelResponse(int request_id) {}
+
+void MetricsRenderFrameObserver::DidReceiveTransferSizeUpdate(
+    int request_id,
+    int received_data_length) {}
+
 void MetricsRenderFrameObserver::FrameDetached() {
   page_timing_metrics_sender_.reset();
 }

chrome/renderer/page_load_metrics/metrics_render_frame_observer.h

@@ -38,6 +38,15 @@ class MetricsRenderFrameObserver : public content::RenderFrameObserver {
   void DidObserveNewFeatureUsage(blink::mojom::WebFeature feature) override;
   void DidObserveNewCssPropertyUsage(int css_property,
                                      bool is_animated) override;
+  void DidStartResponse(
+      int request_id,
+      const network::ResourceResponseHead& response_head) override;
+  void DidReceiveTransferSizeUpdate(int request_id,
+                                    int received_data_length) override;
+  void DidCompleteResponse(
+      int request_id,
+      const network::URLLoaderCompletionStatus& status) override;
+  void DidCancelResponse(int request_id) override;
   void DidCommitProvisionalLoad(bool is_new_navigation,
                                 bool is_same_document_navigation) override;
   void OnDestruct() override;

content/public/renderer/render_frame_observer.h

@@ -30,6 +30,11 @@ struct WebURLError;
 class WebWorkerFetchContext;
 }
 
+namespace network {
+struct ResourceResponseHead;
+struct URLLoaderCompletionStatus;
+}  // namespace network
+
 namespace content {
 
 class RendererPpapiHost;
@@ -123,6 +128,24 @@ class CONTENT_EXPORT RenderFrameObserver : public IPC::Listener,
   virtual void DidObserveNewCssPropertyUsage(int css_property,
                                              bool is_animated) {}
 
+  // Notification when the renderer a response started, completed or canceled.
+  // Complete or Cancel is guaranteed to be called for a response that started.
+  // |request_id| uniquely identifies the request within this render frame.
+  virtual void DidStartResponse(
+      int request_id,
+      const network::ResourceResponseHead& response_head) {}
+  virtual void DidCompleteResponse(
+      int request_id,
+      const network::URLLoaderCompletionStatus& status) {}
+  virtual void DidCancelResponse(int request_id) {}
+
+  // Notification when the renderer observes data used during the page load.
+  // This is used for page load metrics. |received_data_length| is the received
+  // network bytes. |resource_id| uniquely identifies the resource within this
+  // render frame.
+  virtual void DidReceiveTransferSizeUpdate(int resource_id,
+                                            int received_data_length) {}
+
   // Called when the focused node has changed to |node|.
   virtual void FocusedNodeChanged(const blink::WebNode& node) {}
 

content/renderer/loader/resource_dispatcher.cc

@@ -96,10 +96,34 @@ void NotifySubresourceStarted(
   render_frame->GetFrameHost()->SubresourceResponseStarted(url, cert_status);
 }
 
+void NotifyResourceLoadStarted(
+    scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner,
+    int render_frame_id,
+    int request_id,
+    const network::ResourceResponseHead& response_head) {
+  if (!thread_task_runner)
+    return;
+
+  if (!thread_task_runner->BelongsToCurrentThread()) {
+    thread_task_runner->PostTask(
+        FROM_HERE, base::BindOnce(NotifyResourceLoadStarted, thread_task_runner,
+                                  render_frame_id, request_id, response_head));
+    return;
+  }
+
+  RenderFrameImpl* render_frame =
+      RenderFrameImpl::FromRoutingID(render_frame_id);
+  if (!render_frame)
+    return;
+
+  render_frame->DidStartResponse(request_id, response_head);
+}
+
 void NotifyResourceLoadComplete(
     scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner,
     int render_frame_id,
-    mojom::ResourceLoadInfoPtr resource_load_info) {
+    mojom::ResourceLoadInfoPtr resource_load_info,
+    const network::URLLoaderCompletionStatus& status) {
   if (!thread_task_runner)
     return;
 
@@ -107,7 +131,7 @@ void NotifyResourceLoadComplete(
     thread_task_runner->PostTask(
         FROM_HERE,
         base::BindOnce(NotifyResourceLoadComplete, thread_task_runner,
-                       render_frame_id, std::move(resource_load_info)));
+                       render_frame_id, std::move(resource_load_info), status));
     return;
   }
 
@@ -116,10 +140,57 @@ void NotifyResourceLoadComplete(
   if (!render_frame)
     return;
 
+  render_frame->DidCompleteResponse(resource_load_info->request_id, status);
   render_frame->GetFrameHost()->ResourceLoadComplete(
       std::move(resource_load_info));
 }
 
+void NotifyResourceLoadCancel(
+    scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner,
+    int render_frame_id,
+    int request_id) {
+  if (!thread_task_runner)
+    return;
+
+  if (!thread_task_runner->BelongsToCurrentThread()) {
+    thread_task_runner->PostTask(
+        FROM_HERE, base::BindOnce(NotifyResourceLoadCancel, thread_task_runner,
+                                  render_frame_id, request_id));
+    return;
+  }
+
+  RenderFrameImpl* render_frame =
+      RenderFrameImpl::FromRoutingID(render_frame_id);
+  if (!render_frame)
+    return;
+
+  render_frame->DidCancelResponse(request_id);
+}
+
+void NotifyResourceTransferSizeUpdate(
+    scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner,
+    int render_frame_id,
+    int request_id,
+    int transfer_size_diff) {
+  if (!thread_task_runner)
+    return;
+
+  if (!thread_task_runner->BelongsToCurrentThread()) {
+    thread_task_runner->PostTask(
+        FROM_HERE,
+        base::BindOnce(NotifyResourceTransferSizeUpdate, thread_task_runner,
+                       render_frame_id, request_id, transfer_size_diff));
+    return;
+  }
+
+  RenderFrameImpl* render_frame =
+      RenderFrameImpl::FromRoutingID(render_frame_id);
+  if (!render_frame)
+    return;
+
+  render_frame->DidReceiveTransferSizeUpdate(request_id, transfer_size_diff);
+}
+
 // Returns true if the headers indicate that this resource should always be
 // revalidated or not cached.
 bool AlwaysAccessNetwork(
@@ -232,6 +303,14 @@ void ResourceDispatcher::OnReceivedResponse(
   }
 
   request_info->peer->OnReceivedResponse(renderer_response_info);
+
+  // Make a deep copy of ResourceResponseHead before passing it cross-thread.
+  auto resource_response = base::MakeRefCounted<network::ResourceResponse>();
+  resource_response->head = response_head;
+  auto deep_copied_response = resource_response->DeepCopy();
+  NotifyResourceLoadStarted(RenderThreadImpl::DeprecatedGetMainTaskRunner(),
+                            request_info->render_frame_id, request_id,
+                            deep_copied_response->head);
 }
 
 void ResourceDispatcher::OnReceivedCachedMetadata(
@@ -322,6 +401,7 @@ void ResourceDispatcher::OnRequestComplete(
     return;
   request_info->buffer.reset();
   request_info->buffer_size = 0;
+  request_info->did_request_complete = true;
 
   auto resource_load_info = mojom::ResourceLoadInfo::New();
   resource_load_info->url = request_info->response_url;
@@ -347,7 +427,7 @@ void ResourceDispatcher::OnRequestComplete(
 
   NotifyResourceLoadComplete(RenderThreadImpl::DeprecatedGetMainTaskRunner(),
                              request_info->render_frame_id,
-                             std::move(resource_load_info));
+                             std::move(resource_load_info), status);
 
   RequestPeer* peer = request_info->peer.get();
 
@@ -397,6 +477,11 @@ bool ResourceDispatcher::RemovePendingRequest(
   if (it == pending_requests_.end())
     return false;
 
+  if (!it->second->did_request_complete) {
+    NotifyResourceLoadCancel(RenderThreadImpl::DeprecatedGetMainTaskRunner(),
+                             it->second->render_frame_id, request_id);
+  }
+
   // Cancel loading.
   it->second->url_loader = nullptr;
   // Clear URLLoaderClient to stop receiving further Mojo IPC from the browser
@@ -465,6 +550,10 @@ void ResourceDispatcher::OnTransferSizeUpdated(int request_id,
   // TODO(yhirano): Consider using int64_t in
   // RequestPeer::OnTransferSizeUpdated.
   request_info->peer->OnTransferSizeUpdated(transfer_size_diff);
+
+  NotifyResourceTransferSizeUpdate(
+      RenderThreadImpl::DeprecatedGetMainTaskRunner(),
+      request_info->render_frame_id, request_id, transfer_size_diff);
 }
 
 ResourceDispatcher::PendingRequestInfo::PendingRequestInfo(

content/renderer/loader/resource_dispatcher.h

@@ -214,6 +214,7 @@ class CONTENT_EXPORT ResourceDispatcher {
         navigation_response_override;
     bool should_follow_redirect = true;
     bool always_access_network = false;
+    bool did_request_complete = false;
 
     std::vector<content::mojom::RedirectInfoPtr> redirect_info_chain;
 

content/renderer/render_frame_impl.cc

@@ -4816,6 +4816,32 @@ void RenderFrameImpl::DidLoadResourceFromMemoryCache(
       response.MimeType().Utf8(), WebURLRequestToResourceType(request)));
 }
 
+void RenderFrameImpl::DidStartResponse(
+    int request_id,
+    const network::ResourceResponseHead& response_head) {
+  for (auto& observer : observers_)
+    observer.DidStartResponse(request_id, response_head);
+}
+
+void RenderFrameImpl::DidCompleteResponse(
+    int request_id,
+    const network::URLLoaderCompletionStatus& status) {
+  for (auto& observer : observers_)
+    observer.DidCompleteResponse(request_id, status);
+}
+
+void RenderFrameImpl::DidCancelResponse(int request_id) {
+  for (auto& observer : observers_)
+    observer.DidCancelResponse(request_id);
+}
+
+void RenderFrameImpl::DidReceiveTransferSizeUpdate(int resource_id,
+                                                   int received_data_length) {
+  for (auto& observer : observers_) {
+    observer.DidReceiveTransferSizeUpdate(resource_id, received_data_length);
+  }
+}
+
 void RenderFrameImpl::DidDisplayInsecureContent() {
   Send(new FrameHostMsg_DidDisplayInsecureContent(routing_id_));
 }

content/renderer/render_frame_impl.h

@@ -876,6 +876,13 @@ class CONTENT_EXPORT RenderFrameImpl
   // browser.
   void OnDroppedNavigation();
 
+  void DidStartResponse(int request_id,
+                        const network::ResourceResponseHead& response_head);
+  void DidCompleteResponse(int request_id,
+                           const network::URLLoaderCompletionStatus& status);
+  void DidCancelResponse(int request_id);
+  void DidReceiveTransferSizeUpdate(int request_id, int received_data_length);
+
  protected:
   explicit RenderFrameImpl(CreateParams params);