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

 // Copyright 2017 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/page_load_metrics/observers/resource_tracking_page_load_metrics_observer.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.

[RyanSturm, 2017/05/10 19:45:35]

nit: s/petewiL/petewil/ (capitalized L) unless this is an intentional
stylization

[Pete Williamson, 2017/05/10 21:07:14]

Done.

+  if (extra_request_start_info.resource_type == content::RESOURCE_TYPE_IMAGE) {

[RyanSturm, 2017/05/10 19:45:35]

Just a thought, you might want to convert the type here and in OnLoadedResource
before the image comparison (x == offline_pages::ResourceDataType::IMAGE). I
suggest this so that if you change ConvertResourceTypeToResourceDataType the
behavior will be correct here, but I'd be fine with changing it later as this
class changes.

[Pete Williamson, 2017/05/10 21:07:14]

I'd like to change it later with the next changelist.  The next changelist will
add storage for all types of resources, and I haven't yet decided whether to
store them as content::ResourceType or offline_pages::ResourceDataType.

+    ++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_);
+  }
 }
 
-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