Experiment to disable Prerendering with fast wind-down

chrome/browser/prerender/prerender_manager.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/prerender/prerender_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/timer/elapsed_timer.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/prerender/prerender_contents.h"
@@ skipping 573 matching lines @@
 // static
 bool PrerenderManager::IsNoUseGroup() {
   return GetMode() == PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP;
 }
 
 // static
 bool PrerenderManager::IsNoStatePrefetch() {
   return GetMode() == PRERENDER_MODE_NOSTATE_PREFETCH;
 }
 
+bool PrerenderManager::IsPrerenderSilenceExperiment() {
+  // The group name should contain expiration time formatted as:
+  //   "ExperimentYes_expires_YYYY-MM-DDTHH:MM:SSZ".
+  std::string group_name =
+      base::FieldTrialList::FindFullName("PrerenderSilence");
+  const char kExperimentPrefix[] = "ExperimentYes";
+  if (!base::StartsWith(group_name, kExperimentPrefix,
+                        base::CompareCase::INSENSITIVE_ASCII)) {
+    return false;
+  }
+  const char kExperimentPrefixWithExpiration[] = "ExperimentYes_expires_";
+  if (!base::StartsWith(group_name, kExperimentPrefixWithExpiration,
+                        base::CompareCase::INSENSITIVE_ASCII)) {
+    // Without expiration day in the group name, behave as a normal experiment,
+    // i.e. sticky to the Chrome session.
+    return true;

[mattcary, 2016/08/25 16:15:21]

Not to belabor the point, but won't we turn in the experiment on unconditionally
if we have a flag like "ExperimentYes_until_2016-11-20"? That seems a little
permissive. I was thinking it would be safer to do something like:
if (group_name == kExperimentPrefix) return true;
else if (!StartsWith(kExperimentPrefixWithExperiation))  return false;

[pasko, 2016/08/25 16:25:39]

That's because we commonly like suffixing experiment groups: "ExperimentYes1",
"ExperimentYes2" etc. In case we wanted to see on Beta, say, how much noise
there is in the number of crashes per client. Not sure it is applicable here,
just following the common practice to allow suffixes.

+  }
+  base::Time expiration_time;
+  if (!base::Time::FromString(
+          group_name.c_str() + (arraysize(kExperimentPrefixWithExpiration) - 1),
+          &expiration_time)) {

[mmenke, 2016/08/25 19:22:50]

Why is this needed?  Experiments can have their expiration time on the server.

[pasko, 2016/08/26 11:22:12]

Server-based experiments are sticky until Chrome is restarted. By encoding an
additional expiration time here we can cut off the experiment faster. Not sure
it really affects a large volume of users, but estimating the number was not
easy. Also I am one of the users who does not like surprises to take effect for
a long time, and restarts Chrome once every 3 weeks (huge mistake, I know), so
this final straw convinced me that this extra small piece of code is handy to
provide a fast experiment wind down.

There are a few details in the doc linked from the bug.

[mmenke, 2016/08/26 16:44:47]

I remain extremely skeptical this serves any useful purpose, but not going to
fight over it.

[pasko, 2016/08/26 17:39:31]

Thank you. I am somewhat skeptical too, but figuring out how much skeptical I
should be was not worth it.

+    DLOG(ERROR) << "Could not parse expiration date in group: " << group_name;
+    return false;
+  }
+  return GetCurrentTime() < expiration_time;
+}
+
 bool PrerenderManager::IsWebContentsPrerendering(
     const WebContents* web_contents,
     Origin* origin) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PrerenderContents* prerender_contents = GetPrerenderContents(web_contents);
   if (!prerender_contents)
     return false;
 
   if (origin)
     *origin = prerender_contents->origin();
@@ skipping 251 matching lines @@
   // those prerenders is managed by the offliner.
   if (IsLowEndDevice() && origin != ORIGIN_OFFLINE)
     return nullptr;
 
   if ((origin == ORIGIN_LINK_REL_PRERENDER_CROSSDOMAIN ||
        origin == ORIGIN_LINK_REL_PRERENDER_SAMEDOMAIN) &&
       IsGoogleSearchResultURL(referrer.url)) {
     origin = ORIGIN_GWS_PRERENDER;
   }
 
+  if (origin != ORIGIN_OFFLINE && IsPrerenderSilenceExperiment())
+    return nullptr;
+
   GURL url = url_arg;
   GURL alias_url;
   if (IsControlGroup() && MaybeGetQueryStringBasedAliasURL(url, &alias_url))
     url = alias_url;
 
   // From here on, we will record a FinalStatus so we need to register with the
   // histogram tracking.
   histograms_->RecordPrerender(origin, url_arg);
 
   if (profile_->GetPrefs()->GetBoolean(prefs::kBlockThirdPartyCookies) &&
@@ skipping 412 matching lines @@
   DCHECK_EQ(1u, erased);
 }
 
 void PrerenderManager::SetPrerenderContentsFactoryForTest(
     PrerenderContents::Factory* prerender_contents_factory) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
 }  // namespace prerender