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

chrome/browser/metrics/chrome_metrics_service_client.cc

 // Copyright 2014 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 "chrome/browser/metrics/chrome_metrics_service_client.h"
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
+#include "base/metrics/persistent_histogram_allocator.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/strings/string16.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/google/google_brand.h"
 #include "chrome/browser/metrics/chrome_stability_metrics_provider.h"
 #include "chrome/browser/metrics/metrics_reporting_state.h"
@@ skipping 65 matching lines @@
 #include "chrome/browser/signin/chrome_signin_status_metrics_provider_delegate.h"
 #include "components/signin/core/browser/signin_status_metrics_provider.h"
 #endif  // !defined(OS_CHROMEOS)
 
 namespace {
 
 // This specifies the amount of time to wait for all renderers to send their
 // data.
 const int kMaxHistogramGatheringWaitDuration = 60000;  // 60 seconds.
 
+// This is the name of the metrics allocator used by the browser.
+// TODO(bcwhite): De-dup this with chrome_browser_field_trials.cc and move
+// somewhere that content/ can read it from.
+const char kBrowserMetricsAllocatorName[] = "BrowserMetrics";
+
 // Standard interval between log uploads, in seconds.
 #if defined(OS_ANDROID)
 const int kStandardUploadIntervalSeconds = 5 * 60;  // Five minutes.
 const int kStandardUploadIntervalCellularSeconds = 15 * 60;  // Fifteen minutes.
 #else
 const int kStandardUploadIntervalSeconds = 30 * 60;  // Thirty minutes.
 #endif
 
 // Returns true if current connection type is cellular and user is assigned to
 // experimental group for enabled cellular uploads.
@@ skipping 18 matching lines @@
   PrefService* local_state = g_browser_process->local_state();
   return !local_state->HasPrefPath(metrics::prefs::kMetricsReportingEnabled) &&
          variations::GetVariationParamValue("UMA_EnableCellularLogUpload",
                                             "Enabled") == "true";
 #else
   return false;
 #endif
 }
 
 void RegisterInstallerFileMetricsPreferences(PrefRegistrySimple* registry) {
+  metrics::FileMetricsProvider::RegisterPrefs(
+      registry, kBrowserMetricsAllocatorName);
+
 #if defined(OS_WIN)
   metrics::FileMetricsProvider::RegisterPrefs(
       registry, installer::kSetupHistogramAllocatorName);
 #endif
 }
 
 void RegisterInstallerFileMetricsProvider(
     metrics::MetricsService* metrics_service) {
-#if defined(OS_WIN)
-  std::unique_ptr<metrics::FileMetricsProvider> file_metrics(
+  // Create an object to monitor files of metrics and include them in reports.
+  std::unique_ptr<metrics::FileMetricsProvider> file_metrics_provider(
       new metrics::FileMetricsProvider(
           content::BrowserThread::GetBlockingPool()
               ->GetTaskRunnerWithShutdownBehavior(
                   base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN),
           g_browser_process->local_state()));
+
+  // Build the pathname for browser's persistent metrics file. Set it as the
+  // destination for the GlobalHistogramAllocator during process exit and add
+  // it to the file-metrics-provider so one written from a previous run will
+  // be loaded.
+  base::FilePath metrics_file;
+  if (base::PathService::Get(chrome::DIR_USER_DATA, &metrics_file)) {
+    metrics_file = metrics_file.AppendASCII(kBrowserMetricsAllocatorName)
+                       .AddExtension(FILE_PATH_LITERAL(".pma"));

[Ilya Sherman, 2016/04/19 00:57:46]

What is ".pma"?  Is this just an extension that you're making up for the
purposes of this code?  If so, could we just omit the extension entirely?

[bcwhite, 2016/04/19 16:33:38]

PersistentMemoryAllocator.  Just a dump of memory managed by that class.

The extension name is being defined as a constant inside the FileMetricsProvider
as part of a different CL.  It is used to recognize metrics file in some
situations.

+
+    base::GlobalHistogramAllocator* allocator =
+        base::GlobalHistogramAllocator::Get();
+    if (allocator)
+      allocator->SetPersistentLocation(metrics_file);
+
+    file_metrics_provider->RegisterFile(
+        metrics_file,
+        metrics::FileMetricsProvider::FILE_HISTOGRAMS_ATOMIC,
+        kBrowserMetricsAllocatorName);
+  }
+
+#if defined(OS_WIN)
+  // Read metrics file from setup.exe.
   base::FilePath program_dir;
   base::PathService::Get(base::DIR_EXE, &program_dir);
-  file_metrics->RegisterFile(
+  file_metrics_provider->RegisterFile(
       program_dir.AppendASCII(installer::kSetupHistogramAllocatorName)
-          .AddExtension(L".pma"),
+          .AddExtension(FILE_PATH_LITERAL(".pma")),
       metrics::FileMetricsProvider::FILE_HISTOGRAMS_ATOMIC,
       installer::kSetupHistogramAllocatorName);
-  metrics_service->RegisterMetricsProvider(std::move(file_metrics));
 #endif
+
+  // Give the new provider to the metrics service.
+  metrics_service->RegisterMetricsProvider(std::move(file_metrics_provider));
 }
 
 }  // namespace
 
 
 ChromeMetricsServiceClient::ChromeMetricsServiceClient(
     metrics::MetricsStateManager* state_manager)
     : metrics_state_manager_(state_manager),
 #if defined(OS_CHROMEOS)
       chromeos_metrics_provider_(nullptr),
@@ skipping 516 matching lines @@
   }
 }
 
 void ChromeMetricsServiceClient::OnURLOpenedFromOmnibox(OmniboxLog* log) {
   metrics_service_->OnApplicationNotIdle();
 }
 
 bool ChromeMetricsServiceClient::IsUMACellularUploadLogicEnabled() {
   return IsCellularLogicEnabled();
 }