Trigger the SW reporter to run once a week for users with UMA enabled.

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 <string>
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.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/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/common/pref_names.h"
 #include "components/component_updater/component_updater_paths.h"
 #include "components/component_updater/component_updater_service.h"
 #include "components/component_updater/component_updater_utils.h"
 #include "components/component_updater/default_component_installer.h"
 #include "components/component_updater/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace component_updater {
 
 namespace {
 
 // These values are used to send UMA information and are replicated in the
 // histograms.xml file, so the order MUST NOT CHANGE.
 enum SwReporterUmaValue {
   SW_REPORTER_EXPLICIT_REQUEST = 0,
   SW_REPORTER_STARTUP_RETRY = 1,
   SW_REPORTER_RETRIED_TOO_MANY_TIMES = 2,
   SW_REPORTER_START_EXECUTION = 3,
   SW_REPORTER_FAILED_TO_START = 4,
   SW_REPORTER_REGISTRY_EXIT_CODE = 5,
   SW_REPORTER_RESET_RETRIES = 6,
   SW_REPORTER_MAX,
 };
 
 // The maximum number of times to retry a download on startup.
 const int kMaxRetry = 20;
 
+// The number of days to wait before triggering another sw reporter run.
+const int kDaysBetweenSwReporterRuns = 7;
+
 // CRX hash. The extension id is: gkmgaooipdjhmangpemjhigmamcehddo. The hash was
 // generated in Python with something like this:
 // hashlib.sha256().update(open("<file>.crx").read()[16:16+294]).digest().
 const uint8 kSha256Hash[] = {0x6a, 0xc6, 0x0e, 0xe8, 0xf3, 0x97, 0xc0, 0xd6,
                              0xf4, 0xc9, 0x78, 0x6c, 0x0c, 0x24, 0x73, 0x3e,
                              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");
@@ skipping 146 matching lines @@
 void ExecuteSwReporter(ComponentUpdateService* cus, PrefService* prefs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // If we have a pending execution, send metrics about it so we can account for
   // missing executions.
   if (prefs->GetInteger(prefs::kSwReporterExecuteTryCount) > 0)
     ReportUmaStep(SW_REPORTER_RESET_RETRIES);
   // This is an explicit call, so let's forget about previous incomplete
   // execution attempts and start from scratch.
   prefs->SetInteger(prefs::kSwReporterExecuteTryCount, kMaxRetry);
   ReportUmaStep(SW_REPORTER_EXPLICIT_REQUEST);
+  // Record the requested trigger time.
+  prefs->SetInt64(prefs::kSwReporterLastTimeTriggered,
+                  base::Time::Now().ToInternalValue());
   const std::vector<std::string> registered_components(cus->GetComponentIDs());
   if (std::find(registered_components.begin(),
                 registered_components.end(),
                 SwReporterInstallerTraits::ID()) ==
       registered_components.end()) {
     RegisterComponent(cus, prefs);
   } else if (!SwReporterInstallerTraits::VersionPath().empty()) {
     // Here, we already have a fully registered and installed component
     // available for immediate use. This doesn't handle cases where the version
     // folder is there but the executable is not within in. This is a corruption
     // we don't want to handle here.
     ExecuteReporter(SwReporterInstallerTraits::VersionPath());
   }
   // If the component is registered but the version path is not available, it
   // means the component was not fully installed yet, and it should run the
   // reporter when ComponentReady is called.
 }
 
-void ExecutePendingSwReporter(ComponentUpdateService* cus, PrefService* prefs) {
+void ExecuteSwReporterIfRequired(ComponentUpdateService* cus,
+                                 PrefService* prefs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  // The Sw reporter shouldn't run if the user isn't reporting metrics.
+  if (!ChromeMetricsServiceAccessor::IsMetricsReportingEnabled())
+    return;
+
   // Register the existing component for updates.
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
       FROM_HERE,
       base::Bind(&base::PathExists, SwReporterInstallerTraits::install_dir()),
       base::Bind(&MaybeRegisterComponent, cus, prefs));
 
   // Run the reporter if there is a pending execution request.
   int execute_try_count = prefs->GetInteger(prefs::kSwReporterExecuteTryCount);
   if (execute_try_count > 0) {
@@ skipping 11 matching lines @@
 
     // The previous request has not completed. The reporter will run again
     // when ComponentReady is called or the request is abandoned if it has
     // been tried too many times.
     prefs->SetInteger(prefs::kSwReporterExecuteTryCount, --execute_try_count);
     if (execute_try_count > 0)
       ReportUmaStep(SW_REPORTER_STARTUP_RETRY);
     else
       ReportUmaStep(SW_REPORTER_RETRIED_TOO_MANY_TIMES);
   }
+
+  // Run the reporter if it hasn't been triggered in the last
+  // kDaysBetweenSwReporterRuns days.
+  const base::Time last_time_triggered = base::Time::FromInternalValue(
+      prefs->GetInt64(prefs::kSwReporterLastTimeTriggered));
+  if ((base::Time::Now() - last_time_triggered).InDays() >=
+          kDaysBetweenSwReporterRuns) {
+    ExecuteSwReporter(cus, prefs);
+  }
 }
 
 void RegisterPrefsForSwReporter(PrefRegistrySimple* registry) {
   registry->RegisterIntegerPref(prefs::kSwReporterExecuteTryCount, 0);
+  registry->RegisterInt64Pref(prefs::kSwReporterLastTimeTriggered, 0);
 }
 
 }  // namespace component_updater