Revert simplification of memory ordering that is causing TSAN errors.

base/metrics/persistent_memory_allocator.cc

 // 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.
 
 #include "base/metrics/persistent_memory_allocator.h"
 
 #include <assert.h>
 #include <algorithm>
 
 #if defined(OS_WIN)
@@ skipping 200 matching lines @@
     if (!block) {  // Memory is corrupt.
       allocator_->SetCorrupt();
       return kReferenceNull;
     }
 
     // Update the "last_record" pointer to be the reference being returned.
     // If it fails then another thread has already iterated past it so loop
     // again. Failing will also load the existing value into "last" so there
     // is no need to do another such load when the while-loop restarts. A
     // "strong" compare-exchange is used because failing unnecessarily would
-    // mean repeating some fairly costly validations above. This operation
-    // is "relaxed" because the iterator has no other values to protect and
-    // the referenced object will be accessed via an "acquire" in GetAsObject.
+    // mean repeating some fairly costly validations above.
     if (last_record_.compare_exchange_strong(
-            last, next, std::memory_order_relaxed, std::memory_order_relaxed)) {
+            last, next, std::memory_order_acq_rel, std::memory_order_acquire)) {
       *type_return = block->type_id.load(std::memory_order_relaxed);
       break;
     }
   }
 
   // Memory corruption could cause a loop in the list. Such must be detected
   // so as to not cause an infinite loop in the caller. This is done by simply
   // making sure it doesn't iterate more times than the absolute maximum
   // number of allocations that could have been made. Callers are likely
   // to loop multiple times before it is detected but at least it stops.
@@ skipping 395 matching lines @@
     // zero then something must have previously run amuck through memory,
     // writing beyond the allocated space and into unallocated space.
     if (block->size != 0 ||
         block->cookie != kBlockCookieFree ||
         block->type_id.load(std::memory_order_relaxed) != 0 ||
         block->next.load(std::memory_order_relaxed) != 0) {
       SetCorrupt();
       return kReferenceNull;
     }
 
+    // Load information into the block header. There is no "release" of the
+    // data here because this memory can, currently, be seen only by the thread
+    // performing the allocation. When it comes time to share this, the thread
+    // will call MakeIterable() which does the release operation.
     block->size = size;
     block->cookie = kBlockCookieAllocated;
     block->type_id.store(type_id, std::memory_order_relaxed);
     return freeptr;
   }
 }
 
 void PersistentMemoryAllocator::GetMemoryInfo(MemoryInfo* meminfo) const {
   uint32_t remaining = std::max(
       mem_size_ - shared_meta()->freeptr.load(std::memory_order_relaxed),
@@ skipping 272 matching lines @@
 
 // static
 bool FilePersistentMemoryAllocator::IsFileAcceptable(
     const MemoryMappedFile& file,
     bool read_only) {
   return IsMemoryAcceptable(file.data(), file.length(), 0, read_only);
 }
 #endif  // !defined(OS_NACL)
 
 }  // namespace base