Simplify the registration of the Chrome Recovery component.

chrome/browser/component_updater/recovery_component_installer.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/browser/component_updater/recovery_component_installer.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
@@ skipping 26 matching lines @@
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/update_client/update_client.h"
 #include "components/update_client/utils.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace component_updater {
 
+#if defined(GOOGLE_CHROME_BUILD)
+#if defined(OS_WIN) || defined(OS_MACOSX)
+
 namespace {
 
 // CRX hash. The extension id is: npdjjkjlcidkjlamlmmdelcjbcpdjocm.
 const uint8_t kSha2Hash[] = {0xdf, 0x39, 0x9a, 0x9b, 0x28, 0x3a, 0x9b, 0x0c,
                              0xbc, 0xc3, 0x4b, 0x29, 0x12, 0xf3, 0x9e, 0x2c,
                              0x19, 0x7a, 0x71, 0x4b, 0x0a, 0x7c, 0x80, 0x1c,
                              0xf6, 0x29, 0x7c, 0x0a, 0x5f, 0xea, 0x67, 0xb7};
 
 // File name of the recovery binary on different platforms.
 const base::FilePath::CharType kRecoveryFileName[] =
@@ skipping 24 matching lines @@
   RCE_ELEVATED_SKIPPED = 8,
   RCE_COMPONENT_DOWNLOAD_ERROR = 9,
   RCE_ELEVATED_UNKNOWN_RESULT = 10,
   RCE_COUNT
 };
 
 void RecordRecoveryComponentUMAEvent(RecoveryComponentEvent event) {
   UMA_HISTOGRAM_ENUMERATION("RecoveryComponent.Event", event, RCE_COUNT);
 }
 
-#if !defined(OS_CHROMEOS) && defined(GOOGLE_CHROME_BUILD)
 // Checks if elevated recovery simulation switch was present on the command
 // line. This is for testing purpose.
 bool SimulatingElevatedRecovery() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kSimulateElevatedRecovery);
 }
-#endif  // !defined(OS_CHROMEOS) && defined(GOOGLE_CHROME_BUILD)
 
 std::vector<std::string> GetRecoveryInstallArguments(
     const base::DictionaryValue& manifest,
     bool is_deferred_run,
     const base::Version& version) {
   std::vector<std::string> arguments;
 
   // Add a flag for re-attempted install with elevated privilege so that the
   // recovery executable can report back accordingly.
   if (is_deferred_run)
@@ skipping 21 matching lines @@
   base::CommandLine command_line(command);
 
   const auto arguments = GetRecoveryInstallArguments(
       manifest, is_deferred_run, version);
   for (const auto& arg : arguments)
     command_line.AppendArg(arg);
 
   return command_line;
 }
 
-#if defined(OS_WIN) || defined(OS_MACOSX)
 std::unique_ptr<base::DictionaryValue> ReadManifest(
     const base::FilePath& manifest) {
   JSONFileValueDeserializer deserializer(manifest);
   std::string error;
   return base::DictionaryValue::From(deserializer.Deserialize(NULL, &error));
 }
 
 void WaitForElevatedInstallToComplete(base::Process process) {
   int installer_exit_code = 0;
   const base::TimeDelta kMaxWaitTime = base::TimeDelta::FromSeconds(600);
@@ skipping 85 matching lines @@
 
 void ElevatedInstallRecoveryComponent(const base::FilePath& installer_path) {
   base::PostTaskWithTraits(
       FROM_HERE, base::TaskTraits()
                      .WithShutdownBehavior(
                          base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
                      .WithPriority(base::TaskPriority::BACKGROUND)
                      .MayBlock(),
       base::Bind(&DoElevatedInstallRecoveryComponent, installer_path));
 }
-#endif  // defined(OS_WIN)
 
 }  // namespace
 
 // Component installer that is responsible to repair the chrome installation
 // or repair the Google update installation. This is a last resort safety
 // mechanism.
 // For user Chrome, recovery component just installs silently. For machine
 // Chrome, elevation may be needed. If that happens, the installer will set
 // preference flag prefs::kRecoveryComponentNeedsElevation to request that.
 // There is a global error service monitors this flag and will pop up
@@ skipping 68 matching lines @@
     const base::Version& version, PrefService* prefs)
     : current_version_(version), prefs_(prefs) {
   DCHECK(version.IsValid());
 }
 
 void RecoveryComponentInstaller::OnUpdateError(int error) {
   RecordRecoveryComponentUMAEvent(RCE_COMPONENT_DOWNLOAD_ERROR);
   NOTREACHED() << "Recovery component update error: " << error;
 }
 
-#if defined(OS_WIN) || defined(OS_MACOSX)
 void WaitForInstallToComplete(base::Process process,
                               const base::FilePath& installer_folder,
                               PrefService* prefs) {
   int installer_exit_code = 0;
   const base::TimeDelta kMaxWaitTime = base::TimeDelta::FromSeconds(600);
   if (process.WaitForExitWithTimeout(kMaxWaitTime, &installer_exit_code)) {
     if (installer_exit_code == EXIT_CODE_ELEVATION_NEEDED) {
       RecordRecoveryComponentUMAEvent(RCE_ELEVATION_NEEDED);
 
       BrowserThread::PostTask(
@@ skipping 34 matching lines @@
                      .WithPriority(base::TaskPriority::BACKGROUND)
                      .WithBaseSyncPrimitives(),
       base::Bind(&WaitForInstallToComplete, base::Passed(&process),
                  installer_folder, prefs_));
 
   // Returns true regardless of install result since from updater service
   // perspective the install is done, even we may need to do elevated
   // install later.
   return true;
 }
-#else
-bool RecoveryComponentInstaller::RunInstallCommand(
-    const base::CommandLine& cmdline,
-    const base::FilePath&) const {
-  return base::LaunchProcess(cmdline, base::LaunchOptions()).IsValid();
-}
-#endif  // defined(OS_WIN)
 
 #if defined(OS_POSIX)
 // Sets the POSIX executable permissions on a file
 bool SetPosixExecutablePermission(const base::FilePath& path) {
   int permissions = 0;
   if (!base::GetPosixFilePermissions(path, &permissions))
     return false;
   const int kExecutableMask = base::FILE_PERMISSION_EXECUTE_BY_USER |
                               base::FILE_PERMISSION_EXECUTE_BY_GROUP |
                               base::FILE_PERMISSION_EXECUTE_BY_OTHERS;
@@ skipping 77 matching lines @@
 bool RecoveryComponentInstaller::GetInstalledFile(
     const std::string& file,
     base::FilePath* installed_file) {
   return false;
 }
 
 bool RecoveryComponentInstaller::Uninstall() {
   return false;
 }
 
+#endif  // defined(OS_WIN) || defined(OS_MACOSX)
+#endif  // defined(GOOGLE_CHROME_BUILD)
+
 void RegisterRecoveryComponent(ComponentUpdateService* cus,
                                PrefService* prefs) {
-#if !defined(OS_CHROMEOS) && defined(GOOGLE_CHROME_BUILD)
+#if defined(GOOGLE_CHROME_BUILD)
+#if defined(OS_WIN) || defined(OS_MACOSX)
   if (SimulatingElevatedRecovery()) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&SimulateElevatedRecoveryHelper, prefs));
   }
 
   // We delay execute the registration because we are not required in
   // the critical path during browser startup.
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&RecoveryRegisterHelper, cus, prefs),
       base::TimeDelta::FromSeconds(6));
-#endif  // !defined(OS_CHROMEOS) && defined(GOOGLE_CHROME_BUILD)
+#endif
+#endif
 }
 
 void RegisterPrefsForRecoveryComponent(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kRecoveryComponentVersion, "0.0.0.0");
   registry->RegisterFilePathPref(prefs::kRecoveryComponentUnpackPath,
                                  base::FilePath());
   registry->RegisterBooleanPref(prefs::kRecoveryComponentNeedsElevation, false);
 }
 
 void AcceptedElevatedRecoveryInstall(PrefService* prefs) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
+#if defined(GOOGLE_CHROME_BUILD)
 #if defined(OS_WIN) || defined(OS_MACOSX)
   ElevatedInstallRecoveryComponent(
       prefs->GetFilePath(prefs::kRecoveryComponentUnpackPath));
-#endif  // OS_WIN
+#endif
+#endif
+
   prefs->SetBoolean(prefs::kRecoveryComponentNeedsElevation, false);
 }
 
 void DeclinedElevatedRecoveryInstall(PrefService* prefs) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   prefs->SetBoolean(prefs::kRecoveryComponentNeedsElevation, false);
 }
 
 }  // namespace component_updater