Support add-on 'field trial' records.

components/metrics/persistent_system_profile.h

 // 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.
 
 #ifndef BASE_METRICS_PERSISTENT_SYSTEM_PROFILE_H_
 #define BASE_METRICS_PERSISTENT_SYSTEM_PROFILE_H_
 
 #include <vector>
 
+#include "base/strings/string_piece.h"
 #include "base/threading/thread_checker.h"
 #include "components/metrics/proto/system_profile.pb.h"
 
 namespace base {
 template <typename T>
 struct DefaultSingletonTraits;
 class PersistentMemoryAllocator;
 }  // namespace base
 
 namespace metrics {
@@ skipping 11 matching lines @@
       base::PersistentMemoryAllocator* memory_allocator);
 
   // Stores a complete system profile. Use the version taking the serialized
   // version if available to avoid multiple serialization actions. The
   // |complete| flag indicates that this profile contains all known information
   // and can replace whatever exists. If the flag is false, the profile will be
   // stored only if there is nothing else already present.
   void SetSystemProfile(const std::string& serialized_profile, bool complete);
   void SetSystemProfile(const SystemProfileProto& profile, bool complete);
 
+  // Records the existence of a field trial.
+  void SetFieldTrial(base::StringPiece trial, base::StringPiece group);
+
   // Tests if a persistent memory allocator contains an system profile.
   static bool HasSystemProfile(
       const base::PersistentMemoryAllocator& memory_allocator);
 
   // Retrieves the system profile from a persistent memory allocator. Returns
   // true if a profile was successfully retrieved.
   static bool GetSystemProfile(
       const base::PersistentMemoryAllocator& memory_allocator,
       SystemProfileProto* system_profile);
 
  private:
   friend class PersistentSystemProfileTest;
 
   // Defines record types that can be stored inside our local Allocators.
   enum RecordType : uint8_t {
     kUnusedSpace = 0,  // The default value for empty memory.
     kSystemProfileProto,
+    kFieldTrialInfo,
   };
 
   // A class for managing record allocations inside a persistent memory segment.
   class RecordAllocator {
    public:
     // Construct an allocator for writing.
     RecordAllocator(base::PersistentMemoryAllocator* memory_allocator,
                     size_t min_size);
 
     // Construct an allocator for reading.
     RecordAllocator(const base::PersistentMemoryAllocator* memory_allocator);
 
     // These methods manage writing records to the allocator. Do not mix these
     // with "read" calls; it's one or the other.
     void Reset();
-    bool Write(RecordType type, const std::string& record);
+    bool Write(RecordType type, base::StringPiece record);
 
     // Read a record from the allocator. Do not mix this with "write" calls;
     // it's one or the other.
     bool HasMoreData() const;
     bool Read(RecordType* type, std::string* record) const;
 
     base::PersistentMemoryAllocator* allocator() { return allocator_; }
 
     bool has_complete_profile() { return has_complete_profile_; }
     void set_complete_profile() { has_complete_profile_ = true; }
@@ skipping 23 matching lines @@
     bool has_complete_profile_;
 
     // These change even though the underlying data may be "const".
     mutable uint32_t alloc_reference_;  // Last storage block.
     mutable size_t alloc_size_;         // Size of the block.
     mutable size_t end_offset_;         // End of data in block.
 
     // Copy and assign are allowed for easy use with STL containers.
   };
 
+  // Write a record to all registered allocators.
+  void WriteToAll(RecordType type, base::StringPiece record);
+
+  // Merges all extension records into a system profile.
+  static void MergeExtensionRecords(

[Alexei Svitkine (slow), 2017/06/23 18:51:54]

I don't like "extension" terminology here because it can be confusing since
"extensions" mean something else already in Chrome and this could be read as
something related to logging extensions.

How about "UpdateRecords"?

[bcwhite, 2017/06/28 14:25:35]

Done.

+      const base::PersistentMemoryAllocator& memory_allocator,
+      SystemProfileProto* system_profile);
+
   // The list of registered persistent allocators, described by RecordAllocator
   // instances.
   std::vector<RecordAllocator> allocators_;
 
   // Indicates if a complete profile has been stored to all allocators.
   bool all_have_complete_profile_ = false;
 
   THREAD_CHECKER(thread_checker_);
 
   DISALLOW_COPY_AND_ASSIGN(PersistentSystemProfile);
 };
 
 // A singleton instance of the above.
 class GlobalPersistentSystemProfile : public PersistentSystemProfile {
  public:
   static GlobalPersistentSystemProfile* GetInstance();
 
  private:
   friend struct base::DefaultSingletonTraits<GlobalPersistentSystemProfile>;
 
   GlobalPersistentSystemProfile() {}
   ~GlobalPersistentSystemProfile() {}
 
   DISALLOW_COPY_AND_ASSIGN(GlobalPersistentSystemProfile);
 };
 
 }  // namespace metrics
 
 #endif  // BASE_METRICS_PERSISTENT_SYSTEM_PROFILE_H_