Add a field trial to delay all resource requests by thread hops.

chrome/browser/renderer_host/thread_hop_resource_throttle.cc

+// Copyright 2015 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/renderer_host/thread_hop_resource_throttle.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/location.h"
+#include "base/metrics/field_trial.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/strings/string_util.h"
+#include "base/time/time.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/resource_controller.h"

[mmenke, 2015/10/01 21:37:33]

include header for RedirectInfo?

[davidben, 2015/10/01 22:06:25]

The forward-decl from resource_throttle.h should be sufficient I think since
we're not actually doing anything with that type. Or do we want to include it
there anyway?

[mmenke, 2015/10/01 22:12:20]

Ah, right.

+
+ThreadHopResourceThrottle::ThreadHopResourceThrottle() : weak_factory_(this) {}
+
+ThreadHopResourceThrottle::~ThreadHopResourceThrottle() {}
+
+// static

[mmenke, 2015/10/01 21:36:01]

nit:  New style guide doesn't require comments like this.

[davidben, 2015/10/01 22:06:25]

Really? I rather liked those. :-( Removed.

+bool ThreadHopResourceThrottle::IsEnabled() {
+  const std::string group_name =
+      base::FieldTrialList::FindFullName("ThreadHopResourceThrottle");
+  return base::StartsWith(group_name, "Enabled", base::CompareCase::SENSITIVE);
+}
+
+void ThreadHopResourceThrottle::WillStartRequest(bool* defer) {
+  *defer = true;
+  ResumeAfterThreadHop();
+}
+
+void ThreadHopResourceThrottle::WillRedirectRequest(
+    const net::RedirectInfo& redirect_info,
+    bool* defer) {
+  *defer = true;
+  ResumeAfterThreadHop();
+}
+
+void ThreadHopResourceThrottle::WillProcessResponse(bool* defer) {
+  *defer = true;
+  ResumeAfterThreadHop();
+}
+
+const char* ThreadHopResourceThrottle::GetNameForLogging() const {
+  return "ThreadHopResourceThrottle";
+}
+
+void ThreadHopResourceThrottle::ResumeAfterThreadHop() {
+  content::BrowserThread::PostTaskAndReply(
+      content::BrowserThread::UI, FROM_HERE, base::Bind(&base::DoNothing),
+      base::Bind(&ThreadHopResourceThrottle::Resume, weak_factory_.GetWeakPtr(),
+                 base::TimeTicks::Now()));
+}
+
+void ThreadHopResourceThrottle::Resume(const base::TimeTicks& time) {
+  UMA_HISTOGRAM_CUSTOM_TIMES("Net.ThreadHopResourceThrottleTime",
+                             base::TimeTicks::Now() - time,
+                             base::TimeDelta::FromSeconds(0),

[mmenke, 2015/10/01 21:36:01]

base::TimeDelta()?  Or base::TimeDelta::FromMilliseconds(0) - seems weird to mix
seconds and milliseconds.

[davidben, 2015/10/01 22:06:25]

Done.

+                             base::TimeDelta::FromMilliseconds(100), 100);

[mmenke, 2015/10/01 21:36:01]

I don't think we need 100 buckets?  I think even 20 would be more than enough.

[davidben, 2015/10/01 22:06:25]

I mostly copied from elsewhere. You sure 20 is enough though? So empirically the
numbers seem to all be smushed around 0-16ms on my machine.

[mmenke, 2015/10/01 22:12:20]

I'm honestly not sure...I think 100 is way more than we need.  Think you may
want to think about what we care about.  If they're all 0-4, do we care if
they're all 0 vs 4?  Do we care about 50 vs 100 ms?

+  controller()->Resume();
+}