Adding more histograms to ResourcePrefetchPredictor.

chrome/browser/net/resource_prefetch_predictor_observer.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/net/resource_prefetch_predictor_observer.h"
 
 #include <string>
 
+#include "base/metrics/histogram.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_request_info.h"
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request.h"
 
 using content::BrowserThread;
 using predictors::ResourcePrefetchPredictor;
 
 namespace {
 
+// Enum for measuring navigation statistics. The "PROCESSED" values refers to
+// the ones that are handled by the predictor.
+enum NavigationStats {
+  NAVIGATION_STATS_TOTAL_MAIN_FRAME_REQUESTS = 0,
+  NAVIGATION_STATS_PROCESSED_MAIN_FRAME_REQUESTS = 1,
+  NAVIGATION_STATS_TOTAL_MAIN_FRAME_REDIRECTS = 2,
+  NAVIGATION_STATS_PROCESSED_MAIN_FRAME_REDIRECTS = 3,
+  NAVIGATION_STATS_TOTAL_MAIN_FRAME_RESPONSES = 4,
+  NAVIGATION_STATS_PROCESSED_MAIN_FRAME_RESPONSES = 5,
+  NAVIGATION_STATS_TOTAL_SUBRESOURCE_RESPONSES = 6,
+  NAVIGATION_STATS_PROCESSED_SUBRESOURCE_RESPONSES = 7,
+  NAVIGATION_STATS_MAX = 8,
+};
+
+
 bool SummarizeResponse(net::URLRequest* request,
                        ResourcePrefetchPredictor::URLRequestSummary* summary) {
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request);
   if (!info) {
-    LOG(ERROR) << "No ResourceRequestInfo in request";
+    UMA_HISTOGRAM_BOOLEAN("ResourcePrefetchPredictor.NoResourceRequestInfo",

[dominich, 2012/08/29 22:29:29]

you can also use HISTOGRAM_ENUMERATION with the parameters 1, 2.

consider this instead:

UMA_HISTOGRAM_BOOLEAN("ResourcePrefetchPredictor.ResourceRequestInfo", info);

[Shishir, 2012/08/29 22:51:06]

Since this corner case happens rarely (I assume), I would like to report only
the failed case. There is no point reporting the other, just seems wasteful.

[dominich, 2012/08/29 23:16:49]

but without that how do you know if it's a significant %age or a small %age? I
think you need both to know how often it occurs.

[Shishir, 2012/08/30 03:58:36]

Redid this so we have base.

+                          true);
     return false;
   }
 
   int render_process_id, render_view_id;
   if (!info->GetAssociatedRenderView(&render_process_id, &render_view_id)) {
-    LOG(ERROR) << "Could not get RenderViewId from request info.";
+    UMA_HISTOGRAM_BOOLEAN(

[dominich, 2012/08/29 22:29:29]

as above

[Shishir, 2012/08/29 22:51:06]

as above :)

+        "ResourcePrefetchPredictor.NoRenderViewIdFromrResourceRequestInfo",

[dominich, 2012/08/29 22:29:29]

typo: FromrResource ?

[Shishir, 2012/08/29 22:51:06]

Fixed.

+        true);
     return false;
   }
 
   summary->navigation_id.render_process_id = render_process_id;
   summary->navigation_id.render_view_id = render_view_id;
   summary->navigation_id.main_frame_url = request->first_party_for_cookies();
   summary->navigation_id.creation_time = request->creation_time();
   summary->resource_url = request->original_url();
   summary->resource_type = info->GetResourceType();
   request->GetMimeType(&summary->mime_type);
@@ skipping 25 matching lines @@
         BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 void ResourcePrefetchPredictorObserver::OnRequestStarted(
     net::URLRequest* request,
     ResourceType::Type resource_type,
     int child_id,
     int route_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
+  if (resource_type == ResourceType::MAIN_FRAME) {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationStats",
+                              NAVIGATION_STATS_TOTAL_MAIN_FRAME_REQUESTS,
+                              NAVIGATION_STATS_MAX);
+  }
+
   if (!ResourcePrefetchPredictor::ShouldRecordRequest(request, resource_type))
     return;
 
   ResourcePrefetchPredictor::URLRequestSummary summary;
   summary.navigation_id.render_process_id = child_id;
   summary.navigation_id.render_view_id = route_id;
   summary.navigation_id.main_frame_url = request->first_party_for_cookies();
   summary.resource_url = request->original_url();
   summary.resource_type = resource_type;
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&ResourcePrefetchPredictor::RecordURLRequest,
                  predictor_,
                  summary));
+
+  if (resource_type == ResourceType::MAIN_FRAME) {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationStats",
+                              NAVIGATION_STATS_PROCESSED_MAIN_FRAME_REQUESTS,
+                              NAVIGATION_STATS_MAX);
+  }
 }
 
 void ResourcePrefetchPredictorObserver::OnRequestRedirected(
     const GURL& redirect_url,
     net::URLRequest* request) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
+  const content::ResourceRequestInfo* request_info =
+      content::ResourceRequestInfo::ForRequest(request);
+  if (request_info &&
+      request_info->GetResourceType() == ResourceType::MAIN_FRAME) {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationStats",
+                              NAVIGATION_STATS_TOTAL_MAIN_FRAME_REDIRECTS,
+                              NAVIGATION_STATS_MAX);
+  }
+
   if (!ResourcePrefetchPredictor::ShouldRecordRedirect(request))
     return;
 
   ResourcePrefetchPredictor::URLRequestSummary summary;
   if (!SummarizeResponse(request, &summary))
     return;
 
   summary.redirect_url = redirect_url;
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&ResourcePrefetchPredictor::RecordUrlRedirect,
                  predictor_,
                  summary));
+
+  if (request_info &&
+      request_info->GetResourceType() == ResourceType::MAIN_FRAME) {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationStats",
+                              NAVIGATION_STATS_PROCESSED_MAIN_FRAME_REDIRECTS,
+                              NAVIGATION_STATS_MAX);
+  }
 }
 
 void ResourcePrefetchPredictorObserver::OnResponseStarted(
     net::URLRequest* request) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
+  const content::ResourceRequestInfo* request_info =
+      content::ResourceRequestInfo::ForRequest(request);
+  if (request_info &&
+      request_info->GetResourceType() == ResourceType::MAIN_FRAME) {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationStats",
+                              NAVIGATION_STATS_TOTAL_MAIN_FRAME_RESPONSES,
+                              NAVIGATION_STATS_MAX);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationStats",
+                              NAVIGATION_STATS_TOTAL_SUBRESOURCE_RESPONSES,
+                              NAVIGATION_STATS_MAX);
+  }
+
   if (!ResourcePrefetchPredictor::ShouldRecordResponse(request))
     return;
   ResourcePrefetchPredictor::URLRequestSummary summary;
   if (!SummarizeResponse(request, &summary))
     return;
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&ResourcePrefetchPredictor::RecordUrlResponse,
                  predictor_,
                  summary));
+
+  if (request_info &&
+      request_info->GetResourceType() == ResourceType::MAIN_FRAME) {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationStats",
+                              NAVIGATION_STATS_PROCESSED_MAIN_FRAME_RESPONSES,
+                              NAVIGATION_STATS_MAX);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationStats",
+                              NAVIGATION_STATS_PROCESSED_SUBRESOURCE_RESPONSES,
+                              NAVIGATION_STATS_MAX);
+  }
 }
 
 }  // namespace chrome_browser_net