Delay PersistentHistogramAllocator creation until it's known to be used.

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 85 matching lines @@
 #if !defined(OS_CHROMEOS)
 #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.
-const char kBrowserMetricsFileName[] = "SavedMetrics";
 
 // 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) {
-  base::GlobalHistogramAllocator* allocator =
-      base::GlobalHistogramAllocator::GetEvenIfDisabled();
-  if (allocator)
-    metrics::FileMetricsProvider::RegisterPrefs(registry, allocator->Name());
+  metrics::FileMetricsProvider::RegisterPrefs(
+      registry, ChromeMetricsServiceClient::kBrowserMetricsName);
 
 #if defined(OS_WIN)
   metrics::FileMetricsProvider::RegisterPrefs(
       registry, installer::kSetupHistogramAllocatorName);
 #endif
 }
 
-// A wrapper around base::DeleteFile that has no return value and thus can be
-// used as a callback.
-void LocalDeleteFile(const base::FilePath& path) {
-  base::DeleteFile(path, /*recursive=*/false);
-}
-
 std::unique_ptr<metrics::FileMetricsProvider>
 CreateInstallerFileMetricsProvider(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()));
 
-  // 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.
-  // TODO(bcwhite): Actually create those files.
+  // 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(kBrowserMetricsFileName)
+        metrics_file
+            .AppendASCII(ChromeMetricsServiceClient::kBrowserMetricsName)
             .AddExtension(base::PersistentMemoryAllocator::kFileExtension);
+
     if (metrics_reporting_enabled) {
-      // Metrics get persisted to disk when the process exits. Store the path
-      // to that file in the global allocator for use at exit time and tell
-      // the FileMetricsProvider about that file so it can read one created
-      // by the previous run.
-      base::GlobalHistogramAllocator* allocator =
-          base::GlobalHistogramAllocator::GetEvenIfDisabled();
-      if (allocator) {
-        const char* allocator_name = allocator->Name();
-        allocator->SetPersistentLocation(metrics_file);
-        file_metrics_provider->RegisterSource(
-            metrics_file,
-            metrics::FileMetricsProvider::SOURCE_HISTOGRAMS_ATOMIC_FILE,
-            metrics::FileMetricsProvider::ASSOCIATE_PREVIOUS_RUN,
-            allocator_name);
-      }
+      // Enable reading any existing saved metrics.
+      file_metrics_provider->RegisterSource(
+          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(&LocalDeleteFile, metrics_file));
+                            base::Bind(base::IgnoreResult(&base::DeleteFile),
+                                       metrics_file, /*recursive=*/false));
     }
   }
 
 #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;
 }
 
 }  // 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),
 #endif
       waiting_for_collect_final_metrics_step_(false),
       num_async_histogram_fetches_in_progress_(0),
       profiler_metrics_provider_(nullptr),
 #if defined(ENABLE_PLUGINS)
@@ skipping 512 matching lines @@
   }
 }
 
 void ChromeMetricsServiceClient::OnURLOpenedFromOmnibox(OmniboxLog* log) {
   metrics_service_->OnApplicationNotIdle();
 }
 
 bool ChromeMetricsServiceClient::IsUMACellularUploadLogicEnabled() {
   return metrics::IsCellularLogicEnabled();
 }