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 statistics pertaining to observed request, responses and
+// redirects.
+enum RequestStats {
+  REQUEST_STATS_TOTAL_RESPONSES = 0,
+  REQUEST_STATS_TOTAL_PROCESSED_RESPONSES = 1,
+  REQUEST_STATS_NO_RESOURCE_REQUEST_INFO = 2,
+  REQUEST_STATS_NO_RENDER_VIEW_ID_FROM_REQUEST_INFO = 3,
+  REQUEST_STATS_MAX = 4,
+};
+
+// Specific to main frame requests.
+enum MainFrameRequestStats {
+  MAIN_FRAME_REQUEST_STATS_TOTAL_REQUESTS = 0,
+  MAIN_FRAME_REQUEST_STATS_PROCESSED_REQUESTS = 1,
+  MAIN_FRAME_REQUEST_STATS_TOTAL_REDIRECTS = 2,
+  MAIN_FRAME_REQUEST_STATS_PROCESSED_REDIRECTS = 3,
+  MAIN_FRAME_REQUEST_STATS_TOTAL_RESPONSES = 4,
+  MAIN_FRAME_REQUEST_STATS_PROCESSED_RESPONSES = 5,
+  MAIN_FRAME_REQUEST_STATS_MAX = 6,
+};
+
 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_ENUMERATION("ResourcePrefetchPredictor.RequestStats",
+                              REQUEST_STATS_NO_RESOURCE_REQUEST_INFO,
+                              REQUEST_STATS_MAX);
     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_ENUMERATION("ResourcePrefetchPredictor.RequestStats",

[mmenke, 2012/09/04 17:19:46]

Rather than duplicate these two strings all over the place, I'd suggest one
wrapper function for each.

[Shishir, 2012/09/04 17:30:55]

This would be hard to do efficiently. The histogram macro uses a static pointer
which is initialized only once, so to create a  function with a single macro
call is not possible. I can do this by not using the macro and not using a
static pointer, but that would be pretty inefficient since this counter gets
called for every resource request, response etc. 

+                              REQUEST_STATS_NO_RENDER_VIEW_ID_FROM_REQUEST_INFO,
+                              REQUEST_STATS_MAX);
     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.MainFrameRequestStats",
+                              MAIN_FRAME_REQUEST_STATS_TOTAL_REQUESTS,
+                              MAIN_FRAME_REQUEST_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.MainFrameRequestStats",
+                              MAIN_FRAME_REQUEST_STATS_PROCESSED_REQUESTS,
+                              MAIN_FRAME_REQUEST_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.MainFrameRequestStats",
+                              MAIN_FRAME_REQUEST_STATS_TOTAL_REDIRECTS,
+                              MAIN_FRAME_REQUEST_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.MainFrameRequestStats",
+                              MAIN_FRAME_REQUEST_STATS_PROCESSED_REDIRECTS,
+                              MAIN_FRAME_REQUEST_STATS_MAX);
+  }
 }
 
 void ResourcePrefetchPredictorObserver::OnResponseStarted(
     net::URLRequest* request) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
+  UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.RequestStats",
+                            REQUEST_STATS_TOTAL_RESPONSES,
+                            REQUEST_STATS_MAX);
+
+  const content::ResourceRequestInfo* request_info =
+      content::ResourceRequestInfo::ForRequest(request);
+  if (request_info &&
+      request_info->GetResourceType() == ResourceType::MAIN_FRAME) {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.MainFrameRequestStats",
+                              MAIN_FRAME_REQUEST_STATS_TOTAL_RESPONSES,
+                              MAIN_FRAME_REQUEST_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));
+
+  UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.RequestStats",
+                            REQUEST_STATS_TOTAL_PROCESSED_RESPONSES,
+                            REQUEST_STATS_MAX);
+  if (request_info &&
+      request_info->GetResourceType() == ResourceType::MAIN_FRAME) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "ResourcePrefetchPredictor.NavigationStatsMainFrame",
+        MAIN_FRAME_REQUEST_STATS_PROCESSED_RESPONSES,
+        MAIN_FRAME_REQUEST_STATS_MAX);
+  }
 }
 
 }  // namespace chrome_browser_net