Add installer metrics for operations on the archive.

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 <stddef.h>
 #include <stdint.h>
 
 #include <string>
 
 #include "base/at_exit.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/macros.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/metrics/histogram_macros.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/time/time.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "base/win/process_startup_helper.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_constants.h"
@@ skipping 202 matching lines @@
 // Returns false on failure, in which case |install_status| contains the error
 // code and the result is written to the registry (via WriteInstallerResult).
 bool UncompressAndPatchChromeArchive(
     const installer::InstallationState& original_state,
     const installer::InstallerState& installer_state,
     installer::ArchivePatchHelper* archive_helper,
     installer::ArchiveType* archive_type,
     installer::InstallStatus* install_status,
     const base::Version& previous_version) {
   installer_state.UpdateStage(installer::UNCOMPRESSING);
+  base::TimeTicks start_time = base::TimeTicks::Now();
   if (!archive_helper->Uncompress(NULL)) {
     *install_status = installer::UNCOMPRESSION_FAILED;
     installer_state.WriteInstallerResult(*install_status,
                                          IDS_INSTALL_UNCOMPRESSION_FAILED_BASE,
                                          NULL);
     return false;
   }
+  base::TimeDelta elapsed_time = base::TimeTicks::Now() - start_time;
 
   // Short-circuit if uncompression produced the uncompressed archive rather
   // than a patch file.
   if (base::PathExists(archive_helper->target())) {

[bcwhite, 2016/02/25 16:46:50]

Could extract the condition into a bool and have only one instantiation of
UMA_HISTOGRAM_BOOLEAN.  Each instance is about 15 lines of code and includes a
std::map lookup.

[grt (UTC plus 2), 2016/02/25 17:45:26]

Done.

     *archive_type = installer::FULL_ARCHIVE_TYPE;
+    UMA_HISTOGRAM_BOOLEAN("Setup.Install.HasArchivePatch", false);
+    // Uncompression alone hopefully takes less than 3 minutes even on slow
+    // machines.
+    UMA_HISTOGRAM_MEDIUM_TIMES("Setup.Install.UncompressFullArchiveTime",
+                               elapsed_time);
     return true;
   }
 
+  UMA_HISTOGRAM_BOOLEAN("Setup.Install.HasArchivePatch", true);
+  UMA_HISTOGRAM_MEDIUM_TIMES("Setup.Install.UncompressArchivePatchTime",
+                             elapsed_time);
+
   // Find the installed version's archive to serve as the source for patching.
   base::FilePath patch_source(installer::FindArchiveToPatch(original_state,
                                                             installer_state,
                                                             previous_version));
   if (patch_source.empty()) {
     LOG(ERROR) << "Failed to find archive to patch.";
     *install_status = installer::DIFF_PATCH_SOURCE_MISSING;
     installer_state.WriteInstallerResult(*install_status,
                                          IDS_INSTALL_UNCOMPRESSION_FAILED_BASE,
                                          NULL);
     return false;
   }
   archive_helper->set_patch_source(patch_source);
 
   // Try courgette first. Failing that, try bspatch.
+  // Patch application sometimes takes a very long time, so use 100 buckets for
+  // up to an hour.
+  SCOPED_UMA_HISTOGRAM_LONG_TIMER("Setup.Install.ApplyArchivePathTime");

[bcwhite, 2016/02/25 16:46:50]

ApplyArchivePatchTime  (Patch vs Path)

[grt (UTC plus 2), 2016/02/25 17:45:26]

Done.

   installer_state.UpdateStage(installer::ENSEMBLE_PATCHING);
   if (!archive_helper->EnsemblePatch()) {
     installer_state.UpdateStage(installer::BINARY_PATCHING);
     if (!archive_helper->BinaryPatch()) {
       *install_status = installer::APPLY_DIFF_PATCH_FAILED;
       installer_state.WriteInstallerResult(
           *install_status, IDS_INSTALL_UNCOMPRESSION_FAILED_BASE, NULL);
       return false;
     }
   }
@@ skipping 1119 matching lines @@
         !base::PathExists(uncompressed_archive)) {
       LOG(ERROR) << "Cannot install Chrome without an uncompressed archive.";
       installer_state.WriteInstallerResult(
           INVALID_ARCHIVE, IDS_INSTALL_INVALID_ARCHIVE_BASE, NULL);
       return INVALID_ARCHIVE;
     }
     *archive_type = FULL_ARCHIVE_TYPE;
   }
 
   // Unpack the uncompressed archive.
+  base::TimeTicks start_time = base::TimeTicks::Now();
   if (LzmaUtil::UnPackArchive(uncompressed_archive.value(),
                               unpack_path.value(),
                               NULL)) {
     installer_state.WriteInstallerResult(
         UNPACKING_FAILED,
         IDS_INSTALL_UNCOMPRESSION_FAILED_BASE,
         NULL);
     return UNPACKING_FAILED;
   }
+  UMA_HISTOGRAM_MEDIUM_TIMES("Setup.Install.UnpackFullArchiveTime",
+                             base::TimeTicks::Now() - start_time);
 
   VLOG(1) << "unpacked to " << unpack_path.value();
   base::FilePath src_path(
       unpack_path.Append(kInstallSourceChromeDir));
   scoped_ptr<Version>
       installer_version(GetMaxVersionFromArchiveDir(src_path));
   if (!installer_version.get()) {
     LOG(ERROR) << "Did not find any valid version in installer.";
     install_status = INVALID_ARCHIVE;
     installer_state.WriteInstallerResult(install_status,
@@ skipping 343 matching lines @@
     // to pass through, since this is only returned on uninstall which is
     // never invoked directly by Google Update.
     return_code = InstallUtil::GetInstallReturnCode(install_status);
   }
 
   installer::EndPersistentHistogramStorage(installer_state.target_path());
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }