Create a synthetic field trial for precache.

components/precache/content/precache_manager.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 "components/precache/content/precache_manager.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 45 matching lines @@
   return kNumTopHosts;
 }
 
 PrecacheManager::PrecacheManager(
     content::BrowserContext* browser_context,
     const syncer::SyncService* const sync_service,
     const history::HistoryService* const history_service,
     const data_reduction_proxy::DataReductionProxySettings*
         data_reduction_proxy_settings,
     const base::FilePath& db_path,
-    std::unique_ptr<PrecacheDatabase> precache_database)
+    std::unique_ptr<PrecacheDatabase> precache_database,
+    const base::Callback<void(const base::Time&)>&
+        register_synthetic_field_trial_callback)
     : browser_context_(browser_context),
       sync_service_(sync_service),
       history_service_(history_service),
       data_reduction_proxy_settings_(data_reduction_proxy_settings),
-      is_precaching_(false) {
+      is_precaching_(false),
+      register_synthetic_field_trial_callback_(
+          register_synthetic_field_trial_callback) {
   precache_database_ = std::move(precache_database);
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(base::IgnoreResult(&PrecacheDatabase::Init),
                  base::Unretained(precache_database_.get()), db_path));
+  BrowserThread::PostTaskAndReplyWithResult(

[jamartin, 2016/12/21 23:54:33]

There are no race conditions between these two tasks, are there?

[twifkak, 2017/01/05 23:53:14]

Assuming you mean the potential race between Init and GetLastPrecacheTimestamp:

It turns out there isn't, but it's not obvious. PostTaskAndReplyWithResult posts
a nestable post task, which means that it could be started before the previous
tasks are finished, according to sequenced_task_runner.h. However, AFAICT, while
SequencedTaskRunner is an interface, the actually implementation of the task
runner is backed by a base::MessageLoop with NestableTasksAllowed() == false.
(Verified with a DCHECK running on my phone.)

OTOH, even if there is a race, the return value of GetLastPrecacheTimestamp when
!IsDatabaseAccessible() is a "null" base::Time, which would simply result in no
synth trials being registered. Certainly not what I want, but not a crash.

+      BrowserThread::DB, FROM_HERE,
+      base::Bind(&PrecacheDatabase::GetLastPrecacheTimestamp,
+                 base::Unretained(precache_database_.get())),
+      base::Bind(&PrecacheManager::RegisterSyntheticFieldTrial, AsWeakPtr()));
 }
 
 PrecacheManager::~PrecacheManager() {
   // DeleteSoon posts a non-nestable task to the task runner, so any previously
   // posted tasks that rely on an Unretained precache_database_ will finish
   // before it is deleted.
   BrowserThread::DeleteSoon(BrowserThread::DB, FROM_HERE,
                             precache_database_.release());
 }
 
+void PrecacheManager::RegisterSyntheticFieldTrial(
+    const base::Time& last_precache_time) {
+  register_synthetic_field_trial_callback_.Run(last_precache_time);
+}
+
 bool PrecacheManager::IsInExperimentGroup() const {
   // Verify IsPrecachingAllowed() before calling FieldTrialList::FindFullName().
   // This is because field trials are only assigned when requested. This allows
   // us to create Control and Experiment groups that are limited to users for
   // whom PrecachingAllowed() is true, thus accentuating the impact of
   // precaching.
   return IsPrecachingAllowed() &&
          (base::StartsWith(
               base::FieldTrialList::FindFullName(kPrecacheFieldTrialName),
               kPrecacheFieldTrialEnabledGroup, base::CompareCase::SENSITIVE) ||
@@ skipping 384 matching lines @@
       this));
   precache_fetcher_->Start();
 }
 
 void PrecacheManager::OnHostsReceivedThenDone(
     const history::TopHostsList& host_counts) {
   OnDone();
 }
 
 }  // namespace precache