Refactor histogram_persistence to be a class.

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_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/metrics/histogram_persistence.h"
+#include "base/metrics/persistent_histogram_allocator.h"
 #include "base/metrics/persistent_memory_allocator.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 15 matching lines @@
 
   // The last-seen time of this file to detect change.
   base::Time last_seen;
 
   // Once a file has been recognized as needing to be read, it is |mapped|
   // into memory. If that file is "atomic" then the data from that file
   // will be copied to |data| and the mapped file released. If the file is
   // "active", it remains mapped and nothing is copied to local memory.
   std::vector<uint8_t> data;
   scoped_ptr<base::MemoryMappedFile> mapped;
-  scoped_ptr<base::PersistentMemoryAllocator> allocator;
+  scoped_ptr<base::PersistentHistogramAllocator> allocator;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FileInfo);
 };
 
 FileMetricsProvider::FileMetricsProvider(
     const scoped_refptr<base::TaskRunner>& task_runner,
     PrefService* local_state)
     : task_runner_(task_runner),
       pref_service_(local_state),
@@ skipping 106 matching lines @@
       base::Bind(&FileMetricsProvider::CheckAndMapNewMetricFilesOnTaskRunner,
                  base::Unretained(check_list)),
       base::Bind(&FileMetricsProvider::RecordFilesChecked,
                  weak_factory_.GetWeakPtr(), base::Owned(check_list)));
 }
 
 void FileMetricsProvider::RecordHistogramSnapshotsFromFile(
     base::HistogramSnapshotManager* snapshot_manager,
     FileInfo* file) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  base::PersistentMemoryAllocator::Iterator hist_iter;
-  file->allocator->CreateIterator(&hist_iter);
+  base::PersistentHistogramAllocator::Iterator histogram_iter;
+  file->allocator->CreateIterator(&histogram_iter);
 
   int histogram_count = 0;
   while (true) {
-    scoped_ptr<base::HistogramBase> histogram(
-        base::GetNextPersistentHistogram(file->allocator.get(), &hist_iter));
+    scoped_ptr<base::HistogramBase> histogram =
+        file->allocator->GetNextHistogram(&histogram_iter);
     if (!histogram)
       break;
     if (file->type == FILE_HISTOGRAMS_ATOMIC)
       snapshot_manager->PrepareAbsoluteTakingOwnership(std::move(histogram));
     else
       snapshot_manager->PrepareDeltaTakingOwnership(std::move(histogram));
     ++histogram_count;
   }
 
   DVLOG(1) << "Reported " << histogram_count << " histograms from "
            << file->path.value();
 }
 
 void FileMetricsProvider::CreateAllocatorForFile(FileInfo* file) {
   DCHECK(!file->allocator);
 
   // 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 (file->mapped) {
     DCHECK(file->data.empty());
     // TODO(bcwhite): Make this do read/write when supported for "active".
-    file->allocator.reset(new base::FilePersistentMemoryAllocator(
-        std::move(file->mapped), 0, std::string()));
+    file->allocator.reset(new base::PersistentHistogramAllocator(
+        make_scoped_ptr(new base::FilePersistentMemoryAllocator(
+            std::move(file->mapped), 0, ""))));
   } else {
     DCHECK(!file->mapped);
-    file->allocator.reset(new base::PersistentMemoryAllocator(
-        &file->data[0], file->data.size(), 0, 0, "", true));
+    file->allocator.reset(new base::PersistentHistogramAllocator(
+        make_scoped_ptr(new base::PersistentMemoryAllocator(
+            &file->data[0], file->data.size(), 0, 0, "", true))));
   }
 }
 
 void FileMetricsProvider::RecordFilesChecked(FileInfoList* checked) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Move each processed file 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 58 matching lines @@
     if (file->type == FILE_HISTOGRAMS_ATOMIC) {
       DCHECK(!file->mapped);
       file->allocator.reset();
       file->data.clear();
       RecordFileAsSeen(file.get());
     }
   }
 }
 
 }  // namespace metrics