Persist core system profile during startup.

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 "base/atomicops.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/persistent_memory_allocator.h"
 #include "base/stl_util.h"
@@ skipping 28 matching lines @@
   return (data_amount + sizeof(RecordHeader) + sizeof(RecordHeader) - 1) &
          ~(sizeof(RecordHeader) - 1);
 }
 
 }  // namespace
 
 PersistentSystemProfile::RecordAllocator::RecordAllocator(
     base::PersistentMemoryAllocator* memory_allocator,
     size_t min_size)
     : allocator_(memory_allocator),
+      has_complete_profile_(false),
       alloc_reference_(0),
       alloc_size_(0),
       end_offset_(0) {
   AddSegment(min_size);
 }
 
 PersistentSystemProfile::RecordAllocator::RecordAllocator(
     const base::PersistentMemoryAllocator* memory_allocator)
     : allocator_(
           const_cast<base::PersistentMemoryAllocator*>(memory_allocator)),
       alloc_reference_(0),
       alloc_size_(0),
       end_offset_(0) {}
 
 void PersistentSystemProfile::RecordAllocator::Reset() {
   // Clear the first word of all blocks so they're known to be "empty".
   alloc_reference_ = 0;
   while (NextSegment()) {
     // Get the block as a char* and cast it. It can't be fetched directly as
     // an array of RecordHeader because that's not a fundamental type and only
     // arrays of fundamental types are allowed.
     RecordHeader* header =
         reinterpret_cast<RecordHeader*>(allocator_->GetAsArray<char>(
             alloc_reference_, kTypeIdSystemProfile, sizeof(RecordHeader)));
     DCHECK(header);
     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) {
   const char* data = record.data();
   size_t remaining_size = record.size();
@@ skipping 169 matching lines @@
 PersistentSystemProfile::~PersistentSystemProfile() {}
 
 void PersistentSystemProfile::RegisterPersistentAllocator(
     base::PersistentMemoryAllocator* memory_allocator) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   // Create and store the allocator. A |min_size| of "1" ensures that a memory
   // block is reserved now.
   RecordAllocator allocator(memory_allocator, 1);
   allocators_.push_back(std::move(allocator));
+  all_have_complete_profile_ = false;
 }
 
 void PersistentSystemProfile::DeregisterPersistentAllocator(
     base::PersistentMemoryAllocator* memory_allocator) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   // This would be more efficient with a std::map but it's not expected that
   // allocators will get deregistered with any frequency, if at all.
   base::EraseIf(allocators_, [=](RecordAllocator& records) {
     return records.allocator() == memory_allocator;
   });
 }
 
 void PersistentSystemProfile::SetSystemProfile(
-    const std::string& serialized_profile) {
+    const std::string& serialized_profile,
+    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();
     // 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) {
+    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);
+  SetSystemProfile(serialized_profile, complete);
 }
 
 // static
 bool PersistentSystemProfile::HasSystemProfile(
     const base::PersistentMemoryAllocator& memory_allocator) {
   const RecordAllocator records(&memory_allocator);
   return records.HasMoreData();
 }
 
 // static
@@ skipping 12 matching lines @@
   return system_profile->ParseFromString(record);
 }
 
 GlobalPersistentSystemProfile* GlobalPersistentSystemProfile::GetInstance() {
   return base::Singleton<
       GlobalPersistentSystemProfile,
       base::LeakySingletonTraits<GlobalPersistentSystemProfile>>::get();
 }
 
 }  // namespace metrics