Clear memory in a predictable and atomic manner when changing type.

base/metrics/persistent_memory_allocator.h

 // Copyright (c) 2015 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_MEMORY_ALLOCATOR_H_
 #define BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
 
 #include <stdint.h>
 
 #include <atomic>
@@ skipping 199 matching lines @@
     size_t total;
     size_t free;
   };
 
   enum : Reference {
     // A common "null" reference value.
     kReferenceNull = 0,
   };
 
   enum : uint32_t {
+    // A value that will match any type when doing lookups.
+    kTypeIdAny = 0x00000000,
+
     // A value indicating that the type is in transition. Work is being done
     // on the contents to prepare it for a new type to come.
     kTypeIdTransitioning = 0xFFFFFFFF,
   };
 
   enum : size_t {
     kSizeAny = 1  // Constant indicating that any array size is acceptable.
   };
 
   // This is the standard file extension (suitable for being passed to the
@@ skipping 163 matching lines @@
 
   // Access the internal "type" of an object. This generally isn't necessary
   // but can be used to "clear" the type and so effectively mark it as deleted
   // even though the memory stays valid and allocated. Changing the type is
   // an atomic compare/exchange and so requires knowing the existing value.
   // It will return false if the existing type is not what is expected.
   //
   // Changing the type doesn't mean the data is compatible with the new type.
   // Passing true for |clear| will zero the memory after the type has been
   // changed away from |from_type_id| but before it becomes |to_type_id| meaning
-  // that it is done in a manner that is thread-safe.
+  // that it is done in a manner that is thread-safe. Memory is guaranteed to
+  // be zeroed atomically by machine-word in a monotonically increasing order.
   //
   // It will likely be necessary to reconstruct the type before it can be used.
   // Changing the type WILL NOT invalidate existing pointers to the data, either
   // in this process or others, so changing the data structure could have
   // unpredicatable results. USE WITH CARE!
   uint32_t GetType(Reference ref) const;
   bool ChangeType(Reference ref,
                   uint32_t to_type_id,
                   uint32_t from_type_id,
                   bool clear);
@@ skipping 300 matching lines @@
  private:
   std::unique_ptr<MemoryMappedFile> mapped_file_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePersistentMemoryAllocator);
 };
 #endif  // !defined(OS_NACL)
 
 }  // namespace base
 
 #endif  // BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_