Support saving browser metrics to disk and reading them during next run.

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"
@@ skipping 51 matching lines @@
     PrefService* local_state)
     : task_runner_(task_runner),
       pref_service_(local_state),
       weak_factory_(this) {
 }
 
 FileMetricsProvider::~FileMetricsProvider() {}
 
 void FileMetricsProvider::RegisterFile(const base::FilePath& path,
                                        FileType type,
+                                       FileAssociation file_association,
                                        const base::StringPiece prefs_key) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::unique_ptr<FileInfo> file(new FileInfo(type));
   file->path = path;
   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));
+  switch (file_association) {
+    case ASSOCIATE_CURRENT_RUN:
+      files_to_check_.push_back(std::move(file));
+      break;
+    case ASSOCIATE_PREVIOUS_RUN:
+      DCHECK_EQ(FILE_HISTOGRAMS_ATOMIC, file->type);
+      files_for_previous_run_.push_back(std::move(file));
+      break;
+  }
 }
 
 // static
 void FileMetricsProvider::RegisterPrefs(PrefRegistrySimple* prefs,
                                         const base::StringPiece prefs_key) {
   prefs->RegisterInt64Pref(metrics::prefs::kMetricsLastSeenPrefix +
                            prefs_key.as_string(), 0);
 }
 
 // static
@@ skipping 82 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   base::PersistentHistogramAllocator::Iterator histogram_iter(
       file->allocator.get());
 
   int histogram_count = 0;
   while (true) {
     std::unique_ptr<base::HistogramBase> histogram = histogram_iter.GetNext();
     if (!histogram)
       break;
     if (file->type == FILE_HISTOGRAMS_ATOMIC)
-      snapshot_manager->PrepareAbsoluteTakingOwnership(std::move(histogram));
+      snapshot_manager->PrepareFinalDeltaTakingOwnership(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) {
@@ skipping 60 matching lines @@
 
     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();
+
+  // Clear any data for initial metrics since they're always reported
+  // before the first call to this method. It couldn't be released after
+  // being reported in RecordInitialHistogramSnapshots because the data
+  // will continue to be used by the caller after that method returns. Once
+  // here, though, all actions to be done on the data have been completed.
+#if DCHECK_IS_ON()
+  for (const std::unique_ptr<FileInfo>& file : files_for_previous_run_)
+    DCHECK(file->read_complete);
+#endif
+  files_for_previous_run_.clear();
+}
+
+bool FileMetricsProvider::HasInitialStabilityMetrics() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  SCOPED_UMA_HISTOGRAM_TIMER("UMA.FileMetricsProvider.InitialTotalCheckTime");

[Alexei Svitkine (slow), 2016/05/09 21:24:10]

Nit: Add a comment above these scoped timers mentioning that we're worried about
how long the IO done here will take which is why we're measuring them.

(Just the top-level ones in each function.)

[bcwhite, 2016/05/10 15:42:41]

Done.

+
+  // Check all files for previous run to see if they need to be read.
+  for (auto iter = files_for_previous_run_.begin();
+       iter != files_for_previous_run_.end();) {
+    SCOPED_UMA_HISTOGRAM_TIMER("UMA.FileMetricsProvider.InitialFileCheckTime");

[Alexei Svitkine (slow), 2016/05/09 21:24:10]

How about:

UMA.FileMetricsProvider.InitialCheckTime.Total and 
UMA.FileMetricsProvider.InitialCheckTime.File 

[bcwhite, 2016/05/10 15:42:40]

Done.

+
+    auto temp = iter++;
+    FileInfo* file = temp->get();
+
+    // This would normally be done on a background I/O thread but there
+    // hasn't been a chance to run any at the time this method is called.
+    // Do the check in-line.
+    AccessResult result = CheckAndMapNewMetrics(file);
+    UMA_HISTOGRAM_ENUMERATION("UMA.FileMetricsProvider.InitialAccessResult",
+                              result, ACCESS_RESULT_MAX);
+
+    // If it couldn't be accessed, remove it from the list. There is only ever
+    // one chance to record it so no point keeping it around for later. Also
+    // mark it as having been read since uploading it with a future browser
+    // run would associate it with the previous run which would no longer be
+    // the run from which it came.
+    if (result != ACCESS_RESULT_SUCCESS) {
+      RecordFileAsSeen(file);
+      files_for_previous_run_.erase(temp);
+    }
+  }
+
+  return !files_for_previous_run_.empty();
 }
 
 void FileMetricsProvider::RecordHistogramSnapshots(
     base::HistogramSnapshotManager* snapshot_manager) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  SCOPED_UMA_HISTOGRAM_TIMER("UMA.FileMetricsProvider.TotalSnapshotTime");
+
   for (std::unique_ptr<FileInfo>& file : files_to_read_) {
     // Skip this file if the data has already been read.
     if (file->read_complete)
       continue;
 
+    SCOPED_UMA_HISTOGRAM_TIMER("UMA.FileMetricsProvider.FileSnapshotTime");
+
     // 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());
 
     // Update the last-seen time so it isn't read again unless it changes.
     RecordFileAsSeen(file.get());
   }
 }
 
+void FileMetricsProvider::RecordInitialHistogramSnapshots(
+    base::HistogramSnapshotManager* snapshot_manager) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  SCOPED_UMA_HISTOGRAM_TIMER(
+      "UMA.FileMetricsProvider.InitialTotalSnapshotTime");
+
+  for (const std::unique_ptr<FileInfo>& file : files_for_previous_run_) {
+    SCOPED_UMA_HISTOGRAM_TIMER(
+        "UMA.FileMetricsProvider.InitialFileSnapshotTime");
+
+    // The file needs to have an allocator attached to it in order to read
+    // histograms out of it.
+    DCHECK(file->mapped || !file->data.empty());
+    CreateAllocatorForFile(file.get());
+    DCHECK(file->allocator);
+
+    // Dump all histograms contained within the file to the snapshot-manager.
+    RecordHistogramSnapshotsFromFile(snapshot_manager, file.get());
+
+    // Update the last-seen time so it isn't read again unless it changes.
+    RecordFileAsSeen(file.get());
+  }
+}
+
 }  // namespace metrics