Add SharedMemory version of PersistentMemoryAllocator.

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>
 
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
+#include "base/memory/shared_memory.h"
 #include "base/metrics/histogram_macros.h"
 
 namespace {
 
 // Required range of memory segment sizes. It has to fit in an unsigned 32-bit
 // number and should be a power of 2 in order to accomodate almost any page
 // size.
 const uint32_t kSegmentMinSize = 1 << 10;  // 1 KiB
 const uint32_t kSegmentMaxSize = 1 << 30;  // 1 GiB
 
@@ skipping 178 matching lines @@
 
     // Allocate space for the name so other processes can learn it.
     if (!name.empty()) {
       const size_t name_length = name.length() + 1;
       shared_meta()->name = Allocate(name_length, 0);
       char* name_cstr = GetAsObject<char>(shared_meta()->name, 0);
       if (name_cstr)
         strcpy(name_cstr, name.c_str());
     }
   } else {
+    if (shared_meta()->size == 0 ||
+        shared_meta()->version == 0 ||
+        shared_meta()->freeptr.load() == 0 ||
+        shared_meta()->tailptr == 0 ||
+        shared_meta()->queue.cookie == 0 ||
+        shared_meta()->queue.next.load() == 0) {
+      NOTREACHED();
+      SetCorrupt();
+    }
     if (readonly) {
       // For read-only access, validate reasonable ctor parameters.
       DCHECK_GE(mem_size_, shared_meta()->freeptr.load());
     } else {
       // The allocator is attaching to a previously initialized segment of
       // memory. Make sure the embedded data matches what has been passed.
       if (shared_meta()->size != mem_size_ ||
           shared_meta()->page_size != mem_page_) {
         NOTREACHED();
         SetCorrupt();
@@ skipping 421 matching lines @@
     uint64_t id,
     const std::string& name)
     : PersistentMemoryAllocator(memset(new char[size], 0, size),
                                 size, 0, id, name, false) {}
 
 LocalPersistentMemoryAllocator::~LocalPersistentMemoryAllocator() {
   delete [] mem_base_;
 }
 
 
+//----- SharedPersistentMemoryAllocator ----------------------------------------
+
+SharedPersistentMemoryAllocator::SharedPersistentMemoryAllocator(
+    scoped_ptr<SharedMemory> shmem,

[Alexei Svitkine (slow), 2016/02/05 21:54:02]

Nit: Make param consistent with header.

[bcwhite, 2016/02/06 04:26:11]

Done.

+    uint64_t id,
+    const std::string& name,
+    bool read_only)
+    : PersistentMemoryAllocator(static_cast<uint8_t*>(shmem->memory()),
+                                shmem->mapped_size(), 0, id, name, read_only),
+      shared_memory_(std::move(shmem)) {}
+
+SharedPersistentMemoryAllocator::~SharedPersistentMemoryAllocator() {
+}
+
+// static
+bool SharedPersistentMemoryAllocator::IsSharedMemoryAcceptable(
+    const SharedMemory& shmem) {
+  return IsMemoryAcceptable(shmem.memory(), shmem.mapped_size(), 0, true);
+}
+
+
 //----- FilePersistentMemoryAllocator ------------------------------------------
 
 FilePersistentMemoryAllocator::FilePersistentMemoryAllocator(
-    MemoryMappedFile* file,
+    scoped_ptr<MemoryMappedFile> file,
     uint64_t id,
     const std::string& name)
     : PersistentMemoryAllocator(const_cast<uint8_t*>(file->data()),
                                 file->length(), 0, id, name, true),
-      mapped_file_(file) {}
+      mapped_file_(std::move(file)) {}
 
 FilePersistentMemoryAllocator::~FilePersistentMemoryAllocator() {
 }
 
 // static
 bool FilePersistentMemoryAllocator::IsFileAcceptable(
     const MemoryMappedFile& file) {
   return IsMemoryAcceptable(file.data(), file.length(), 0, true);
 }
 
 }  // namespace base