Fully support read/write memory-mapped files for persistent memory.

components/metrics/file_metrics_provider.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 "components/metrics/file_metrics_provider.h"
 
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/persistent_histogram_allocator.h"
 #include "base/metrics/persistent_memory_allocator.h"
+#include "base/strings/string_piece.h"
 #include "base/task_runner.h"
 #include "base/time/time.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_service.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 
 
 namespace metrics {
 
@@ skipping 161 matching lines @@
   source->mapped.reset(new base::MemoryMappedFile());
   if (!source->mapped->Initialize(std::move(file))) {
     source->mapped.reset();
     return ACCESS_RESULT_SYSTEM_MAP_FAILURE;
   }
 
   // Ensure any problems below don't occur repeatedly.
   source->last_seen = info.last_modified;
 
   // Test the validity of the file contents.
-  if (!base::FilePersistentMemoryAllocator::IsFileAcceptable(*source->mapped)) {
+  if (!base::FilePersistentMemoryAllocator::IsFileAcceptable(*source->mapped,
+                                                             true)) {
     source->mapped.reset();
     return ACCESS_RESULT_INVALID_CONTENTS;
   }
 
   switch (source->type) {
     case SOURCE_HISTOGRAMS_ATOMIC_FILE:
     case SOURCE_HISTOGRAMS_ATOMIC_DIR:
       // For an "atomic" file, copy the data into local memory but don't
       // release the file so that it is held open to prevent access by other
       // processes. The copy means all I/O is done on this thread instead of
@@ skipping 150 matching lines @@
   // File data was validated earlier. Files are not considered "untrusted"
   // as some processes might be (e.g. Renderer) so there's no need to check
   // again to try to thwart some malicious actor that may have modified the
   // data between then and now.
   if (source->data.empty()) {
     // Data hasn't been copied into memory. Create the allocator directly
     // on the memory-mapped file.
     // TODO(bcwhite): Make this do read/write when supported for "active".
     source->allocator.reset(new base::PersistentHistogramAllocator(
         base::WrapUnique(new base::FilePersistentMemoryAllocator(
-            std::move(source->mapped), 0, ""))));
+            std::move(source->mapped), 0, 0, base::StringPiece(), true))));
   } else {
     // Data was copied from the mapped file into memory. Create an allocator
     // on the copy thus eliminating disk I/O during data access.
     source->allocator.reset(new base::PersistentHistogramAllocator(
         base::WrapUnique(new base::PersistentMemoryAllocator(
-            &source->data[0], source->data.size(), 0, 0, "", true))));
+            &source->data[0], source->data.size(), 0, 0, base::StringPiece(),
+            true))));
   }
 }
 
 void FileMetricsProvider::RecordSourcesChecked(SourceInfoList* checked) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Move each processed source to either the "to-read" list (for processing)
   // or the "to-check" list (for future checking).
   for (auto iter = checked->begin(); iter != checked->end();) {
     auto temp = iter++;
@@ skipping 171 matching lines @@
 
     // Dump all histograms contained within the source to the snapshot-manager.
     RecordHistogramSnapshotsFromSource(snapshot_manager, source.get());
 
     // Update the last-seen time so it isn't read again unless it changes.
     RecordSourceAsRead(source.get());
   }
 }
 
 }  // namespace metrics