Move memory management code into separate class for future reuse.

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 58 matching lines @@
     explicit Iterator(const PersistentMemoryAllocator* allocator);
 
     // As above but resuming from the |starting_after| reference. The first call
     // to GetNext() will return the next object found after that reference. The
     // reference must be to an "iterable" object; references to non-iterable
     // objects (those that never had MakeIterable() called for them) will cause
     // a run-time error.
     Iterator(const PersistentMemoryAllocator* allocator,
              Reference starting_after);
 
+    // Resets the iterator back to the beginning.
+    void Reset();

[manzagop (departed), 2016/10/04 21:02:43]

Is this dangerous to introduce since we have some "while (GetNext()!=0)" which
could lead to infinite looping if a second thread keeps resetting the iterator?
Is iterator sharing common?

[bcwhite, 2016/10/05 16:34:11]

Each thread has its own iterator and all iterators are completely independent.

+
+    // Resets the iterator, resuming from the |starting_after| reference.

[manzagop (departed), 2016/10/04 21:02:43]

I'm guessing whenever you Reset(), then GetNext returns the same value?

From a quick look, I don't think the comments mentioned the references are
ordered (or that the iterator iteration order is). At least it wasn't obvious to
me (out of context reader). Add a comment?

[bcwhite, 2016/10/05 16:34:11]

Yes, the first iterable in the allocator.
Done.

+    void Reset(Reference starting_after);
+
+    // Returns the previously retrieved reference, or kReferenceNull if none.
+    // If constructor or reset with a starting_after location, this will return
+    // that value.
+    Reference GetLast();

[manzagop (departed), 2016/10/04 21:02:43]

Add a basic test for these?

[bcwhite, 2016/10/05 16:34:11]

Done.

+
     // Gets the next iterable, storing that type in |type_return|. The actual
     // return value is a reference to the allocation inside the allocator or
     // zero if there are no more. GetNext() may still be called again at a
     // later time to retrieve any new allocations that have been added.
     Reference GetNext(uint32_t* type_return);
 
     // Similar to above but gets the next iterable of a specific |type_match|.
     // This should not be mixed with calls to GetNext() because any allocations
     // skipped here due to a type mis-match will never be returned by later
     // calls to GetNext() meaning it's possible to completely miss entries.
@@ skipping 354 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_