Support add-on 'field trial' records.

components/metrics/persistent_system_profile.cc

 // Copyright 2017 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/metrics/persistent_system_profile.h"
 
+#include <set>
+
 #include "base/atomicops.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/persistent_memory_allocator.h"
+#include "base/pickle.h"
 #include "base/stl_util.h"
+#include "components/variations/active_field_trials.h"
 
 namespace metrics {
 
 namespace {
 
 // To provide atomic addition of records so that there is no confusion between
 // writers and readers, all of the metadata about a record is contained in a
 // structure that can be stored as a single atomic 32-bit word.
 union RecordHeader {
   struct {
@@ skipping 54 matching lines @@
     base::subtle::NoBarrier_Store(&header->as_atomic, 0);
   }
 
   // Reset member variables.
   has_complete_profile_ = false;
   alloc_reference_ = 0;
   alloc_size_ = 0;
   end_offset_ = 0;
 }
 
-bool PersistentSystemProfile::RecordAllocator::Write(
-    RecordType type,
-    const std::string& record) {
+bool PersistentSystemProfile::RecordAllocator::Write(RecordType type,
+                                                     base::StringPiece record) {
   const char* data = record.data();
   size_t remaining_size = record.size();
 
   // Allocate space and write records until everything has been stored.
   do {
     if (end_offset_ == alloc_size_) {
       if (!AddSegment(remaining_size))
         return false;
     }
     // Write out as much of the data as possible. |data| and |remaining_size|
@@ skipping 93 matching lines @@
   header.as_parts.continued = (write_size < *remaining_size);
   size_t offset = end_offset_;
   end_offset_ += CalculateRecordSize(write_size);
   DCHECK_GE(alloc_size_, end_offset_);
   if (end_offset_ < alloc_size_) {
     // An empty record header has to be next before this one gets written.
     base::subtle::NoBarrier_Store(
         reinterpret_cast<base::subtle::Atomic32*>(block + end_offset_), 0);
   }
   memcpy(block + offset + sizeof(header), *data, write_size);
-  base::subtle::Release_Store(reinterpret_cast<base::subtle::Atomic32*>(block),
-                              header.as_atomic);
+  base::subtle::Release_Store(
+      reinterpret_cast<base::subtle::Atomic32*>(block + offset),
+      header.as_atomic);
 
   // Account for what was stored and prepare for follow-on records with any
   // remaining data.
   *data += write_size;
   *remaining_size -= write_size;
 
   return true;
 }
 
 bool PersistentSystemProfile::RecordAllocator::ReadData(
@@ skipping 19 matching lines @@
     return true;  // End of all records.
   } else if (*type == kUnusedSpace) {
     *type = static_cast<RecordType>(header.as_parts.type);
   } else if (*type != header.as_parts.type) {
     NOTREACHED();  // Continuation didn't match start of record.
     *type = kUnusedSpace;
     record->clear();
     return false;
   }
   size_t read_size = header.as_parts.amount;
-  if (read_size < sizeof(header) ||
-      end_offset_ + sizeof(header) + read_size > alloc_size_) {
+  if (end_offset_ + sizeof(header) + read_size > alloc_size_) {
     NOTREACHED();  // Invalid header amount.
     *type = kUnusedSpace;
     return true;  // Don't try again.
   }
 
   // Append the record data to the output string.
-  record->append(block + sizeof(header), read_size);
+  record->append(block + end_offset_ + sizeof(header), read_size);
   end_offset_ += CalculateRecordSize(read_size);
   DCHECK_GE(alloc_size_, end_offset_);
 
   return !continued;
 }
 
 PersistentSystemProfile::PersistentSystemProfile() {}
 
 PersistentSystemProfile::~PersistentSystemProfile() {}
 
@@ skipping 24 matching lines @@
     bool complete) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   if (allocators_.empty() || serialized_profile.empty())
     return;
 
   for (auto& allocator : allocators_) {
     // Don't overwrite a complete profile with an incomplete one.
     if (!complete && allocator.has_complete_profile())
       continue;
-    // A full system profile always starts fresh.
-    allocator.Reset();
+    // A full system profile always starts fresh. Incomplete keeps existing
+    // records for merging.
+    if (complete)
+      allocator.Reset();
     // Write out the serialized profile.
     allocator.Write(kSystemProfileProto, serialized_profile);
     // Indicate if this is a complete profile.
     if (complete)
       allocator.set_complete_profile();
   }
 
   if (complete)
     all_have_complete_profile_ = true;
 }
 
 void PersistentSystemProfile::SetSystemProfile(
     const SystemProfileProto& profile,
     bool complete) {
   // Avoid serialization if passed profile is not complete and all allocators
   // already have complete ones.
   if (!complete && all_have_complete_profile_)
     return;
 
   std::string serialized_profile;
   if (!profile.SerializeToString(&serialized_profile))
     return;
   SetSystemProfile(serialized_profile, complete);
 }
 
+void PersistentSystemProfile::SetFieldTrial(base::StringPiece trial,
+                                            base::StringPiece group) {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+
+  if (trial.empty() || group.empty())
+    return;
+
+  base::Pickle pickler;
+  if (!pickler.WriteString(trial) || !pickler.WriteString(group))
+    return;
+
+  WriteToAll(kFieldTrialInfo,
+             base::StringPiece(static_cast<const char*>(pickler.data()),
+                               pickler.size()));
+}
+
 // static
 bool PersistentSystemProfile::HasSystemProfile(
     const base::PersistentMemoryAllocator& memory_allocator) {
   const RecordAllocator records(&memory_allocator);
   return records.HasMoreData();
 }
 
 // static
 bool PersistentSystemProfile::GetSystemProfile(
     const base::PersistentMemoryAllocator& memory_allocator,
     SystemProfileProto* system_profile) {
   const RecordAllocator records(&memory_allocator);
 
   RecordType type;
   std::string record;
-  if (!records.Read(&type, &record))
-    return false;
-  if (type != kSystemProfileProto)
+  do {
+    if (!records.Read(&type, &record))
+      return false;
+  } while (type != kSystemProfileProto);
+
+  if (!system_profile->ParseFromString(record))
     return false;
 
-  return system_profile->ParseFromString(record);
+  MergeExtensionRecords(memory_allocator, system_profile);
+  return true;
+}
+
+// static
+void PersistentSystemProfile::MergeExtensionRecords(
+    const base::PersistentMemoryAllocator& memory_allocator,
+    SystemProfileProto* system_profile) {
+  const RecordAllocator records(&memory_allocator);
+
+  RecordType type;
+  std::string record;
+  std::set<uint32_t> known_field_trial_ids;
+
+  while (records.Read(&type, &record)) {
+    switch (type) {
+      case kUnusedSpace:
+        // These should never be returned.
+        NOTREACHED();
+        break;
+
+      case kSystemProfileProto:
+        // Profile was passed in; ignore this one.
+        break;
+
+      case kFieldTrialInfo: {
+        // Get the set of known trial IDs so duplicates don't get added.
+        if (known_field_trial_ids.empty()) {
+          for (int i = 0; i < system_profile->field_trial_size(); ++i) {
+            const SystemProfileProto::FieldTrial& field_trial =
+                system_profile->field_trial(i);
+            known_field_trial_ids.insert(field_trial.name_id());
+          }
+        }
+
+        base::Pickle pickler(record.data(), record.size());
+        base::PickleIterator iter(pickler);
+        base::StringPiece trial;
+        base::StringPiece group;
+        if (iter.ReadStringPiece(&trial) && iter.ReadStringPiece(&group)) {
+          variations::ActiveGroupId field_ids =
+              variations::MakeActiveGroupId(trial, group);
+          if (!base::ContainsKey(known_field_trial_ids, field_ids.name)) {
+            SystemProfileProto::FieldTrial* field_trial =
+                system_profile->add_field_trial();
+            field_trial->set_name_id(field_ids.name);
+            field_trial->set_group_id(field_ids.group);
+            known_field_trial_ids.insert(field_ids.name);
+          }
+        }
+      } break;
+    }
+  }
+}
+
+void PersistentSystemProfile::WriteToAll(RecordType type,
+                                         base::StringPiece record) {
+  for (auto& allocator : allocators_)
+    allocator.Write(type, record);
 }
 
 GlobalPersistentSystemProfile* GlobalPersistentSystemProfile::GetInstance() {
   return base::Singleton<
       GlobalPersistentSystemProfile,
       base::LeakySingletonTraits<GlobalPersistentSystemProfile>>::get();
 }
 
 }  // namespace metrics