[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 "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;
-}
+}  // 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) {

[pasko, 2016/08/30 13:41:04]

is it possible to detect redirects on the path to main resource here? If yes,
then we could make more buckets: "MAIN_RESOURCE_REDIRECTS_ALL_CACHEABLE",
"MAIN_RESOURCE_REDIRECTS_SOME_NO_STORE"

TODO for later would SG to me as well

[droger, 2016/08/30 14:31:41]

Good idea.

We can detect redirects easily, and reporting each redirect should be easy.

Reporting info regarding the whole redirect chain may be harder but probably
doable too. However, this would probably be in a separate histogram in this
case? I'll do this in a separate CL because it may not be trivial.

+  *defer = false;

[pasko, 2016/08/30 13:41:04]

I am not familiar with resource throttle API, of course, but ..

other implementations of WillProcessResponse seem to mostly avoid touching the
output argument on early return (such as when ResourceRequestInfo not
available). Seems safer in various edge cases when info is not available during
hypothetical shutdown and the space for |defer| is already gone.

[droger, 2016/08/30 14:31:41]

Done.

I wondered about this, and both cases definitely exist in the codebase. I don't
have a strong preference.

+
+  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::WillProcessResponseOnUI,
+                 content::IsResourceTypeFrame(info->GetResourceType()),
+                 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::WillProcessResponseOnUI(bool is_main_resource,
+                                                        bool is_no_store,
+                                                        int render_process_id,
+                                                        int render_frame_id) {
+  PrerenderContents* prerender_contents =

[pasko, 2016/08/30 13:41:05]

nit: DCHECK_CURRENTLY_ON

+      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);
+}
+
+// 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