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 AddFieldTrial(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; }
 
    private:
     // Advance to the next record segment in the memory allocator.
     bool NextSegment() const;
 
     // Advance to the next record segment, creating a new one if necessary with
     // sufficent |min_size| space.
     bool AddSegment(size_t min_size);
 
     // Writes data to the current position, updating the passed values past
     // the amount written. Returns false in case of an error.
-    bool WriteData(RecordType type, const char** data, size_t* remaining_size);
+    bool WriteData(RecordType type, const char** data, size_t* data_size);
 
     // Reads data from the current position, updating the passed string
     // in-place. |type| must be initialized to kUnusedSpace and |record| must
     // be an empty string before the first call but unchanged thereafter.
     // Returns true when record is complete.
     bool ReadData(RecordType* type, std::string* record) const;
 
     // This never changes but can't be "const" because vector calls operator=().
     base::PersistentMemoryAllocator* allocator_;  // Storage location.
 
     // Indicates if a complete profile has been stored.
     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 "update" records into a system profile.
+  static void MergeUpdateRecords(
+      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_