Create a synthetic field trial for precache

chrome/browser/precache/precache_util.cc

 // Copyright 2016 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/precache/precache_util.h"
 
-#include "base/time/time.h"
+#include "base/metrics/field_trial.h"
+#include "base/strings/string_util.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
 #include "chrome/browser/precache/precache_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "components/data_use_measurement/content/content_url_request_classifier.h"
 #include "components/precache/content/precache_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/url_request/url_request.h"
 #include "url/gurl.h"
 
 namespace net {
 class HttpResponseInfo;
 }
 
 namespace {
 
+const char kPrecacheFieldTrialName[] = "Precache";
+const char kPrecacheSyntheticFieldTrialName[] = "PrecacheSynthetic";
+
+// Users who precached in the last |kDaysForPrecacheCandidates| days will be
+// treated as precache candidates.
+const size_t kDaysForPrecacheCandidates = 15;
+
 void UpdatePrecacheMetricsAndStateOnUIThread(const GURL& url,
                                              const GURL& referrer,
                                              base::TimeDelta latency,
                                              const base::Time& fetch_time,
                                              const net::HttpResponseInfo& info,
                                              int64_t size,
                                              bool is_user_traffic,
                                              void* profile_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
@@ skipping 29 matching lines @@
   // Record precache metrics when a fetch is completed successfully, if
   // precaching is allowed.
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&UpdatePrecacheMetricsAndStateOnUIThread, request->url(),
                  GURL(request->referrer()), latency, base::Time::Now(),
                  request->response_info(), received_content_length,
                  data_use_measurement::IsUserRequest(*request), profile_id));
 }
 
+void RegisterPrecacheSyntheticFieldTrial(const base::Time& last_precache_time) {
+  if (base::Time::Now() - last_precache_time <=
+      base::TimeDelta::FromDays(kDaysForPrecacheCandidates)) {
+    const auto& group_name =
+        base::FieldTrialList::FindFullName(kPrecacheFieldTrialName);
+    if (!group_name.empty()) {
+      ChromeMetricsServiceAccessor::RegisterSyntheticFieldTrial(

[twifkak, 2016/12/08 21:49:22]

Ooh, how about a multi-group field trial? Just learned about it now. It occurs
to me the next question we will ask is "What about only people who precached
yesterday?"

Some proof-of-concept code:

const size_t kDaysForRecentPrecacheCandidates = 1;

std::vector<uint32_t> groups;
base::TimeDelta time_ago = base::Time::Now() - last_precache_time;
if (time_ago <= base::TimeDelta::FromDays(kDaysForPrecacheCandidates))
  groups.push_back(metrics::HashName(group_name);
if (time_ago <=
    base::TimeDelta::FromDays(kDaysForRecentPrecacheCandidates))
  groups.push_back(metrics::HashName(group_name + "Recent");
RegisterSyntheticMultiGroupFieldTrial(
  kPrecacheSyntheticFieldTrialName, groups);

+          kPrecacheSyntheticFieldTrialName, group_name);
+    }
+  }
+}
+
 }  // namespace precache