Plumbing for variations headers from synthetic field trials.

components/variations/net/variations_http_header_provider.cc

 // Copyright 2014 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/variations/net/variations_http_header_provider.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/memory/singleton.h"
@@ skipping 119 matching lines @@
 
   base::AutoLock scoped_lock(lock_);
   if (new_id != EMPTY_ID)
     variation_ids_set_.insert(new_id);
   if (new_trigger_id != EMPTY_ID)
     variation_trigger_ids_set_.insert(new_trigger_id);
 
   UpdateVariationIDsHeaderValue();
 }
 
+void VariationsHttpHeaderProvider::OnSyntheticTrialsChanged(
+    const std::vector<metrics::SyntheticTrialGroup>& groups) {
+  base::AutoLock scoped_lock(lock_);
+
+  synthetic_variation_ids_set_.clear();
+  for (const metrics::SyntheticTrialGroup& group : groups) {
+    const VariationID id =
+        GetGoogleVariationIDFromHashes(GOOGLE_WEB_PROPERTIES, group.id);

[jwd, 2014/10/31 18:50:26]

Are there no plans to support triggering experiments?

[Alexei Svitkine (slow), 2014/10/31 18:51:06]

Not currently. The goal is to enable analysis, not change behavior.

+    if (id != EMPTY_ID)
+      synthetic_variation_ids_set_.insert(id);
+  }
+  UpdateVariationIDsHeaderValue();
+}
+
 void VariationsHttpHeaderProvider::InitVariationIDsCacheIfNeeded() {
   base::AutoLock scoped_lock(lock_);
   if (variation_ids_cache_initialized_)
     return;
 
   // Register for additional cache updates. This is done first to avoid a race
   // that could cause registered FieldTrials to be missed.
   DCHECK(base::MessageLoop::current());
   base::FieldTrialList::AddObserver(this);
 
@@ skipping 29 matching lines @@
 }
 
 void VariationsHttpHeaderProvider::UpdateVariationIDsHeaderValue() {
   lock_.AssertAcquired();
 
   // The header value is a serialized protobuffer of Variation IDs which is
   // base64 encoded before transmitting as a string.
   variation_ids_header_.clear();
 
   if (variation_ids_set_.empty() && default_variation_ids_set_.empty() &&
-      variation_trigger_ids_set_.empty() && default_trigger_id_set_.empty()) {
+      variation_trigger_ids_set_.empty() && default_trigger_id_set_.empty() &&
+      synthetic_variation_ids_set_.empty()) {
     return;
   }
 
   // This is the bottleneck for the creation of the header, so validate the size
   // here. Force a hard maximum on the ID count in case the Variations server
   // returns too many IDs and DOSs receiving servers with large requests.
   const size_t total_id_count =
       variation_ids_set_.size() + variation_trigger_ids_set_.size();
   DCHECK_LE(total_id_count, 10U);
   UMA_HISTOGRAM_COUNTS_100("Variations.Headers.ExperimentCount",
                            total_id_count);
   if (total_id_count > 20)
     return;
 
   // Merge the two sets of experiment ids.
   std::set<VariationID> all_variation_ids_set = default_variation_ids_set_;
-  for (std::set<VariationID>::const_iterator it = variation_ids_set_.begin();
-       it != variation_ids_set_.end(); ++it) {
-    all_variation_ids_set.insert(*it);
-  }
-  ClientVariations proto;
-  for (std::set<VariationID>::const_iterator it = all_variation_ids_set.begin();
-       it != all_variation_ids_set.end(); ++it) {
-    proto.add_variation_id(*it);
-  }
+  for (VariationID id : variation_ids_set_)
+    all_variation_ids_set.insert(id);
+  for (VariationID id : synthetic_variation_ids_set_)
+    all_variation_ids_set.insert(id);
 
   std::set<VariationID> all_trigger_ids_set = default_trigger_id_set_;
-  for (std::set<VariationID>::const_iterator it =
-           variation_trigger_ids_set_.begin();
-       it != variation_trigger_ids_set_.end(); ++it) {
-    all_trigger_ids_set.insert(*it);
-  }
-  for (std::set<VariationID>::const_iterator it = all_trigger_ids_set.begin();
-       it != all_trigger_ids_set.end(); ++it) {
-    proto.add_trigger_variation_id(*it);
-  }
+  for (VariationID id : variation_trigger_ids_set_)
+    all_trigger_ids_set.insert(id);
+
+  ClientVariations proto;
+  for (VariationID id : all_variation_ids_set)
+    proto.add_variation_id(id);
+  for (VariationID id : all_trigger_ids_set)
+    proto.add_trigger_variation_id(id);
 
   std::string serialized;
   proto.SerializeToString(&serialized);
 
   std::string hashed;
   base::Base64Encode(serialized, &hashed);
   // If successful, swap the header value with the new one.
   // Note that the list of IDs and the header could be temporarily out of sync
   // if IDs are added as the header is recreated. The receiving servers are OK
   // with such discrepancies.
@@ skipping 16 matching lines @@
   for (size_t i = 0; i < arraysize(kSuffixesToSetHeadersFor); ++i) {
     if (EndsWith(host, kSuffixesToSetHeadersFor[i], false))
       return true;
   }
 
   return google_util::IsYoutubeDomainUrl(url, google_util::ALLOW_SUBDOMAIN,
                                          google_util::ALLOW_NON_STANDARD_PORTS);
 }
 
 }  // namespace variations