Get network resource usage from ChromeResourceDispatcherHostDelegate

chrome/browser/loader/chrome_resource_dispatcher_host_delegate.cc

 // Copyright (c) 2012 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/loader/chrome_resource_dispatcher_host_delegate.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 32 matching lines @@
 #include "chrome/browser/ui/login/login_handler.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/features.h"
 #include "chrome/common/url_constants.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_config.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_data.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_io_data.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_util.h"
 #include "components/google/core/browser/google_util.h"
+#include "components/offline_pages/features/features.h"
 #include "components/policy/core/common/cloud/policy_header_io_helper.h"
 #include "components/previews/core/previews_experiments.h"
 #include "components/previews/core/previews_io_data.h"
 #include "components/rappor/public/rappor_utils.h"
 #include "components/rappor/rappor_service_impl.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/variations/net/variations_http_headers.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_data.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 32 matching lines @@
 #include "chrome/browser/renderer_host/chrome_navigation_ui_data.h"
 #include "extensions/browser/extension_throttle_manager.h"
 #include "extensions/browser/guest_view/web_view/web_view_renderer_state.h"
 #include "extensions/browser/info_map.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/manifest_handlers/mime_types_handler.h"
 #include "extensions/common/user_script.h"
 #endif
 
+#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
+#include "chrome/browser/offline_pages/offliner_user_data.h"
+#include "chrome/browser/offline_pages/resource_loading_observer.h"
+#endif
+
 #if defined(OS_ANDROID)
 #include "chrome/browser/android/download/intercept_download_resource_throttle.h"
 #include "chrome/browser/android/offline_pages/downloads/resource_throttle.h"
 #include "chrome/browser/loader/data_reduction_proxy_resource_throttle_android.h"
-#include "chrome/browser/offline_pages/background_loader_offliner.h"
 #include "components/navigation_interception/intercept_navigation_delegate.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/signin/merge_session_resource_throttle.h"
 #include "chrome/browser/chromeos/login/signin/merge_session_throttling_utils.h"
 #endif
 
 using content::BrowserThread;
 using content::RenderViewHost;
@@ skipping 222 matching lines @@
     if (net_error == net::OK) {
       UMA_HISTOGRAM_LONG_TIMES("Net.NTP.Local.RequestTime2.Success",
                                request_loading_time);
     } else if (net_error == net::ERR_ABORTED) {
       UMA_HISTOGRAM_LONG_TIMES("Net.NTP.Local.RequestTime2.ErrAborted",
                                request_loading_time);
     }
   }
 }
 
+#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
+// Translate content::ResourceType to a type to use for Offliners.
+offline_pages::ResourceLoadingObserver::ResourceDataType
+ConvertResourceTypeToResourceDataType(content::ResourceType type) {
+  switch (type) {
+    case content::RESOURCE_TYPE_STYLESHEET:
+      return offline_pages::ResourceLoadingObserver::ResourceDataType::TEXT_CSS;
+    case content::RESOURCE_TYPE_IMAGE:
+      return offline_pages::ResourceLoadingObserver::ResourceDataType::IMAGE;
+    default:
+      return offline_pages::ResourceLoadingObserver::ResourceDataType::OTHER;
+  }
+}
+
+void NotifyUIThreadOfRequestStarted(
+    const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
+    ResourceType resource_type) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  content::WebContents* web_contents = web_contents_getter.Run();
+  if (!web_contents)
+    return;
+
+  // If we are producing an offline version of the page, track resource loading.
+  offline_pages::ResourceLoadingObserver* resource_tracker =
+      offline_pages::OfflinerUserData::ResourceLoadingObserverFromWebContents(
+          web_contents);
+  if (resource_tracker) {
+    offline_pages::ResourceLoadingObserver::ResourceDataType data_type =
+        ConvertResourceTypeToResourceDataType(resource_type);
+    resource_tracker->ObserveResourceLoading(data_type, true /* STARTED */);
+  }
+}
+#endif
+
 void NotifyUIThreadOfRequestComplete(
     const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
     const content::ResourceRequestInfo::FrameTreeNodeIdGetter&
         frame_tree_node_id_getter,
     const GURL& url,
     const net::HostPortPair& host_port_pair,
     const content::GlobalRequestID& request_id,
     ResourceType resource_type,
     bool is_download,
     bool was_cached,
     std::unique_ptr<data_reduction_proxy::DataReductionProxyData>
         data_reduction_proxy_data,
     int net_error,
     int64_t total_received_bytes,
     int64_t raw_body_bytes,
     int64_t original_content_length,
     base::TimeTicks request_creation_time,
     base::TimeDelta request_loading_time) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::WebContents* web_contents = web_contents_getter.Run();
   if (!web_contents)
     return;
+
   if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME) {
     LogMainFrameMetricsOnUIThread(url, net_error, request_loading_time,
                                   web_contents);
   }
+
   if (!was_cached) {
     UpdatePrerenderNetworkBytesCallback(web_contents, total_received_bytes);
-#if defined(OS_ANDROID)
-    offline_pages::BackgroundLoaderOffliner* background_loader =
-        offline_pages::BackgroundLoaderOffliner::FromWebContents(web_contents);
+  }
 
-    if (background_loader)
-      background_loader->OnNetworkBytesChanged(total_received_bytes);
-#endif  // OS_ANDROID
+#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
+  // If we are producing an offline version of the page, track resource loading.
+  offline_pages::ResourceLoadingObserver* resource_tracker =
+      offline_pages::OfflinerUserData::ResourceLoadingObserverFromWebContents(
+          web_contents);
+  if (resource_tracker) {
+    offline_pages::ResourceLoadingObserver::ResourceDataType data_type =
+        ConvertResourceTypeToResourceDataType(resource_type);
+    resource_tracker->ObserveResourceLoading(data_type, false /* COMPLETED */);
+    if (!was_cached)
+      resource_tracker->OnNetworkBytesChanged(total_received_bytes);
   }
+#endif  // BUILDFLAG(ENABLE_OFFLINE_PAGES)
+
   if (!is_download) {
     page_load_metrics::MetricsWebContentsObserver* metrics_observer =
         page_load_metrics::MetricsWebContentsObserver::FromWebContents(
             web_contents);
     if (metrics_observer) {
       metrics_observer->OnRequestComplete(
           url, host_port_pair, frame_tree_node_id_getter.Run(), request_id,
           resource_type, was_cached, std::move(data_reduction_proxy_data),
           raw_body_bytes, original_content_length, request_creation_time,
           net_error);
@@ skipping 53 matching lines @@
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     content::AppCacheService* appcache_service,
     ResourceType resource_type,
     std::vector<std::unique_ptr<content::ResourceThrottle>>* throttles) {
   if (safe_browsing_.get())
     safe_browsing_->OnResourceRequest(request);
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
 
+#if BUILDFLAG(ENABLE_OFFLINE_PAGES)
+  // TODO(petewil): Unify the safe browsing request and the metrics observer
+  // request if possible so we only have to cross to the main thread once.
+  // http://crbug.com/712312.
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&NotifyUIThreadOfRequestStarted,
+                                     info->GetWebContentsGetterForRequest(),
+                                     info->GetResourceType()));
+#endif  // BUILDFLAG(ENABLE_OFFLINE_PAGES)
+
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(
       resource_context);
 
 #if defined(OS_ANDROID)
   if (resource_type != content::RESOURCE_TYPE_MAIN_FRAME)
     InterceptNavigationDelegate::UpdateUserGestureCarryoverInfo(request);
 #endif
 
 #if defined(OS_CHROMEOS)
   // Check if we need to add merge session throttle. This throttle will postpone
@@ skipping 496 matching lines @@
             &ChromeResourceDispatcherHostDelegate::OnAbortedFrameLoad,
             base::Unretained(this), url, request_loading_time));
     return;
   }
 
   std::string metric_name = (request_loading_time.InMilliseconds() < 100 ?
       "Net.ErrAborted.Fast" : "Net.ErrAborted.Slow");
   rappor::SampleDomainAndRegistryFromGURL(
       g_browser_process->rappor_service(), metric_name, url);
 }