Persist core system profile during startup.

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/threading/thread_checker.h"
@@ skipping 13 matching lines @@
   PersistentSystemProfile();
   ~PersistentSystemProfile();
 
   // This object can store records in multiple memory allocators.
   void RegisterPersistentAllocator(
       base::PersistentMemoryAllocator* memory_allocator);
   void DeregisterPersistentAllocator(
       base::PersistentMemoryAllocator* memory_allocator);
 
   // Stores a complete system profile. Use the version taking the serialized
-  // version if available to avoid multiple serialization actions.
-  void SetSystemProfile(const std::string& serialized_profile);
-  void SetSystemProfile(const SystemProfileProto& profile);
+  // 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);
 
   // 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);
@@ skipping 22 matching lines @@
     void Reset();
     bool Write(RecordType type, const std::string& 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);
 
     // 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.
   };
 
   // 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_