Create and pass shared-histogram-allocator from browser to renderer.

base/metrics/persistent_histogram_allocator.cc

 // Copyright 2016 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_histogram_allocator.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"

[grt (UTC plus 2), 2016/04/01 14:22:48]

remove these two -- already included in .h

[bcwhite, 2016/04/01 16:50:26]

Done.

+#include "base/memory/shared_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"

[grt (UTC plus 2), 2016/04/01 14:22:48]

remove this -- already included in .h

[bcwhite, 2016/04/01 16:50:26]

Done.

 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/synchronization/lock.h"
 
 // TODO(bcwhite): Order these methods to match the header file. The current
 // order is only temporary in order to aid review of the transition from
 // a non-class implementation.
 
 namespace base {
@@ skipping 226 matching lines @@
 void PersistentHistogramAllocator::CreateGlobalAllocatorOnLocalMemory(
     size_t size,
     uint64_t id,
     StringPiece name) {
   SetGlobalAllocator(make_scoped_ptr(new PersistentHistogramAllocator(
       make_scoped_ptr(new LocalPersistentMemoryAllocator(size, id, name)))));
 }
 
 // static
 void PersistentHistogramAllocator::CreateGlobalAllocatorOnSharedMemory(
+    scoped_ptr<SharedMemory> memory,
     size_t size,
-    const SharedMemoryHandle& handle) {
+    uint64_t id,
+    StringPiece name) {
+  if (!memory->memory() && !memory->Map(size))
+    NOTREACHED();
+
+  if (memory->memory()) {
+    DCHECK_LE(memory->mapped_size(), size);
+    SetGlobalAllocator(make_scoped_ptr(new PersistentHistogramAllocator(
+        make_scoped_ptr(new SharedPersistentMemoryAllocator(
+            std::move(memory), id, name, /*readonly=*/false)))));
+  }
+}
+
+// static
+void PersistentHistogramAllocator::CreateGlobalAllocatorOnSharedMemoryHandle(
+    const SharedMemoryHandle& handle,
+    size_t size) {
   scoped_ptr<SharedMemory> shm(new SharedMemory(handle, /*readonly=*/false));

[grt (UTC plus 2), 2016/04/01 14:22:48]

iiuc, this effectively takes ownership of |handle| since
SharedMemory::SharedMemory copies the handle value and
SharedMemory::~SharedMemory will eventually close it. in this case, i think it's
deceptive to take |handle| as a constref since the caller can no longer safely
use the thing they pass in. please do something so that it's impossible to
mis-use.

[bcwhite, 2016/04/01 16:50:26]

The passing convention matches that of the SharedMemory object to which it is
given.  I could switch it to a std::move(scoped_ptr) pattern here but it seems a
bit excessive, complicate the creation by creating a duplicate of something
passed by value, and will be at odds with the conventions of the underlying
class.

I'll add a comment but don't see any simple way to prevent mis-use in code.

   if (!shm->Map(size)) {
     NOTREACHED();
     return;
   }
 
+  DCHECK_LE(shm->mapped_size(), size);
   SetGlobalAllocator(make_scoped_ptr(new PersistentHistogramAllocator(
       make_scoped_ptr(new SharedPersistentMemoryAllocator(
           std::move(shm), 0, StringPiece(), /*readonly=*/false)))));
 }
 
 // static
 scoped_ptr<HistogramBase> PersistentHistogramAllocator::CreateHistogram(
     PersistentHistogramData* histogram_data_ptr) {
   if (!histogram_data_ptr) {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_METADATA_POINTER);
@@ skipping 302 matching lines @@
       scoped_ptr<HistogramBase> histogram =
           g_allocator->GetNextHistogramWithIgnore(&iter, last_created);
       if (!histogram)
         break;
       StatisticsRecorder::RegisterOrDeleteDuplicate(histogram.release());
     }
   }
 }
 
 }  // namespace base