Adding a SW reporter component updater

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/win/registry.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/component_updater/component_updater_service.h"
+#include "chrome/browser/component_updater/component_updater_utils.h"
+#include "chrome/browser/component_updater/default_component_installer.h"
+#include "chrome/common/chrome_paths.h"
+#include "chrome/common/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_MAX,
+};
+
+// The maximum number of times to retry a download on startup.
+const int kMaxRetry = 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");
+
+// Where to fetch the reporter exit code in the registry.
+const wchar_t kSoftwareRemovalToolRegistryKey[] =
+    L"Software\\Google\\Software Removal Tool";
+const wchar_t kExitCodeRegistryValueName[] = L"ExitCode";
+
+void ReportUmaStep(SwReporterUmaValue value) {
+  UMA_HISTOGRAM_ENUMERATION("SoftwareReporter.Step", value, SW_REPORTER_MAX);
+}
+
+// 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.
+void ReportAndClearExitCode(int exit_code) {
+  UMA_HISTOGRAM_SPARSE_SLOWLY("SoftwareReporter.ExitCode", exit_code);
+
+  base::win::RegKey srt_key(
+      HKEY_CURRENT_USER, kSoftwareRemovalToolRegistryKey, KEY_WRITE);
+  srt_key.DeleteValue(kExitCodeRegistryValueName);
+
+  // Now that we are done we can reset the try count.
+  g_browser_process->local_state()->SetInteger(
+      prefs::kSwReporterExecuteTryCount, 0);
+}
+
+// This function is called from a worker thread to launch the SwReporter and
+// wait for termination to collect its exit code. This task could be interrupted
+// by a shutdown at anytime, so it shouldn't depend on anything external that
+// could be shutdown beforehand.
+void LaunchAndWaitForExit(const base::FilePath& exe_path) {
+  const base::CommandLine reporter_command_line(exe_path);
+  base::ProcessHandle scan_reporter_process = base::kNullProcessHandle;
+  if (!base::LaunchProcess(reporter_command_line,
+                           base::LaunchOptions(),
+                           &scan_reporter_process)) {
+    ReportUmaStep(SW_REPORTER_FAILED_TO_START);
+    return;
+  }
+  ReportUmaStep(SW_REPORTER_START_EXECUTION);
+
+  int exit_code = -1;
+  bool success = base::WaitForExitCode(scan_reporter_process, &exit_code);
+  DCHECK(success);
+  base::CloseProcessHandle(scan_reporter_process);
+  scan_reporter_process = base::kNullProcessHandle;
+  // It's OK if this doesn't complete, the work will continue on next startup.
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&ReportAndClearExitCode, exit_code));
+}
+
+void ExecuteReporter(const base::FilePath& install_dir) {
+  base::WorkerPool::PostTask(
+      FROM_HERE,
+      base::Bind(&LaunchAndWaitForExit, install_dir.Append(kSwReporterExeName)),
+      true);
+}
+
+class SwReporterInstallerTraits : public ComponentInstallerTraits {
+ public:
+  explicit SwReporterInstallerTraits(PrefService* prefs) : prefs_(prefs) {}
+
+  virtual ~SwReporterInstallerTraits() {}
+
+  virtual bool VerifyInstallation(const base::FilePath& dir) const {
+    return base::PathExists(dir.Append(kSwReporterExeName));
+  }
+
+  virtual bool CanAutoUpdate() const { return true; }
+
+  virtual bool OnCustomInstall(const base::DictionaryValue& manifest,
+                               const base::FilePath& install_dir) {
+    return true;
+  }
+
+  virtual void ComponentReady(const base::Version& version,
+                              const base::FilePath& install_dir,
+                              scoped_ptr<base::DictionaryValue> manifest) {
+    wcsncpy_s(version_dir_,
+              _MAX_PATH,
+              install_dir.value().c_str(),
+              install_dir.value().size());
+    // Only execute the reporter if there is still a pending request for it..
+    if (prefs_->GetInteger(prefs::kSwReporterExecuteTryCount))
+      ExecuteReporter(install_dir);
+  }
+
+  virtual base::FilePath GetBaseDirectory() const { return install_dir(); }
+
+  virtual void GetHash(std::vector<uint8>* hash) const { GetPkHash(hash); }
+
+  virtual std::string GetName() const { return "Software Reporter Tool"; }
+
+  static const base::FilePath install_dir() {

[Sorin Jianu, 2014/06/20 05:37:38]

This const not needed on the return value.

[MAD, 2014/06/20 14:40:15]

Done.

+    // The base directory on windows looks like:
+    // <profile>\AppData\Local\Google\Chrome\User Data\SwReporter\.
+    base::FilePath result;
+    PathService::Get(chrome::DIR_USER_DATA, &result);
+    return result.Append(FILE_PATH_LITERAL("SwReporter"));
+  }
+
+  static const std::string ID() {

[Sorin Jianu, 2014/06/20 05:37:38]

This const is not needed here.

[MAD, 2014/06/20 14:40:15]

Done.

+    CrxComponent component;
+    component.version = Version("0.0.0.0");
+    GetPkHash(&component.pk_hash);
+    return component_updater::GetCrxComponentID(component);

[Sorin Jianu, 2014/06/20 05:37:38]

I will provide a function to convert a component hash to a component id, as
discussed. Seems ok for now.

[MAD, 2014/06/20 14:40:15]

Thanks!

+  }
+
+  static const base::FilePath VersionPath() {

[Sorin Jianu, 2014/06/20 05:37:38]

const not needed.

[MAD, 2014/06/20 14:40:15]

Done.

+    return base::FilePath(version_dir_);
+  }
+
+ private:
+  static void GetPkHash(std::vector<uint8>* hash) {
+    DCHECK(hash);
+    hash->assign(kSha256Hash, kSha256Hash + sizeof(kSha256Hash));
+  }
+
+  PrefService* prefs_;
+  static wchar_t version_dir_[_MAX_PATH];
+};
+
+wchar_t SwReporterInstallerTraits::version_dir_[] = {};
+
+void RegisterComponent(ComponentUpdateService* cus, PrefService* prefs) {

[Sorin Jianu, 2014/06/20 05:37:38]

Need to ask waffles@ if the threading model is correct for the installer. Also,
asserting that the code runs on the correct thread could be useful. 

[MAD, 2014/06/20 14:40:15]

Done.

+  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);
+}
+
+bool IsComponentInstalled() {
+  return base::PathExists(
+      SwReporterInstallerTraits::VersionPath().Append(kSwReporterExeName));
+}
+
+void ExecuteAndOrRegisterReporter(ComponentUpdateService* cus,
+                                  PrefService* prefs,
+                                  bool execute) {
+  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 (execute) {
+    ExecuteReporter(SwReporterInstallerTraits::VersionPath());
+  }
+}
+
+}  // namespace
+
+void ExecuteSwReporter(ComponentUpdateService* cus, PrefService* prefs) {
+  // 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);
+  base::PostTaskAndReplyWithResult(

[Sorin Jianu, 2014/06/20 05:37:38]

Do we need to post and reply? Would just posting to the FILE to run
ExecuteAndOrRegisterReporter suffice?
I am thinking that the parameter |execute| can be computed by the
ExecuteAndOrRegisterReporter function itself, no need to post and reply. The
code could be synchronous, unless I am overlooking something.

[MAD, 2014/06/20 14:40:15]

The execute bool is computed on the file thread based on the existence of the
file, so I don't think we can avoid the ping pong across threads
unfortunately... Unless you know of a way to tell if we can run the executable
without having to jump to the file thread...

+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
+      FROM_HERE,
+      base::Bind(&IsComponentInstalled),
+      base::Bind(&ExecuteAndOrRegisterReporter, cus, prefs));
+}
+
+void ExecutePendingSwReporter(ComponentUpdateService* cus, PrefService* prefs) {
+  // Only continue registration / execute if we have a pending execution.
+  int execute_try_count = prefs->GetInteger(prefs::kSwReporterExecuteTryCount);
+  if (execute_try_count) {
+    // We have a pending execution, let's check if it completed or not.
+    base::win::RegKey srt_key(
+        HKEY_CURRENT_USER, kSoftwareRemovalToolRegistryKey, KEY_READ);
+    DWORD exit_code = -1;
+    if (srt_key.Valid() &&
+        srt_key.ReadValueDW(kExitCodeRegistryValueName, &exit_code) ==
+            ERROR_SUCCESS) {
+      ReportUmaStep(SW_REPORTER_REGISTRY_EXIT_CODE);
+      ReportAndClearExitCode(exit_code);
+      return;
+    }
+
+    // If it didn't complete, let's make sure we didn't go beyond the maximum
+    // retry count yet.
+    prefs->SetInteger(prefs::kSwReporterExecuteTryCount, --execute_try_count);
+    if (!execute_try_count)
+      ReportUmaStep(SW_REPORTER_RETRIED_TOO_MANY_TIMES);
+    else
+      ReportUmaStep(SW_REPORTER_STARTUP_RETRY);
+  }
+  // If we already have an install dir, we need to register to get updates.
+  bool previously_installed =

[Sorin Jianu, 2014/06/20 05:37:38]

The value of |previously_installed| will always be false when it runs at browser
startup.

[MAD, 2014/06/20 14:40:14]

Done.

+      base::PathExists(SwReporterInstallerTraits::VersionPath());
+  if (previously_installed) {
+    if (execute_try_count) {
+      base::PostTaskAndReplyWithResult(
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
+          FROM_HERE,
+          base::Bind(&IsComponentInstalled),
+          base::Bind(&ExecuteAndOrRegisterReporter, cus, prefs));
+    } else {
+      ExecuteAndOrRegisterReporter(cus, prefs, false);
+    }
+  }
+}
+
+void RegisterPrefsForSwReporter(PrefRegistrySimple* registry) {
+  registry->RegisterIntegerPref(prefs::kSwReporterExecuteTryCount, 0);
+}
+
+}  // namespace component_updater