Add SRT log upload result metrics.

chrome/browser/component_updater/sw_reporter_installer_win.cc

 // Copyright (c) 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/component_updater/sw_reporter_installer_win.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
+#include "base/strings/string_tokenizer.h"
 #include "base/task_runner_util.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "base/win/registry.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/srt_global_error_win.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
@@ skipping 42 matching lines @@
                                0x05, 0xa5, 0x62, 0x4b, 0x2e, 0xc7, 0xb7, 0x1c,
                                0x5f, 0xea, 0xf0, 0x88, 0xf6, 0x97, 0x9b, 0xc7};
 
 const base::FilePath::CharType kSwReporterExeName[] =
     FILE_PATH_LITERAL("software_reporter_tool.exe");
 
 // Where to fetch the reporter exit code in the registry.
 const wchar_t kSoftwareRemovalToolRegistryKey[] =
     L"Software\\Google\\Software Removal Tool";
 const wchar_t kCleanerSuffixRegistryKey[] = L"Cleaner";
+const wchar_t kEndTimeRegistryValueName[] = L"EndTime";
 const wchar_t kExitCodeRegistryValueName[] = L"ExitCode";
+const wchar_t kStartTimeRegistryValueName[] = L"StartTime";
+const wchar_t kUploadResultsValueName[] = L"UploadResults";
 const wchar_t kVersionRegistryValueName[] = L"Version";
-const wchar_t kStartTimeRegistryValueName[] = L"StartTime";
-const wchar_t kEndTimeRegistryValueName[] = L"EndTime";
 
 // Field trial strings.
 const char kSRTPromptTrialName[] = "SRTPromptFieldTrial";
 const char kSRTPromptOnGroup[] = "On";
 const char kSRTPromptSeedParamName[] = "Seed";
 
 // Exit codes that identify that a cleanup is needed.
 const int kCleanupNeeded = 0;
 const int kNothingFound = 2;
 const int kPostRebootCleanupNeeded = 4;
@@ skipping 23 matching lines @@
     DCHECK_LT(version.components()[1], 0x10000);
     major_version += 0x100 * version.components()[1];
   }
   if (version.components().size() >= 3) {
     DCHECK_LT(version.components()[2], 0x100);
     major_version += version.components()[2];
   }
   UMA_HISTOGRAM_SPARSE_SLOWLY("SoftwareReporter.MajorVersion", major_version);
 }
 
+void ReportUploadsWithUma(const base::string16& upload_results) {
+  base::WStringTokenizer tokenizer(upload_results, L";");
+  int failure_count = 0;
+  int success_count = 0;
+  int longest_failure_run = 0;
+  int current_failure_run = 0;
+  bool last_result = false;
+  while (tokenizer.GetNext()) {
+    if (tokenizer.token() == L"0") {
+      ++failure_count;
+      ++current_failure_run;
+      last_result = false;
+    } else {
+      ++success_count;
+      current_failure_run = 0;
+      last_result = true;
+    }
+
+    if (current_failure_run > longest_failure_run)
+      longest_failure_run = current_failure_run;
+  }
+
+  UMA_HISTOGRAM_COUNTS_100("SoftwareReporter.UploadFailureCount",
+                           failure_count);
+  UMA_HISTOGRAM_COUNTS_100("SoftwareReporter.UploadSuccessCount",
+                           success_count);
+  UMA_HISTOGRAM_COUNTS_100("SoftwareReporter.UploadLongestFailureRun",
+                           longest_failure_run);
+  UMA_HISTOGRAM_BOOLEAN("SoftwareReporter.LastUploadResult", last_result);
+}
+
 // This function is called on the UI thread to report the SwReporter exit code
 // and then clear it from the registry as well as clear the execution state
 // from the local state. This could be called from an interruptible worker
 // thread so should be resilient to unexpected shutdown. |version| is provided
 // so the kSwReporterPromptVersion prefs can be set.
 void ReportAndClearExitCode(int exit_code, const std::string& version) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("SoftwareReporter.ExitCode", exit_code);
   base::win::RegKey srt_key(HKEY_CURRENT_USER, kSoftwareRemovalToolRegistryKey,
                             KEY_WRITE);
   srt_key.DeleteValue(kExitCodeRegistryValueName);
@@ skipping 205 matching lines @@
 };
 
 wchar_t SwReporterInstallerTraits::version_dir_[] = {};
 
 }  // namespace
 
 void RegisterSwReporterComponent(ComponentUpdateService* cus,
                                  PrefService* prefs) {
   // The Sw reporter doesn't need to run if the user isn't reporting metrics and
   // isn't in the SRTPrompt field trial "On" group.
-  if (!ChromeMetricsServiceAccessor::IsMetricsReportingEnabled() &&
+  if (false &&

[MAD, 2015/02/11 22:26:49]

Héhé... :-)

You know you can also simply enable UMA... ;-)
Or you could force the fieldtrial on the command line.

[robertshield, 2015/02/11 22:36:16]

Heh, oops, shouldn't leave test code lying around like that. Thanks for
catching!

+      !ChromeMetricsServiceAccessor::IsMetricsReportingEnabled() &&
       base::FieldTrialList::FindFullName(kSRTPromptTrialName) !=
           kSRTPromptOnGroup) {
     return;
   }
 
   // Check if we have information from Cleaner and record UMA statistics.
   base::string16 cleaner_key_name(kSoftwareRemovalToolRegistryKey);
   cleaner_key_name.append(1, L'\\').append(kCleanerSuffixRegistryKey);
   base::win::RegKey cleaner_key(
       HKEY_CURRENT_USER, cleaner_key_name.c_str(), KEY_ALL_ACCESS);
@@ skipping 36 matching lines @@
     if (exit_code == kPostRebootCleanupNeeded ||
         exit_code == kDelayedPostRebootCleanupNeeded) {
       // Check if we are running after the user has rebooted.
       base::TimeDelta elapsed(base::Time::Now() -
                               base::Time::FromInternalValue(start_time_value));
       DCHECK_GT(elapsed.InMilliseconds(), 0);
       UMA_HISTOGRAM_BOOLEAN(
           "SoftwareReporter.Cleaner.HasRebooted",
           static_cast<uint64>(elapsed.InMilliseconds()) > ::GetTickCount());
     }
+
+    if (cleaner_key.HasValue(kUploadResultsValueName)) {
+      base::string16 upload_results;
+      cleaner_key.ReadValue(kUploadResultsValueName, &upload_results);
+      ReportUploadsWithUma(upload_results);
+    }
   }
 
   // Install the component.
   scoped_ptr<ComponentInstallerTraits> traits(
       new SwReporterInstallerTraits(prefs));
   // |cus| will take ownership of |installer| during installer->Register(cus).
   DefaultComponentInstaller* installer =
       new DefaultComponentInstaller(traits.Pass());
   installer->Register(cus);
 }
@@ skipping 12 matching lines @@
   registry->RegisterStringPref(
       prefs::kSwReporterPromptVersion, "",
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
   registry->RegisterStringPref(
       prefs::kSwReporterPromptSeed, "",
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 }  // namespace component_updater