Add a way to send the resource percentage signal to the RC.

chrome/browser/page_load_metrics/observers/resource_tracking_page_load_metrics_observer.cc

Index: chrome/browser/page_load_metrics/observers/resource_tracking_page_load_metrics_observer.cc
diff --git a/chrome/browser/page_load_metrics/observers/resource_tracking_page_load_metrics_observer.cc b/chrome/browser/page_load_metrics/observers/resource_tracking_page_load_metrics_observer.cc
index 1f74a34c9256b916eb0faf7e96f060f6b7bea836..fec572c247651df3d2d45b429f3eb81de8829387 100644
--- a/chrome/browser/page_load_metrics/observers/resource_tracking_page_load_metrics_observer.cc
+++ b/chrome/browser/page_load_metrics/observers/resource_tracking_page_load_metrics_observer.cc
@@ -4,36 +4,97 @@
 
 #include "chrome/browser/page_load_metrics/observers/resource_tracking_page_load_metrics_observer.h"
 
+#include "chrome/browser/offline_pages/offliner_user_data.h"
+#include "components/offline_pages/core/background/request_coordinator.h"
+#include "components/offline_pages/core/background/resource_data_type.h"
+
+namespace {
+
+// Since the content::ResourceType type is not generally available everywhere
+// in chrome, we translate it to a type that can be used from code in the
+// components subtree.
+offline_pages::ResourceDataType ConvertResourceTypeToResourceDataType(
+    content::ResourceType type) {
+  switch (type) {
+    case (content::RESOURCE_TYPE_MAIN_FRAME):
+    case (content::RESOURCE_TYPE_SUB_FRAME):
+      return offline_pages::ResourceDataType::TEXT_HTML;
+    case (content::RESOURCE_TYPE_STYLESHEET):
+      return offline_pages::ResourceDataType::TEXT_CSS;
+    case (content::RESOURCE_TYPE_SCRIPT):
+      return offline_pages::ResourceDataType::TEXT_SCRIPT;
+    case (content::RESOURCE_TYPE_IMAGE):
+      return offline_pages::ResourceDataType::IMAGE;
+    case (content::RESOURCE_TYPE_MEDIA):
+      return offline_pages::ResourceDataType::MEDIA;
+    case (content::RESOURCE_TYPE_XHR):
+      return offline_pages::ResourceDataType::XHR;
+    default:
+      return offline_pages::ResourceDataType::OTHER;
+  }
+}
+}  // namespace
+
 namespace page_load_metrics {
 
 ResourceTrackingPageLoadMetricsObserver::
-    ResourceTrackingPageLoadMetricsObserver()
-    : started_count_(0), completed_count_(0) {}
+    ResourceTrackingPageLoadMetricsObserver(
+        offline_pages::ResourceTrackerObserver* request_coordinator)
+    : started_count_(0),
+      completed_count_(0),
+      request_coordinator_(request_coordinator) {}
 ResourceTrackingPageLoadMetricsObserver::
     ~ResourceTrackingPageLoadMetricsObserver() {}
 
 void ResourceTrackingPageLoadMetricsObserver::OnStartedResource(
     const ExtraRequestStartInfo& extra_request_start_info) {
-  // TODO(petewiL): Store this by type.
-  ++started_count_;
+  // TODO(petewil): Store this by type. Until we do, only look at images.
+  if (extra_request_start_info.resource_type == content::RESOURCE_TYPE_IMAGE) {
+    ++started_count_;
+    InformObservers(content::ResourceType::RESOURCE_TYPE_IMAGE, started_count_,
+                    completed_count_);
+  }
 }
 
 void ResourceTrackingPageLoadMetricsObserver::OnLoadedResource(
     const ExtraRequestCompleteInfo& extra_request_complete_info) {
   // TODO(petewil): Check to see if the type of the request changed.  If it did,
   // update the old and new types for the started type.  Then update by type for
-  // the completed type.
-  ++completed_count_;
+  // the completed type.  Maybe we can just skip that, and count XHR as its own
+  // type.
+  if (extra_request_complete_info.resource_type ==
+      content::RESOURCE_TYPE_IMAGE) {
+    ++completed_count_;
+    InformObservers(content::ResourceType::RESOURCE_TYPE_IMAGE, started_count_,
+                    completed_count_);
+  }
+}
+
+PageLoadMetricsObserver::ObservePolicy
+ResourceTrackingPageLoadMetricsObserver::OnCommit(
+    content::NavigationHandle* navigation_handle) {
+  if (navigation_handle == nullptr)
+    return PageLoadMetricsObserver::STOP_OBSERVING;
+
+  offline_pages::Offliner* offliner =
+      offline_pages::OfflinerUserData::OfflinerFromWebContents(
+          navigation_handle->GetWebContents());
+  if (offliner)
+    return PageLoadMetricsObserver::CONTINUE_OBSERVING;
+
+  return PageLoadMetricsObserver::STOP_OBSERVING;
 }
 
-void ResourceTrackingPageLoadMetricsObserver::GetCountsForTypeForTesting(
+void ResourceTrackingPageLoadMetricsObserver::InformObservers(
     const content::ResourceType type,
-    int64_t* started_count,
-    int64_t* completed_count) {
-  if (started_count != nullptr)
-    *started_count = started_count_;
-  if (completed_count != nullptr)
-    *completed_count = completed_count_;
+    int64_t started_count,
+    int64_t completed_count) {
+  if (request_coordinator_) {
+    offline_pages::ResourceDataType converted_type =
+        ConvertResourceTypeToResourceDataType(type);
+    request_coordinator_->ObserveResourceTracking(converted_type, started_count,
+                                                  completed_count);
+  }
 }
 
 }  // namespace page_load_metrics