[NoStatePrefetch] Track redirects in UMA

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/logging.h"
+#include "base/numerics/safe_conversions.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 {
 static const char kFollowOnlyWhenPrerenderShown[] =
     "follow-only-when-prerender-shown";
 
 PrerenderContents* g_prerender_contents_for_testing;
+
+// Returns true if the response has a "no-store" cache control header.
+bool IsNoStoreResponse(const net::URLRequest& request) {
+  const net::HttpResponseInfo& response_info = request.response_info();
+  return response_info.headers.get() &&
+         response_info.headers->HasHeaderValue("cache-control", "no-store");
+}
+
 }  // namespace
 
 void PrerenderResourceThrottle::OverridePrerenderContentsForTesting(
     PrerenderContents* contents) {
   g_prerender_contents_for_testing = contents;
 }
 
 PrerenderResourceThrottle::PrerenderResourceThrottle(net::URLRequest* request)
     : request_(request) {
 }
@@ skipping 14 matching lines @@
 void PrerenderResourceThrottle::WillRedirectRequest(
     const net::RedirectInfo& redirect_info,
     bool* defer) {
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
   *defer = true;
   std::string header;
   request_->GetResponseHeaderByName(kFollowOnlyWhenPrerenderShown, &header);
 
   content::BrowserThread::PostTask(
-      content::BrowserThread::UI,
-      FROM_HERE,
+      content::BrowserThread::UI, FROM_HERE,
       base::Bind(&PrerenderResourceThrottle::WillRedirectRequestOnUI,
                  AsWeakPtr(), header, info->GetResourceType(), info->IsAsync(),
-                 info->GetChildID(), info->GetRenderFrameID(),
-                 redirect_info.new_url));
+                 IsNoStoreResponse(*request_), info->GetChildID(),
+                 info->GetRenderFrameID(), redirect_info.new_url));
 }
 
 void PrerenderResourceThrottle::WillProcessResponse(bool* defer) {
   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");
-  }
+  DCHECK_GT(request_->url_chain().size(), 0u);
+  int redirect_count =
+      base::saturated_cast<int>(request_->url_chain().size() - 1);

[pasko, 2016/09/05 14:39:48]

size() returns an unsigned int. Suppose it returns zero, then by subtracting 1
we would have an UINT_MAX, which after saturated_cast turns into INT_MAX, I
believe (modulo some weird platforms).

I wanted it to become a -1 and let the histogram code deal with it (I think they
have underflow and overflow buckets, and underflow would be easier to read on
the dashboard). This would be achievable with:

int redirect_count = base::saturated_cast<int>(request_->url_chain().size()) -
1;

WDYT?

[droger, 2016/09/05 15:03:44]

Good catch.
Of course. That's what I wanted to do, but misplaced the bracket.

 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&PrerenderResourceThrottle::WillProcessResponseOnUI,
                  content::IsResourceTypeFrame(info->GetResourceType()),
-                 is_no_store, info->GetChildID(), info->GetRenderFrameID()));
+                 IsNoStoreResponse(*request_), redirect_count,
+                 info->GetChildID(), info->GetRenderFrameID()));
 }
 
 const char* PrerenderResourceThrottle::GetNameForLogging() const {
   return "PrerenderResourceThrottle";
 }
 
 void PrerenderResourceThrottle::Resume() {
   controller()->Resume();
 }
 
@@ skipping 38 matching lines @@
       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,
+    bool is_no_store,
     int render_process_id,
     int render_frame_id,
     const GURL& new_url) {
   bool cancel = false;
   PrerenderContents* prerender_contents =
       PrerenderContentsFromRenderFrame(render_process_id, render_frame_id);
   if (prerender_contents) {
+    prerender_contents->prerender_manager()->RecordPrefetchResponseReceived(
+        prerender_contents->origin(),
+        content::IsResourceTypeFrame(resource_type), true /* is_redirect */,
+        is_no_store);
     // Abort any prerenders with requests which redirect to invalid schemes.
     if (!PrerenderManager::DoesURLHaveValidScheme(new_url)) {
       prerender_contents->Destroy(FINAL_STATUS_UNSUPPORTED_SCHEME);
       ReportUnsupportedPrerenderScheme(new_url);
       cancel = true;
     } else if (follow_only_when_prerender_shown_header == "1" &&
                resource_type != content::RESOURCE_TYPE_MAIN_FRAME) {
       // Only defer redirects with the Follow-Only-When-Prerender-Shown
       // header. Do not defer redirects on main frame loads.
       if (!async) {
@@ skipping 12 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(cancel ? &PrerenderResourceThrottle::Cancel :
                  &PrerenderResourceThrottle::Resume, throttle));
 }
 
 // static
 void PrerenderResourceThrottle::WillProcessResponseOnUI(bool is_main_resource,
                                                         bool is_no_store,
+                                                        int redirect_count,
                                                         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;
 
-  prerender_contents->prerender_manager()->RecordResourcePrefetch(
-      prerender_contents->origin(), is_main_resource, is_no_store);
+  prerender_contents->prerender_manager()->RecordPrefetchResponseReceived(
+      prerender_contents->origin(), is_main_resource, false /* is_redirect */,
+      is_no_store);
+  prerender_contents->prerender_manager()->RecordPrefetchRedirectCount(
+      prerender_contents->origin(), is_main_resource, redirect_count);
 }
 
 // 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