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

chrome/installer/setup/setup_main.cc

 // Copyright (c) 2012 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/installer/setup/setup_main.h"
 
 #include <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_version_info.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/metrics/histogram_base.h"
+#include "base/metrics/histogram_persistence.h"
+#include "base/metrics/persistent_memory_allocator.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/process/memory.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
@@ skipping 1588 matching lines @@
 }  // namespace installer
 
 int WINAPI wWinMain(HINSTANCE instance, HINSTANCE prev_instance,
                     wchar_t* command_line, int show_command) {
   // Check to see if the CPU is supported before doing anything else. There's
   // very little than can safely be accomplished if the CPU isn't supported
   // since dependent libraries (e.g., base) may use invalid instructions.
   if (!installer::IsProcessorSupported())
     return installer::CPU_NOT_SUPPORTED;
 
+  // Create a persistent space for any histograms that can be reported later
+  // by the Chrome process. The "id" is a timestamp so that Chrome can tell
+  // if it has already reported these metrics. No name is given so no internal
+  // histograms are created or managed; such would be pointless because they
+  // would have to be created on the heap and thus never be persisted for
+  // reporting.
+  uint32_t allocator_id = static_cast<uint32_t>(base::Time::Now().ToTimeT());
+  base::SetPersistentHistogramMemoryAllocator(
+      new base::LocalPersistentMemoryAllocator(1 << 20,  // 1 MiB
+                                               allocator_id,
+                                               std::string()));
+
+  // Now that histograms have a persistent place to be stored, the allocator
+  // itself can create histograms within that space.
+  base::GetPersistentHistogramMemoryAllocator()
+      ->CreateHistograms(google_update::kSetupHistogramAllocatorName);
+
   // The exit manager is in charge of calling the dtors of singletons.
   base::AtExitManager exit_manager;
   base::CommandLine::Init(0, NULL);
 
   // install_util uses chrome paths.
   chrome::RegisterPathProvider();
 
   const MasterPreferences& prefs = MasterPreferences::ForCurrentProcess();
   installer::InitInstallerLogging(prefs);
 
@@ skipping 129 matching lines @@
   // MSI demands that custom actions always return 0 (ERROR_SUCCESS) or it will
   // rollback the action. If we're uninstalling we want to avoid this, so always
   // report success, squashing any more informative return codes.
   if (!(installer_state.is_msi() && is_uninstall)) {
     // Note that we allow the status installer::UNINSTALL_REQUIRES_REBOOT
     // to pass through, since this is only returned on uninstall which is
     // never invoked directly by Google Update.
     return_code = InstallUtil::GetInstallReturnCode(install_status);
   }
 
+  // Save all the persistent histograms to a single file on disk for reading
+  // by the browser so it can be reported. For atomicity, first write to a
+  // temporary file and then rename it. The ImportantFileWriter would be good
+  // for this except it supports only std::string for its data.
+  base::FilePath file_path = installer_state.target_path().AppendASCII(
+      google_update::kSetupHistogramAllocatorName);
+  base::FilePath tmp_file_path;
+  base::DeleteFile(file_path, false);
+  if (base::CreateTemporaryFileInDir(file_path.DirName(), &tmp_file_path)) {
+    base::File histograms(tmp_file_path,
+                          base::File::FLAG_CREATE | base::File::FLAG_WRITE);
+    if (histograms.IsValid()) {
+      base::PersistentMemoryAllocator* alloc =
+          base::GetPersistentHistogramMemoryAllocator();
+      int used = static_cast<int>(alloc->used());
+      if (histograms.Write(0, static_cast<const char*>(alloc->data()),
+                           used) == used &&
+          histograms.Flush()) {
+        histograms.Close();
+        if (base::ReplaceFile(tmp_file_path, file_path, nullptr)) {
+          VLOG(1) << "Persistent histograms saved in file: "
+                  << file_path.AsUTF8Unsafe();
+        }
+      }
+    }
+  }
+  base::DeleteFile(tmp_file_path, false);
+
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }