Implement plumbing for variations in feedback reports.

components/variations/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/variations_http_header_provider.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 18 matching lines @@
   InitVariationIDsCacheIfNeeded();
 
   std::string variation_ids_header_copy;
   {
     base::AutoLock scoped_lock(lock_);
     variation_ids_header_copy = variation_ids_header_;
   }
   return variation_ids_header_copy;
 }
 
+std::string VariationsHttpHeaderProvider::GetVariationsString() {
+  InitVariationIDsCacheIfNeeded();
+
+  // Construct a space-separated string with leading and trailing spaces from
+  // the variations set. Note: The ids in it will be in sorted order per the
+  // std::set contract.
+  std::string ids_string = " ";
+  {
+    base::AutoLock scoped_lock(lock_);
+    for (VariationID id : GetAllVariationIds()) {
+      ids_string.append(base::IntToString(id));
+      ids_string.push_back(' ');
+    }
+  }
+  return ids_string;
+}
+
 bool VariationsHttpHeaderProvider::SetDefaultVariationIds(
     const std::string& variation_ids) {
   default_variation_ids_set_.clear();
   default_trigger_id_set_.clear();
   for (const base::StringPiece& entry : base::SplitStringPiece(
            variation_ids, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     if (entry.empty()) {
       default_variation_ids_set_.clear();
       default_trigger_id_set_.clear();
       return false;
@@ skipping 71 matching lines @@
 
   // 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);
 
   base::TimeTicks before_time = base::TimeTicks::Now();
 
   base::FieldTrial::ActiveGroups initial_groups;
   base::FieldTrialList::GetActiveFieldTrialGroups(&initial_groups);
-  for (base::FieldTrial::ActiveGroups::const_iterator it =
-           initial_groups.begin();
-       it != initial_groups.end(); ++it) {
-    const VariationID id = GetGoogleVariationID(GOOGLE_WEB_PROPERTIES,
-                                                it->trial_name, it->group_name);
+
+  for (const auto& entry : initial_groups) {
+    const VariationID id =
+        GetGoogleVariationID(GOOGLE_WEB_PROPERTIES, entry.trial_name,
+                             entry.group_name);
     if (id != EMPTY_ID)
       variation_ids_set_.insert(id);
 
-    const VariationID trigger_id = GetGoogleVariationID(
-        GOOGLE_WEB_PROPERTIES_TRIGGER, it->trial_name, it->group_name);
+    const VariationID trigger_id =
+        GetGoogleVariationID(GOOGLE_WEB_PROPERTIES_TRIGGER, entry.trial_name,
+                             entry.group_name);
+
     if (trigger_id != EMPTY_ID)
       variation_trigger_ids_set_.insert(trigger_id);
   }
   UpdateVariationIDsHeaderValue();
 
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "Variations.HeaderConstructionTime",
       (base::TimeTicks::Now() - before_time).InMicroseconds(), 0,
       base::TimeDelta::FromSeconds(1).InMicroseconds(), 50);
 
@@ skipping 17 matching lines @@
   // 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 (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_variation_ids_set = GetAllVariationIds();
   std::set<VariationID> all_trigger_ids_set = default_trigger_id_set_;
   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.
   variation_ids_header_ = hashed;
 }
 
+std::set<VariationID> VariationsHttpHeaderProvider::GetAllVariationIds() {
+  lock_.AssertAcquired();
+
+  std::set<VariationID> all_variation_ids_set = default_variation_ids_set_;
+  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);
+  return all_variation_ids_set;
+}
+
 }  // namespace variations