Persist setup metrics and have Chrome report them during UMA upload.

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_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 {
+
+// This structure stores all the information about the files being monitored
+// and their current reporting state.
+struct FileMetricsProvider::FileInfo {
+  FileInfo() {}
+  ~FileInfo() {}
+
+  // Where on disk the file is located.
+  base::FilePath path;
+
+  // How to access this file (atomic/active).
+  FileType type;
+
+  // Name used inside prefs to persistent metadata.
+  std::string prefs_key;
+
+  // 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;
+
+ 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),
+      weak_factory_(this) {
+  DCHECK(thread_checker_.CalledOnValidThread());

[Alexei Svitkine (slow), 2016/02/19 20:09:44]

Nit: No need to do it here since this will always be true since the thread
checker is created in the ctor.

[bcwhite, 2016/02/19 20:32:56]

Done.

+}
+
+FileMetricsProvider::~FileMetricsProvider() {}
+
+void FileMetricsProvider::RegisterFile(const base::FilePath& path,
+                                       FileType type,
+                                       const base::StringPiece prefs_key) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  scoped_ptr<FileInfo> file(new FileInfo());
+  file->path = path;
+  file->type = type;
+  file->prefs_key = prefs_key.as_string();
+
+  // |prefs_key| may be empty if the caller does not wish to persist the
+  // state across instances of the program.
+  if (pref_service_ && !prefs_key.empty()) {
+    file->last_seen = base::Time::FromInternalValue(
+        pref_service_->GetInt64(metrics::prefs::kMetricsLastSeenPrefix +
+                                file->prefs_key));
+  }
+
+  files_to_check_.push_back(std::move(file));
+}
+
+// static
+void FileMetricsProvider::RegisterPrefs(PrefRegistrySimple* prefs,
+                                        const base::StringPiece prefs_key) {
+  prefs->RegisterInt64Pref(metrics::prefs::kMetricsLastSeenPrefix +
+                           prefs_key.as_string(), 0);
+}
+
+// This method has all state information passed in |files| and is intended
+// to run on a worker thread rather than the UI thread.

[Alexei Svitkine (slow), 2016/02/19 20:09:44]

Nit: The comment above the method should just be "// static" - the other part
should either be in the body or in the header.

[bcwhite, 2016/02/19 20:32:56]

Done.

+// static
+void FileMetricsProvider::CheckAndMapNewMetricFilesOnTaskRunner(
+    FileMetricsProvider::FileInfoList* files) {
+  for (scoped_ptr<FileInfo>& file : *files) {
+    AccessResult result = CheckAndMapNewMetrics(file.get());
+    // Some results are not reported in order to keep the dashboard clean.
+    if (result != ACCESS_RESULT_DOESNT_EXIST &&
+        result != ACCESS_RESULT_NOT_MODIFIED) {
+      UMA_HISTOGRAM_ENUMERATION(
+          "UMA.FileMetricsProvider.AccessResult", result, ACCESS_RESULT_MAX);
+    }
+  }
+}
+
+// This method has all state information passed in |file| and is intended
+// to run on a worker thread rather than the UI thread.
+// static
+FileMetricsProvider::AccessResult FileMetricsProvider::CheckAndMapNewMetrics(
+    FileMetricsProvider::FileInfo* file) {

[Alexei Svitkine (slow), 2016/02/19 20:09:44]

Add thread check here.

[Alexei Svitkine (slow), 2016/02/19 20:11:40]

Sorry, ignore this one.

[bcwhite, 2016/02/19 20:32:56]

Acknowledged.

+  DCHECK(!file->mapped);
+  DCHECK(file->data.empty());
+
+  base::File::Info info;
+  if (!base::GetFileInfo(file->path, &info))
+    return ACCESS_RESULT_DOESNT_EXIST;
+
+  if (info.is_directory || info.size == 0)
+    return ACCESS_RESULT_INVALID_FILE;
+
+  if (file->last_seen >= info.last_modified)
+    return ACCESS_RESULT_NOT_MODIFIED;
+
+  // A new file of metrics has been found. Map it into memory.
+  // TODO(bcwhite): Make this open read/write when supported for "active".
+  file->mapped.reset(new base::MemoryMappedFile());
+  if (!file->mapped->Initialize(file->path)) {
+    file->mapped.reset();
+    return ACCESS_RESULT_SYSTEM_MAP_FAILURE;
+  }
+
+  // Ensure any problems below don't occur repeatedly.
+  file->last_seen = info.last_modified;
+
+  // Test the validity of the file contents.
+  if (!base::FilePersistentMemoryAllocator::IsFileAcceptable(*file->mapped))
+    return ACCESS_RESULT_INVALID_CONTENTS;
+
+  // For an "atomic" file, immediately copy the data into local memory and
+  // release the file so that it is not held open.
+  if (file->type == FILE_HISTOGRAMS_ATOMIC) {
+    file->data.assign(file->mapped->data(),
+                      file->mapped->data() + file->mapped->length());
+    file->mapped.reset();
+  }
+
+  return ACCESS_RESULT_SUCCESS;
+}
+
+void FileMetricsProvider::ScheduleFilesCheck() {

[Alexei Svitkine (slow), 2016/02/19 20:09:44]

Add thread check here.

[bcwhite, 2016/02/19 20:32:56]

Done.

+  if (files_to_check_.empty())
+    return;
+
+  // Create an independent list of files for checking. This will be Owned()
+  // by the reply call given to the task-runner, to be deleted when that call
+  // has returned. It is also passed Unretained() to the task itself, safe
+  // because that must complete before the reply runs.
+  FileInfoList* check_list = new FileInfoList();
+  std::swap(files_to_check_, *check_list);
+  task_runner_->PostTaskAndReply(
+      FROM_HERE,
+      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) {

[Alexei Svitkine (slow), 2016/02/19 20:09:44]

Add thread check here.

[bcwhite, 2016/02/19 20:32:56]

Done.

+  base::PersistentMemoryAllocator::Iterator hist_iter;
+  file->allocator->CreateIterator(&hist_iter);
+
+  int histogram_count = 0;
+  while (true) {
+    scoped_ptr<base::HistogramBase> histogram(
+        base::GetNextPersistentHistogram(file->allocator.get(), &hist_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()));
+  } else {
+    DCHECK(!file->mapped);
+    file->allocator.reset(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++;
+    const FileInfo* file = temp->get();
+    if (file->mapped || !file->data.empty())
+      files_to_read_.splice(files_to_read_.end(), *checked, temp);
+    else
+      files_to_check_.splice(files_to_check_.end(), *checked, temp);
+  }
+}
+
+void FileMetricsProvider::RecordFileAsSeen(FileInfo* file) {

[Alexei Svitkine (slow), 2016/02/19 20:11:41]

Add thread check here.

[bcwhite, 2016/02/19 20:32:56]

Done.

+  if (pref_service_ && !file->prefs_key.empty()) {
+    pref_service_->SetInt64(metrics::prefs::kMetricsLastSeenPrefix +
+                            file->prefs_key,
+                            file->last_seen.ToInternalValue());
+  }
+}
+
+void FileMetricsProvider::OnDidCreateMetricsLog() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Move finished metric files back to list of monitored files.
+  for (auto iter = files_to_read_.begin(); iter != files_to_read_.end();) {
+    auto temp = iter++;
+    const FileInfo* file = temp->get();
+    if (!file->allocator && !file->mapped && file->data.empty())
+      files_to_check_.splice(files_to_check_.end(), files_to_read_, temp);
+  }
+
+  // Schedule a check to see if there are new metrics to load. If so, they
+  // will be reported during the next collection run after this one. The
+  // check is run off of the worker-pool so as to not cause delays on the
+  // main UI thread (which is currently where metric collection is done).
+  ScheduleFilesCheck();
+}
+
+void FileMetricsProvider::RecordHistogramSnapshots(
+    base::HistogramSnapshotManager* snapshot_manager) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  for (scoped_ptr<FileInfo>& file : files_to_read_) {
+    // If the file is mapped or loaded then it needs to have an allocator
+    // attached to it in order to read histograms out of it.
+    if (file->mapped || !file->data.empty())
+      CreateAllocatorForFile(file.get());
+
+    // A file should not be under "files to read" unless it has an allocator
+    // or is memory-mapped (at which point it will have received an allocator
+    // above). However, if this method gets called twice before the scheduled-
+    // files-check has a chance to clean up, this may trigger. This also
+    // catches the case where creating an allocator from the file has failed.
+    if (!file->allocator)
+      continue;
+
+    // Dump all histograms contained within the file to the snapshot-manager.
+    RecordHistogramSnapshotsFromFile(snapshot_manager, file.get());
+
+    // Atomic files are read once and then ignored unless they change.
+    if (file->type == FILE_HISTOGRAMS_ATOMIC) {
+      DCHECK(!file->mapped);
+      file->allocator.reset();
+      file->data.clear();
+      RecordFileAsSeen(file.get());
+    }
+  }
+}
+
+}  // namespace metrics