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

base/metrics/persistent_histogram_allocator.h

 // 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.
 
 #ifndef BASE_METRICS_HISTOGRAM_PERSISTENCE_H_
 #define BASE_METRICS_HISTOGRAM_PERSISTENCE_H_
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/feature_list.h"
@@ skipping 98 matching lines @@
       scoped_ptr<PersistentHistogramAllocator> allocator);
   static PersistentHistogramAllocator* GetGlobalAllocator();
 
   // This access to the persistent allocator is only for testing; it extracts
   // the current allocator completely. This allows easy creation of histograms
   // within persistent memory segments which can then be extracted and used
   // in other ways.
   static scoped_ptr<PersistentHistogramAllocator>
   ReleaseGlobalAllocatorForTesting();
 
-  // These helper methods perform SetGlobalAllocator() calls with allocators
-  // of the specified type and parameters.
+  // Create a global allocator using the passed-in memory |base|, |size|, and
+  // other parameters. Ownership of the memory segment remains with the caller.
   static void CreateGlobalAllocatorOnPersistentMemory(
       void* base,
       size_t size,
       size_t page_size,
       uint64_t id,
       StringPiece name);
+
+  // Create a global allocator using an internal block of memory of the
+  // specified |size| taken from the heap.
   static void CreateGlobalAllocatorOnLocalMemory(
       size_t size,
       uint64_t id,
       StringPiece name);
+
+  // Create a global allocator using a block of shared |memory| of the
+  // specified |size|. The allocator takes ownership of the shared memory
+  // and releases it upon destruction, though the memory will continue to
+  // live if other processes have access to it.
   static void CreateGlobalAllocatorOnSharedMemory(
+      scoped_ptr<SharedMemory> memory,
       size_t size,
-      const SharedMemoryHandle& handle);
+      uint64_t id,
+      StringPiece name);
+
+  // Create a global allocator using a block of shared memory accessed
+  // through the given |handle| and |size|. The allocator takes ownership
+  // of the handle and closes it upon destruction, though the memory will
+  // continue to live if other processes have access to it.
+  static void CreateGlobalAllocatorOnSharedMemoryHandle(
+      const SharedMemoryHandle& handle,
+      size_t size);
 
   // Import new histograms from the global PersistentHistogramAllocator. It's
   // possible for other processes to create histograms in the active memory
   // segment; this adds those to the internal list of known histograms to
   // avoid creating duplicates that would have to be merged during reporting.
   // Every call to this method resumes from the last entry it saw; it costs
   // nothing if nothing new has been added.
   static void ImportGlobalHistograms();
 
   // Histogram containing creation results. Visible for testing.
@@ skipping 59 matching lines @@
   // A reference to the last-created histogram in the allocator, used to avoid
   // trying to import what was just created.
   subtle::AtomicWord last_created_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(PersistentHistogramAllocator);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_HISTOGRAM_PERSISTENCE_H_