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 "chrome/browser/offline_pages/offliner_user_data.h"
+#include "components/offline_pages/core/background/offliner.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::Offliner::ResourceDataType ConvertResourceTypeToResourceDataType(
+    content::ResourceType type) {
+  switch (type) {
+    case (content::RESOURCE_TYPE_MAIN_FRAME):
+    case (content::RESOURCE_TYPE_SUB_FRAME):
+      return offline_pages::Offliner::ResourceDataType::TEXT_HTML;
+    case (content::RESOURCE_TYPE_STYLESHEET):
+      return offline_pages::Offliner::ResourceDataType::TEXT_CSS;
+    case (content::RESOURCE_TYPE_SCRIPT):
+      return offline_pages::Offliner::ResourceDataType::TEXT_SCRIPT;
+    case (content::RESOURCE_TYPE_IMAGE):
+      return offline_pages::Offliner::ResourceDataType::IMAGE;
+    case (content::RESOURCE_TYPE_MEDIA):
+      return offline_pages::Offliner::ResourceDataType::MEDIA;
+    case (content::RESOURCE_TYPE_XHR):
+      return offline_pages::Offliner::ResourceDataType::XHR;
+    default:
+      return offline_pages::Offliner::ResourceDataType::OTHER;
+  }
+}
+}  // namespace
+
 namespace page_load_metrics {
 
 ResourceTrackingPageLoadMetricsObserver::
     ResourceTrackingPageLoadMetricsObserver()
     : started_count_(0), completed_count_(0) {}
 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.

[Dmitry Titov, 2017/05/24 23:09:34]

Why limit to images here? This looks like a general-purpose resource loading
observer, the concern of a specific endpoint not being able to report about
other types should probably be solved there.

Otherwise it's unclear why to even have ConvertResourceTypeToResourceDataType().
For example, you could just call
InformClient(offline_pages::Offliner::ResourceDataType::IMAGE) and avoid having
that conversion method altogether.

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

[Dmitry Titov, 2017/05/24 23:09:34]

Between next 3 lines, content::RESOURCE_TYPE_IMAGE is used as also
content::ResourceType::RESOURCE_TYPE_IMAGE. There should be one way to use it.

+    ++started_count_;
+    InformClient(content::ResourceType::RESOURCE_TYPE_IMAGE);
+  }
 }
 
 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) {

[Dmitry Titov, 2017/05/24 23:09:35]

formatting. git cl format this CL please.

+    ++completed_count_;
+    InformClient(content::ResourceType::RESOURCE_TYPE_IMAGE);
+  }
 }
 
-void ResourceTrackingPageLoadMetricsObserver::GetCountsForTypeForTesting(
-    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_;
+PageLoadMetricsObserver::ObservePolicy
+ResourceTrackingPageLoadMetricsObserver::OnCommit(
+    content::NavigationHandle* navigation_handle) {
+  DCHECK(navigation_handle != nullptr);
+
+  offline_pages::Offliner* offliner =
+      offline_pages::OfflinerUserData::OfflinerFromWebContents(
+          navigation_handle->GetWebContents());
+  if (offliner) {
+    offliner_ = offliner;
+    return PageLoadMetricsObserver::CONTINUE_OBSERVING;
+  }
+
+  return PageLoadMetricsObserver::STOP_OBSERVING;
+}
+
+void ResourceTrackingPageLoadMetricsObserver::InformClient(
+    const content::ResourceType type) {
+  if (offliner_) {
+    // TODO: Also rename ResourceTrackerObserver -> ResourceTrackerClient
+    offline_pages::Offliner::ResourceDataType converted_type =
+        ConvertResourceTypeToResourceDataType(type);
+    offliner_->ObserveResourceTracking(converted_type, started_count_,
+                                       completed_count_);
+  }
 }
 
 }  // namespace page_load_metrics