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

components/metrics/file_metrics_provider.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 COMPONENTS_METRICS_FILE_METRICS_PROVIDER_H_
 #define COMPONENTS_METRICS_FILE_METRICS_PROVIDER_H_
 
 #include <list>
 #include <memory>
 #include <string>
@@ skipping 34 matching lines @@
 
     // "Active" files may be open by one or more other processes and updated
     // at any time with new samples or new histograms. Such files may also be
     // inactive for any period of time only to be opened again and have new
     // data written to them. The file should probably never be deleted because
     // there would be no guarantee that the data has been reported.
     // TODO(bcwhite): Enable when read/write mem-mapped files are supported.
     //FILE_HISTOGRAMS_ACTIVE,
   };
 
+  enum FileAssociation {
+    // Associates the metrics in the file with the current run of the browser.
+    // The reporting will take place as part of the normal logging of
+    // histograms.
+    ASSOCIATE_CURRENT_RUN,
+
+    // Associates the metrics in the file with the previous run of the browesr.
+    // The reporting will take place as part of the "stability" histograms.
+    // This is important when metrics are dumped as part of a crash of the
+    // previous run. This can only be used with FILE_HISTOGRAMS_ATOMIC.
+    ASSOCIATE_PREVIOUS_RUN,
+  };
+
   FileMetricsProvider(const scoped_refptr<base::TaskRunner>& task_runner,
                       PrefService* local_state);
   ~FileMetricsProvider() override;
 
   // Indicates a file to be monitored and how the file is used. Because some
   // metadata may persist across process restarts, preferences entries are
   // used based on the |prefs_key| name. Call RegisterPrefs() with the same
   // name to create the necessary keys in advance. Set |prefs_key| empty
   // if no persistence is required.
   void RegisterFile(const base::FilePath& path,
                     FileType type,
+                    FileAssociation file_association,
                     const base::StringPiece prefs_key);
 
   // Registers all necessary preferences for maintaining persistent state
   // about a monitored file across process restarts. The |prefs_key| is
   // typically the filename.
   static void RegisterPrefs(PrefRegistrySimple* prefs,
                             const base::StringPiece prefs_key);
 
  private:
   friend class FileMetricsProviderTest;
   FRIEND_TEST_ALL_PREFIXES(FileMetricsProviderTest, AccessMetrics);
+  FRIEND_TEST_ALL_PREFIXES(FileMetricsProviderTest, AccessInitialMetrics);
 
   // The different results that can occur accessing a file.
   enum AccessResult {
     // File was successfully mapped.
     ACCESS_RESULT_SUCCESS,
 
     // File does not exist.
     ACCESS_RESULT_DOESNT_EXIST,
 
     // File exists but not modified since last read.
@@ skipping 37 matching lines @@
 
   // Takes a list of files checked by an external task and determines what
   // to do with each.
   void RecordFilesChecked(FileInfoList* checked);
 
   // Updates the persistent state information to show a file as being read.
   void RecordFileAsSeen(FileInfo* file);
 
   // metrics::MetricsDataProvider:
   void OnDidCreateMetricsLog() override;
+  bool HasInitialStabilityMetrics() override;
   void RecordHistogramSnapshots(
       base::HistogramSnapshotManager* snapshot_manager) override;
+  void RecordInitialHistogramSnapshots(
+      base::HistogramSnapshotManager* snapshot_manager) override;
 
   // A task-runner capable of performing I/O.
   scoped_refptr<base::TaskRunner> task_runner_;
 
   // A list of files not currently active that need to be checked for changes.
   FileInfoList files_to_check_;
 
   // A list of files that have data to be read and reported.
   FileInfoList files_to_read_;
 
+  // A list of files for a previous run. These are held separately because
+  // they are not subject to the periodic background checking that handles
+  // metrics for the current run.
+  FileInfoList files_for_previous_run_;
+
   // The preferences-service used to store persistent state about files.
   PrefService* pref_service_;
 
   base::ThreadChecker thread_checker_;
   base::WeakPtrFactory<FileMetricsProvider> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FileMetricsProvider);
 };
 
 }  // namespace metrics
 
 #endif  // COMPONENTS_METRICS_FILE_METRICS_PROVIDER_H_