Send metrics with embedded system profiles after system 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 83 matching lines @@
     }
     // Write out as much of the data as possible. |data| and |remaining_size|
     // are updated in place.
     if (!WriteData(type, &data, &remaining_size))
       return false;
   } while (remaining_size > 0);
 
   return true;
 }
 
+bool PersistentSystemProfile::RecordAllocator::HasMoreData() const {
+  if (alloc_reference_ == 0 && !NextSegment())
+    return false;
+
+  char* block =
+      allocator_->GetAsArray<char>(alloc_reference_, kTypeIdSystemProfile,
+                                   base::PersistentMemoryAllocator::kSizeAny);
+  if (!block)
+    return false;
+
+  RecordHeader header;
+  header.as_atomic = base::subtle::Acquire_Load(
+      reinterpret_cast<base::subtle::Atomic32*>(block + end_offset_));
+  return header.as_parts.type != kUnusedSpace;
+}
+
 bool PersistentSystemProfile::RecordAllocator::Read(RecordType* type,
                                                     std::string* record) const {
   *type = kUnusedSpace;
   record->clear();
 
   // Access data and read records until everything has been loaded.
   while (true) {
     if (end_offset_ == alloc_size_) {
       if (!NextSegment())
         return false;
@@ skipping 155 matching lines @@
     return;
 
   for (auto& allocator : allocators_) {
     // A full system profile always starts fresh.
     allocator.Reset();
     // Write out the serialized profile.
     allocator.Write(kSystemProfileProto, serialized_profile);
   }
 }
 
+void PersistentSystemProfile::SetSystemProfile(
+    const SystemProfileProto& profile) {
+  std::string serialized_profile;
+  if (!profile.SerializeToString(&serialized_profile))
+    return;
+  SetSystemProfile(serialized_profile);
+}
+
+// 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)
     return false;
 
   return system_profile->ParseFromString(record);
 }
 
 GlobalPersistentSystemProfile* GlobalPersistentSystemProfile::GetInstance() {
   return base::Singleton<
       GlobalPersistentSystemProfile,
       base::LeakySingletonTraits<GlobalPersistentSystemProfile>>::get();
 }
 
 }  // namespace metrics