[NoStatePrefetch] Add UMA histogram to count prefetch requests

chrome/browser/prerender/prerender_resource_throttle.cc

 // Copyright 2013 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/prerender/prerender_resource_throttle.h"
 
+#include "base/metrics/histogram_macros.h"
 #include "build/build_config.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
+#include "net/http/http_response_headers.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request.h"
 
 using content::ResourceType;
 
 namespace prerender {
 
 namespace {
+
+// This enum is used to define the buckets for an enumerated UMA histogram.
+// Hence, existing enumerated constants should never be deleted or reordered,
+// and new constants should only be appended at the end of the enumeration.
+enum NoStatePrefetchResourceType {

[pasko, 2016/08/30 09:43:33]

nit: enum class is shiny and modern

+  kMainResourceCacheable = 0,
+  kMainResourceNoStore = 1,
+  kSubResourceCacheable = 2,
+  kSubResourceNoStore = 3,
+
+  kNoStatePrefetchResourceTypeCount  // Must be the last.
+};
+
 static const char kFollowOnlyWhenPrerenderShown[] =
     "follow-only-when-prerender-shown";
 
 PrerenderContents* g_prerender_contents_for_testing;
-}
+
+}  // namespace
 
 void PrerenderResourceThrottle::OverridePrerenderContentsForTesting(
     PrerenderContents* contents) {
   g_prerender_contents_for_testing = contents;
 }
 
 PrerenderResourceThrottle::PrerenderResourceThrottle(net::URLRequest* request)
     : request_(request) {
 }
 
@@ skipping 21 matching lines @@
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&PrerenderResourceThrottle::WillRedirectRequestOnUI,
                  AsWeakPtr(), header, info->GetResourceType(), info->IsAsync(),
                  info->GetChildID(), info->GetRenderFrameID(),
                  redirect_info.new_url));
 }
 
+void PrerenderResourceThrottle::WillProcessResponse(bool* defer) {
+  *defer = false;
+
+  const content::ResourceRequestInfo* info =
+      content::ResourceRequestInfo::ForRequest(request_);
+  if (!info)
+    return;
+
+  bool is_no_store = false;
+  const net::HttpResponseInfo& response_info = request_->response_info();
+  if (response_info.headers.get()) {
+    is_no_store =
+        response_info.headers->HasHeaderValue("cache-control", "no-store");
+  }
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&PrerenderResourceThrottle::UpdatePrefetchHistogramOnUI,
+                 content::IsResourceTypeFrame(info->GetResourceType()),

[pasko, 2016/08/30 09:43:33]

will main resource redirects be recorded as sub-resources? that's unfortunate
because they may prevent serving the main resource only from cache

+                 is_no_store, info->GetChildID(), info->GetRenderFrameID()));
+}
+
 const char* PrerenderResourceThrottle::GetNameForLogging() const {
   return "PrerenderResourceThrottle";
 }
 
 void PrerenderResourceThrottle::Resume() {
   controller()->Resume();
 }
 
 void PrerenderResourceThrottle::Cancel() {
   controller()->Cancel();
 }
 
+// static
 void PrerenderResourceThrottle::WillStartRequestOnUI(
     const base::WeakPtr<PrerenderResourceThrottle>& throttle,
     const std::string& method,
     ResourceType resource_type,
     int render_process_id,
     int render_frame_id,
     const GURL& url) {
   bool cancel = false;
   PrerenderContents* prerender_contents =
       PrerenderContentsFromRenderFrame(render_process_id, render_frame_id);
@@ skipping 17 matching lines @@
     }
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(cancel ? &PrerenderResourceThrottle::Cancel :
                  &PrerenderResourceThrottle::Resume, throttle));
 }
 
+// static
 void PrerenderResourceThrottle::WillRedirectRequestOnUI(
     const base::WeakPtr<PrerenderResourceThrottle>& throttle,
     const std::string& follow_only_when_prerender_shown_header,
     ResourceType resource_type,
     bool async,
     int render_process_id,
     int render_frame_id,
     const GURL& new_url) {
   bool cancel = false;
   PrerenderContents* prerender_contents =
@@ skipping 21 matching lines @@
     }
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(cancel ? &PrerenderResourceThrottle::Cancel :
                  &PrerenderResourceThrottle::Resume, throttle));
 }
 
+// static
+void PrerenderResourceThrottle::UpdatePrefetchHistogramOnUI(
+    bool is_main_resource,
+    bool is_no_store,
+    int render_process_id,
+    int render_frame_id) {
+  PrerenderContents* prerender_contents =
+      PrerenderContentsFromRenderFrame(render_process_id, render_frame_id);
+  if (!prerender_contents)
+    return;
+
+  if (prerender_contents->prerender_mode() != PREFETCH_ONLY)
+    return;
+
+  NoStatePrefetchResourceType type =
+      is_main_resource
+          ? (is_no_store ? kMainResourceNoStore : kMainResourceCacheable)
+          : (is_no_store ? kSubResourceNoStore : kSubResourceCacheable);
+  UMA_HISTOGRAM_ENUMERATION("Prerender.NoStatePrefetchResourceCount", type,
+                            kNoStatePrefetchResourceTypeCount);
+}
+
+// static
 PrerenderContents* PrerenderResourceThrottle::PrerenderContentsFromRenderFrame(
     int render_process_id, int render_frame_id) {
   if (g_prerender_contents_for_testing)
     return g_prerender_contents_for_testing;
   content::RenderFrameHost* rfh = content::RenderFrameHost::FromID(
       render_process_id, render_frame_id);
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(rfh);
   return PrerenderContents::FromWebContents(web_contents);
 }
 
 }  // namespace prerender