Persist setup metrics and have Chrome report them during UMA upload.

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 14 matching lines @@
 #include "chrome/browser/google/google_brand.h"
 #include "chrome/browser/metrics/chrome_stability_metrics_provider.h"
 #include "chrome/browser/metrics/time_ticks_experiment_win.h"
 #include "chrome/browser/ui/browser_otr_state.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.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_service.h"
 #include "components/metrics/net/net_metrics_log_uploader.h"
 #include "components/metrics/net/network_metrics_provider.h"
 #include "components/metrics/net/version_utils.h"
 #include "components/metrics/profiler/profiler_metrics_provider.h"
 #include "components/metrics/profiler/tracking_synchronizer.h"
 #include "components/metrics/stability_metrics_helper.h"
 #include "components/metrics/ui/screen_info_metrics_provider.h"
@@ skipping 123 matching lines @@
   client->Initialize();
 
   return client;
 }
 
 // static
 void ChromeMetricsServiceClient::RegisterPrefs(PrefRegistrySimple* registry) {
   metrics::MetricsService::RegisterPrefs(registry);
   metrics::StabilityMetricsHelper::RegisterPrefs(registry);
 
+  metrics::FileMetricsProvider::RegisterPrefs(
+      registry, installer::kSetupHistogramAllocatorName);
+
 #if BUILDFLAG(ANDROID_JAVA_UI)
   AndroidMetricsProvider::RegisterPrefs(registry);
 #endif  // BUILDFLAG(ANDROID_JAVA_UI)
 
 #if defined(ENABLE_PLUGINS)
   PluginMetricsProvider::RegisterPrefs(registry);
 #endif  // defined(ENABLE_PLUGINS)
 }
 
 metrics::MetricsService* ChromeMetricsServiceClient::GetMetricsService() {
@@ skipping 138 matching lines @@
           base::Bind(&chrome::IsOffTheRecordSessionActive))));
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new ChromeStabilityMetricsProvider(
           g_browser_process->local_state())));
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new metrics::GPUMetricsProvider));
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(
           new metrics::ScreenInfoMetricsProvider));
 
+#if defined(OS_WIN)
+  scoped_ptr<metrics::FileMetricsProvider> file_metrics(
+      new metrics::FileMetricsProvider(metrics_service_.get(),
+                                       g_browser_process->local_state()));
+  file_metrics->RegisterFile(
+      base::CommandLine::ForCurrentProcess()->GetProgram().DirName()

[grt (UTC plus 2), 2016/02/08 18:09:18]

use base::PathService::Get(base::DIR_EXE, &dir) instead of
GetProgram().DirName()

[bcwhite, 2016/02/09 21:08:45]

Done.

+          .AppendASCII(installer::kSetupHistogramAllocatorName)
+          .AddExtension(L".pma"),

[Alexei Svitkine (slow), 2016/02/09 19:48:15]

Can this logic be somewhere outside this file? Seems like an implementation
detail of what we're trying to watch - maybe make a Create*() method for this
provider somewhere?

[grt (UTC plus 2), 2016/02/15 15:42:39]

ping

[bcwhite, 2016/02/15 19:22:10]

How about just a constant that has both the file name and extension together? 
The alternative would be a function that takes a dir-name and adds both.

[Alexei Svitkine (slow), 2016/02/17 21:55:35]

Sorry, in this comment I meant all the stuff to initialize the
FileMetricsProvider(). Can you add a Create*() method for the provider that does
this initialization? Having a constant that includes the extension also SGTM but
that's orthogonal.

[bcwhite, 2016/02/18 01:46:56]

As in
class FileMetricsProvider {
...
  static scoped_ptr<FileMetricsProvider> CreateForFile(...) {...}
...
}
???

This would effectively merge two calls into one but still have to include all
the parameters of both.  It also assumes only one file to be registered.

Do I have that right?  You sure?

[Alexei Svitkine (slow), 2016/02/18 15:50:32]

Sorry, not exactly what I meant. I mean not having all this code inline here.
You can still keep it in this file, but make a helper function in the anon
namespace, so as not to have the specific logic be inside the function that adds
all the providers (as this function is already long enough).

[bcwhite, 2016/02/18 19:35:01]

Done.

+      metrics::FileMetricsProvider::FILE_HISTOGRAMS_ATOMIC,
+      installer::kSetupHistogramAllocatorName);
+  metrics_service_->RegisterMetricsProvider(std::move(file_metrics));
+#endif
+
   drive_metrics_provider_ = new metrics::DriveMetricsProvider(
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::FILE),
       chrome::FILE_LOCAL_STATE);
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(drive_metrics_provider_));
 
   profiler_metrics_provider_ =
       new metrics::ProfilerMetricsProvider(base::Bind(&IsCellularLogicEnabled));
   metrics_service_->RegisterMetricsProvider(
@@ skipping 168 matching lines @@
   if (!ServiceProcessControl::GetInstance()->GetHistograms(callback, timeout)) {
     // Assume |num_async_histogram_fetches_in_progress_| is not changed by
     // |GetHistograms()|.
     DCHECK_EQ(num_async_histogram_fetches_in_progress_, 2);
     // Assign |num_async_histogram_fetches_in_progress_| above and decrement it
     // here to make code work even if |GetHistograms()| fired |callback|.
     --num_async_histogram_fetches_in_progress_;
   }
 #endif  // !ENABLE_PRINT_PREVIEW
 
-  // Set up the callback to task to call after we receive histograms from all
+  // Set up the callback task to call after we receive histograms from all
   // child processes. |timeout| specifies how long to wait before absolutely
   // calling us back on the task.
   content::FetchHistogramsAsynchronously(base::MessageLoop::current(), callback,
                                          timeout);
 }
 
 void ChromeMetricsServiceClient::OnHistogramSynchronizationDone() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // This function should only be called as the callback from an ansynchronous
@@ skipping 74 matching lines @@
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 void ChromeMetricsServiceClient::OnURLOpenedFromOmnibox(OmniboxLog* log) {
   metrics_service_->OnApplicationNotIdle();
 }