Integrate Crashpad UMA

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>
 
@@ skipping 18 matching lines @@
 #include "chrome/browser/metrics/chrome_stability_metrics_provider.h"
 #include "chrome/browser/metrics/https_engagement_metrics_provider.h"
 #include "chrome/browser/metrics/metrics_reporting_state.h"
 #include "chrome/browser/metrics/sampling_metrics_provider.h"
 #include "chrome/browser/metrics/subprocess_metrics_provider.h"
 #include "chrome/browser/metrics/time_ticks_experiment_win.h"
 #include "chrome/browser/sync/chrome_sync_client.h"
 #include "chrome/browser/ui/browser_otr_state.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/features.h"
 #include "chrome/installer/util/util_constants.h"
 #include "components/metrics/call_stack_profile_metrics_provider.h"
 #include "components/metrics/drive_metrics_provider.h"
 #include "components/metrics/file_metrics_provider.h"
 #include "components/metrics/gpu/gpu_metrics_provider.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_reporting_default_state.h"
@@ skipping 54 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.
 
+// Needs to be kept in sync with the writer in
+// third_party/crashpad/crashpad/handler/handler_main.cc.
+const char kCrashpadHistogramAllocatorName[] = "CrashpadMetrics";
+
 // Checks whether it is the first time that cellular uploads logic should be
 // enabled based on whether the the preference for that logic is initialized.
 // This should happen only once as the used preference will be initialized
 // afterwards in |UmaSessionStats.java|.
 bool ShouldClearSavedMetrics() {
 #if BUILDFLAG(ANDROID_JAVA_UI)
   PrefService* local_state = g_browser_process->local_state();
   return !local_state->HasPrefPath(metrics::prefs::kMetricsReportingEnabled) &&
          metrics::IsCellularLogicEnabled();
 #else
   return false;
 #endif
 }
 
-void RegisterInstallerFileMetricsPreferences(PrefRegistrySimple* registry) {
+void RegisterFileMetricsPreferences(PrefRegistrySimple* registry) {
   metrics::FileMetricsProvider::RegisterPrefs(
       registry, ChromeMetricsServiceClient::kBrowserMetricsName);
 
+  metrics::FileMetricsProvider::RegisterPrefs(registry,
+                                              kCrashpadHistogramAllocatorName);
+
 #if defined(OS_WIN)
   metrics::FileMetricsProvider::RegisterPrefs(
       registry, installer::kSetupHistogramAllocatorName);
 #endif
 }
 
-std::unique_ptr<metrics::FileMetricsProvider>
-CreateInstallerFileMetricsProvider(bool metrics_reporting_enabled) {
+std::unique_ptr<metrics::FileMetricsProvider> CreateFileMetricsProvider(
+    bool metrics_reporting_enabled) {
   // Fetch a worker-pool for performing I/O tasks that are not allowed on
   // the main UI thread.
   scoped_refptr<base::TaskRunner> task_runner =
       content::BrowserThread::GetBlockingPool()
           ->GetTaskRunnerWithShutdownBehavior(
               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 
   // Create an object to monitor files of metrics and include them in reports.
   std::unique_ptr<metrics::FileMetricsProvider> file_metrics_provider(
       new metrics::FileMetricsProvider(task_runner,
                                        g_browser_process->local_state()));
 
   // Create the full pathname of the file holding browser metrics.
-  base::FilePath metrics_file;
-  if (base::PathService::Get(chrome::DIR_USER_DATA, &metrics_file)) {
-    metrics_file =
-        metrics_file
-            .AppendASCII(ChromeMetricsServiceClient::kBrowserMetricsName)
-            .AddExtension(base::PersistentMemoryAllocator::kFileExtension);
+  base::FilePath user_data_dir;
+  if (base::PathService::Get(chrome::DIR_USER_DATA, &user_data_dir)) {
+    base::FilePath browser_metrics_file;
+    base::GlobalHistogramAllocator::ConstructFilePaths(
+        browser_metrics_file, ChromeMetricsServiceClient::kBrowserMetricsName,
+        &browser_metrics_file, nullptr);
 
     if (metrics_reporting_enabled) {
       // Enable reading any existing saved metrics.
       file_metrics_provider->RegisterSource(
-          metrics_file,
+          browser_metrics_file,
           metrics::FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_FILE,
           metrics::FileMetricsProvider::ASSOCIATE_PREVIOUS_RUN,
           ChromeMetricsServiceClient::kBrowserMetricsName);
     } else {
       // When metrics reporting is not enabled, any existing file should be
       // deleted in order to preserve user privacy.
-      task_runner->PostTask(FROM_HERE,
-                            base::Bind(base::IgnoreResult(&base::DeleteFile),
-                                       metrics_file, /*recursive=*/false));
+      task_runner->PostTask(
+          FROM_HERE, base::Bind(base::IgnoreResult(&base::DeleteFile),
+                                browser_metrics_file, /*recursive=*/false));
     }
   }
 
+  // Read the Crashpad metrics files.
+  base::FilePath default_user_data_dir;
+  if (chrome::GetDefaultUserDataDirectory(&default_user_data_dir)) {
+    base::FilePath base_path, active_path;
+    base::GlobalHistogramAllocator::ConstructFilePaths(
+        default_user_data_dir, kCrashpadHistogramAllocatorName, &base_path,
+        &active_path);
+    if (metrics_reporting_enabled) {
+      // Register the data from the previous run if crashpad_handler didn't exit
+      // cleanly.
+      file_metrics_provider->RegisterSource(
+          base_path,
+          metrics::FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_FILE,
+          metrics::FileMetricsProvider::ASSOCIATE_PREVIOUS_RUN,
+          kCrashpadHistogramAllocatorName);
+
+      // Register data that will be populated for the current run.
+      file_metrics_provider->RegisterSource(
+          active_path,
+          metrics::FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_FILE,
+          metrics::FileMetricsProvider::ASSOCIATE_CURRENT_RUN,
+          kCrashpadHistogramAllocatorName);
+    } else {
+      // This file must be deleted here so that it's not mistaken for data from
+      // a previous run if metrics reporting is toggled.
+      task_runner->PostTask(FROM_HERE,
+                            base::Bind(base::IgnoreResult(&base::DeleteFile),
+                                       base_path, /*recursive=*/false));
+    }
+  }

[Alexei Svitkine (slow), 2016/09/15 16:49:44]

This block seems very similar to the one above - can you make a helper function
so they share code?

[scottmg, 2016/09/15 17:41:13]

Done.

+
 #if defined(OS_WIN)
   // Read metrics file from setup.exe.
   base::FilePath program_dir;
   base::PathService::Get(base::DIR_EXE, &program_dir);
   file_metrics_provider->RegisterSource(
       program_dir.AppendASCII(installer::kSetupHistogramAllocatorName),
       metrics::FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_DIR,
       metrics::FileMetricsProvider::ASSOCIATE_CURRENT_RUN,
       installer::kSetupHistogramAllocatorName);
 #endif
 
   return file_metrics_provider;
 }
 
-// If there is a global metrics file being updated on disk, mark it to be
-// deleted when the process exits. A normal shutdown is almost complete
-// so there is no benefit in keeping a file with no new data to be processed
-// during the next startup sequence. Deleting the file during shutdown adds
-// an extra disk-access or two to shutdown but eliminates the unnecessary
-// processing of the contents during startup only to find nothing.
-void CleanUpGlobalPersistentHistogramStorage() {
-  base::GlobalHistogramAllocator* allocator =
-      base::GlobalHistogramAllocator::Get();
-  if (!allocator)
-    return;
-
-  const base::FilePath& path = allocator->GetPersistentLocation();
-  if (path.empty())
-    return;
-
-  // Open (with delete) and then immediately close the file by going out of
-  // scope. This is the only cross-platform safe way to delete a file that may
-  // be open elsewhere. Open handles will continue to operate normally but
-  // new opens will not be possible.
-  base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_READ |
-                        base::File::FLAG_DELETE_ON_CLOSE);
-}
-
 }  // namespace
 
 
 const char ChromeMetricsServiceClient::kBrowserMetricsName[] = "BrowserMetrics";
 
 ChromeMetricsServiceClient::ChromeMetricsServiceClient(
     metrics::MetricsStateManager* state_manager)
     : metrics_state_manager_(state_manager),
 #if defined(OS_CHROMEOS)
       chromeos_metrics_provider_(nullptr),
@@ skipping 11 matching lines @@
       start_time_(base::TimeTicks::Now()),
       has_uploaded_profiler_data_(false),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
   RecordCommandLineMetrics();
   RegisterForNotifications();
 }
 
 ChromeMetricsServiceClient::~ChromeMetricsServiceClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  CleanUpGlobalPersistentHistogramStorage();
+  base::GlobalHistogramAllocator* allocator =
+      base::GlobalHistogramAllocator::Get();
+  if (allocator) {
+    // A normal shutdown is almost complete so there is no benefit in keeping a
+    // file with no new data to be processed during the next startup sequence.
+    // Deleting the file during shutdown adds an extra disk-access or two to
+    // shutdown but eliminates the unnecessary processing of the contents during
+    // startup only to find nothing.
+    allocator->DeletePersistentLocation();
+  }
 }
 
 // static
 std::unique_ptr<ChromeMetricsServiceClient> ChromeMetricsServiceClient::Create(
     metrics::MetricsStateManager* state_manager) {
   // Perform two-phase initialization so that |client->metrics_service_| only
   // receives pointers to fully constructed objects.
   std::unique_ptr<ChromeMetricsServiceClient> client(
       new ChromeMetricsServiceClient(state_manager));
   client->Initialize();
 
   return client;
 }
 
 // static
 void ChromeMetricsServiceClient::RegisterPrefs(PrefRegistrySimple* registry) {
   metrics::MetricsService::RegisterPrefs(registry);
   metrics::StabilityMetricsHelper::RegisterPrefs(registry);
 
-  RegisterInstallerFileMetricsPreferences(registry);
+  RegisterFileMetricsPreferences(registry);
 
   metrics::RegisterMetricsReportingStatePrefs(registry);
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
   AndroidMetricsProvider::RegisterPrefs(registry);
 #endif  // BUILDFLAG(ANDROID_JAVA_UI)
 
 #if defined(ENABLE_PLUGINS)
   PluginMetricsProvider::RegisterPrefs(registry);
 #endif  // defined(ENABLE_PLUGINS)
@@ skipping 150 matching lines @@
       std::unique_ptr<metrics::MetricsProvider>(
           new ChromeStabilityMetricsProvider(
               g_browser_process->local_state())));
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new metrics::GPUMetricsProvider));
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(
           new metrics::ScreenInfoMetricsProvider));
 
-  metrics_service_->RegisterMetricsProvider(CreateInstallerFileMetricsProvider(
+  metrics_service_->RegisterMetricsProvider(CreateFileMetricsProvider(
       ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled()));
 
   drive_metrics_provider_ = new metrics::DriveMetricsProvider(
       content::BrowserThread::GetTaskRunnerForThread(
           content::BrowserThread::FILE),
       chrome::FILE_LOCAL_STATE);
   metrics_service_->RegisterMetricsProvider(
       std::unique_ptr<metrics::MetricsProvider>(drive_metrics_provider_));
 
   profiler_metrics_provider_ = new metrics::ProfilerMetricsProvider(
@@ skipping 339 matching lines @@
   }
 }
 
 void ChromeMetricsServiceClient::OnURLOpenedFromOmnibox(OmniboxLog* log) {
   metrics_service_->OnApplicationNotIdle();
 }
 
 bool ChromeMetricsServiceClient::IsUMACellularUploadLogicEnabled() {
   return metrics::IsCellularLogicEnabled();
 }