helper_unittest.cc

// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/installer/util/helper.h"

#include <windows.h>

#include <shlobj.h>

#include <optional>
#include <string_view>

#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/path_service.h"
#include "base/test/scoped_path_override.h"
#include "base/test/test_reg_util_win.h"
#include "base/values.h"
#include "base/version.h"
#include "base/win/registry.h"
#include "build/build_config.h"
#include "chrome/install_static/install_util.h"
#include "chrome/install_static/test/scoped_install_details.h"
#include "chrome/installer/util/google_update_constants.h"
#include "chrome/installer/util/initial_preferences.h"
#include "chrome/installer/util/util_constants.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace installer {

namespace {

// A helper that overrides an environment variable for the lifetime of an
// instance.
class ScopedEnvironmentOverride {
 public:
  ScopedEnvironmentOverride(std::wstring_view name, const wchar_t* new_value)
      : name_(name) {
    std::array<wchar_t, MAX_PATH> value;
    value[0] = L'\0';
    DWORD len =
        ::GetEnvironmentVariableW(name_.c_str(), value.data(), value.size());
    if (len > 0 && len < value.size()) {
      old_value_.emplace(value.data(), len);
    }
    ::SetEnvironmentVariableW(name_.c_str(), new_value);
  }
  ~ScopedEnvironmentOverride() {
    ::SetEnvironmentVariableW(name_.c_str(),
                              old_value_ ? old_value_->c_str() : nullptr);
  }

 private:
  const std::wstring name_;
  std::optional<std::wstring> old_value_;
};

}  // namespace

class GetInstalledDirectoryTest : public testing::TestWithParam<bool> {
 protected:
  void SetUp() override {
    ASSERT_TRUE(random_.CreateUniqueTempDir());
    ASSERT_NO_FATAL_FAILURE(
        registry_override_manager_.OverrideRegistry(HKEY_LOCAL_MACHINE));
    ASSERT_NO_FATAL_FAILURE(
        registry_override_manager_.OverrideRegistry(HKEY_CURRENT_USER));
  }

  static bool is_system_level() { return GetParam(); }
  base::FilePath random_path() const { return random_.GetPath(); }

  static base::win::RegKey GetClientsRegKey() {
    return base::win::RegKey(
        is_system_level() ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
        install_static::GetClientsKeyPath().c_str(),
        KEY_SET_VALUE | KEY_WOW64_32KEY);
  }

  static base::win::RegKey GetClientStateRegKey() {
    return base::win::RegKey(
        is_system_level() ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
        install_static::GetClientStateKeyPath().c_str(),
        KEY_SET_VALUE | KEY_WOW64_32KEY);
  }

 private:
  base::ScopedTempDir random_;
  registry_util::RegistryOverrideManager registry_override_manager_;
};

TEST_P(GetInstalledDirectoryTest, NoRegistryValue) {
  EXPECT_EQ(GetInstalledDirectory(is_system_level()), base::FilePath());
}

TEST_P(GetInstalledDirectoryTest, RegistryValueSet) {
  const base::FilePath install_path =
      random_path()
          .Append(install_static::GetChromeInstallSubDirectory())
          .Append(kInstallBinaryDir);
  ASSERT_TRUE(base::CreateDirectory(install_path));
  base::win::RegKey client_state_key(GetClientStateRegKey());
  ASSERT_EQ(client_state_key.WriteValue(
                kUninstallStringField,
                install_path.AppendASCII("1.0.0.0\\Installer\\setup.exe")
                    .value()
                    .c_str()),
            ERROR_SUCCESS);

  base::win::RegKey client_key(GetClientsRegKey());
  ASSERT_EQ(client_key.WriteValue(google_update::kRegVersionField, L"1.0.0.0"),
            ERROR_SUCCESS);

  EXPECT_EQ(GetInstalledDirectory(is_system_level()), install_path);
}

TEST_P(GetInstalledDirectoryTest, NoDirectory) {
  base::win::RegKey client_state_key(GetClientStateRegKey());
  ASSERT_EQ(client_state_key.WriteValue(
                kUninstallStringField,
                random_path()
                    .Append(install_static::GetChromeInstallSubDirectory())
                    .Append(kInstallBinaryDir)
                    .AppendASCII("1.0.0.0\\Installer\\setup.exe")
                    .value()
                    .c_str()),
            ERROR_SUCCESS);

  base::win::RegKey client_key(GetClientsRegKey());
  ASSERT_EQ(client_key.WriteValue(google_update::kRegVersionField, L"1.0.0.0"),
            ERROR_SUCCESS);
  EXPECT_EQ(GetInstalledDirectory(is_system_level()), base::FilePath());
}

TEST_P(GetInstalledDirectoryTest, ReferencesParent) {
  const base::FilePath install_path =
      random_path()
          .Append(install_static::GetChromeInstallSubDirectory())
          .Append(kInstallBinaryDir);
  ASSERT_TRUE(base::CreateDirectory(install_path));
  base::win::RegKey client_state_key(GetClientStateRegKey());
  ASSERT_EQ(client_state_key.WriteValue(
                kUninstallStringField,
                install_path
                    .AppendASCII("1.0.0.0\\Installer\\..\\Installer\\setup.exe")
                    .value()
                    .c_str()),
            ERROR_SUCCESS);

  base::win::RegKey client_key(GetClientsRegKey());
  ASSERT_EQ(client_key.WriteValue(google_update::kRegVersionField, L"1.0.0.0"),
            ERROR_SUCCESS);

  EXPECT_EQ(GetInstalledDirectory(is_system_level()), base::FilePath());
}

TEST_P(GetInstalledDirectoryTest, NotAbsolute) {
  base::win::RegKey client_state_key(GetClientStateRegKey());
  ASSERT_EQ(client_state_key.WriteValue(
                kUninstallStringField,
                base::FilePath(install_static::GetChromeInstallSubDirectory())
                    .Append(kInstallBinaryDir)
                    .AppendASCII("1.0.0.0\\Installer\\setup.exe")
                    .value()
                    .c_str()),
            ERROR_SUCCESS);

  base::win::RegKey client_key(GetClientsRegKey());
  ASSERT_EQ(client_key.WriteValue(google_update::kRegVersionField, L"1.0.0.0"),
            ERROR_SUCCESS);

  EXPECT_EQ(GetInstalledDirectory(is_system_level()), base::FilePath());
}

TEST_P(GetInstalledDirectoryTest, AtRoot) {
  base::win::RegKey client_state_key(GetClientStateRegKey());
  ASSERT_EQ(
      client_state_key.WriteValue(
          kUninstallStringField,
          base::FilePath(FILE_PATH_LITERAL("C:\\1.0.0.0\\Installer\\setup.exe"))
              .value()
              .c_str()),
      ERROR_SUCCESS);

  base::win::RegKey client_key(GetClientsRegKey());
  ASSERT_EQ(client_key.WriteValue(google_update::kRegVersionField, L"1.0.0.0"),
            ERROR_SUCCESS);

  EXPECT_EQ(GetInstalledDirectory(is_system_level()), base::FilePath());
}

TEST_P(GetInstalledDirectoryTest, RegistryValueSetWrongScope) {
  base::win::RegKey client_state_key(GetClientStateRegKey());
  ASSERT_EQ(client_state_key.WriteValue(
                kUninstallStringField,
                random_path()
                    .Append(install_static::GetChromeInstallSubDirectory())
                    .Append(kInstallBinaryDir)
                    .AppendASCII("1.0.0.0\\Installer\\setup.exe")
                    .value()
                    .c_str()),
            ERROR_SUCCESS);

  base::win::RegKey client_key(GetClientsRegKey());
  ASSERT_EQ(client_key.WriteValue(google_update::kRegVersionField, L"1.0.0.0"),
            ERROR_SUCCESS);
  EXPECT_EQ(GetInstalledDirectory(!is_system_level()), base::FilePath());
}

TEST_P(GetInstalledDirectoryTest, RegistryValueSetNoProductVersion) {
  base::win::RegKey client_state_key(GetClientStateRegKey());
  ASSERT_EQ(client_state_key.WriteValue(
                kUninstallStringField,
                random_path()
                    .Append(install_static::GetChromeInstallSubDirectory())
                    .Append(kInstallBinaryDir)
                    .AppendASCII("1.0.0.0\\Installer\\setup.exe")
                    .value()
                    .c_str()),
            ERROR_SUCCESS);
  EXPECT_EQ(GetInstalledDirectory(is_system_level()), base::FilePath());
}

INSTANTIATE_TEST_SUITE_P(UserLevelTest,
                         GetInstalledDirectoryTest,
                         testing::Values(false));
INSTANTIATE_TEST_SUITE_P(SystemLevelTest,
                         GetInstalledDirectoryTest,
                         testing::Values(true));

class GetDefaultChromeInstallPathTest : public testing::TestWithParam<bool> {
 protected:
  void SetUp() override {
    ASSERT_TRUE(program_files_.CreateUniqueTempDir());
    ASSERT_TRUE(program_files_x86_.CreateUniqueTempDir());
    ASSERT_TRUE(local_app_data_.CreateUniqueTempDir());
    program_files_override_.emplace(base::DIR_PROGRAM_FILES,
                                    program_files_path());
    program_files_x86_override_.emplace(base::DIR_PROGRAM_FILESX86,
                                        program_files_x86_path());
    local_data_app_override_.emplace(base::DIR_LOCAL_APP_DATA,
                                     local_app_data_path());
  }

  static bool is_system_level() { return GetParam(); }
  base::FilePath program_files_path() const { return program_files_.GetPath(); }
  base::FilePath program_files_x86_path() const {
    return program_files_x86_.GetPath();
  }
  base::FilePath local_app_data_path() const {
    return local_app_data_.GetPath();
  }

  base::FilePath GetExpectedPath(bool system_level) const {
    auto path = system_level ? program_files_path() : local_app_data_path();
    return path.Append(install_static::GetChromeInstallSubDirectory())
        .Append(kInstallBinaryDir);
  }

 private:
  base::ScopedTempDir program_files_;
  base::ScopedTempDir program_files_x86_;
  base::ScopedTempDir local_app_data_;
  std::optional<base::ScopedPathOverride> program_files_override_;
  std::optional<base::ScopedPathOverride> program_files_x86_override_;
  std::optional<base::ScopedPathOverride> local_data_app_override_;
};

// Tests that the PathService is used to get the default install path.
TEST_P(GetDefaultChromeInstallPathTest, PathService) {
  EXPECT_EQ(GetDefaultChromeInstallPath(is_system_level()),
            GetExpectedPath(is_system_level()));
}

// Tests that the environment variable fallback is used if the PathService
// returns a path that doesn't exist.
TEST_P(GetDefaultChromeInstallPathTest, EnvironmentFallback) {
  // Override the relevant paths with directories that do not exist so that the
  // env var fallback is reached.
  base::ScopedPathOverride bad_program_files_override(
      base::DIR_PROGRAM_FILES, program_files_path().AppendASCII("doesnotexist"),
      /*is_absolute=*/true, /*create=*/false);
  base::ScopedPathOverride bad_program_files_x86_override(
      base::DIR_PROGRAM_FILESX86,
      program_files_x86_path().AppendASCII("doesnotexist"),
      /*is_absolute=*/true, /*create=*/false);
  base::ScopedPathOverride bad_local_ap_data_override(
      base::DIR_LOCAL_APP_DATA,
      local_app_data_path().AppendASCII("doesnotexist"),
      /*is_absolute=*/true, /*create=*/false);

  ScopedEnvironmentOverride program_files_env(
      L"PROGRAMFILES", program_files_path().value().c_str());
  ScopedEnvironmentOverride program_files_x86_env(
      L"PROGRAMFILES(X86)", program_files_x86_path().value().c_str());
  ScopedEnvironmentOverride local_app_data_env(
      L"LOCALAPPDATA", local_app_data_path().value().c_str());

  EXPECT_EQ(GetDefaultChromeInstallPath(is_system_level()),
            GetExpectedPath(is_system_level()));
}

INSTANTIATE_TEST_SUITE_P(UserLevelTest,
                         GetDefaultChromeInstallPathTest,
                         testing::Values(false));
INSTANTIATE_TEST_SUITE_P(SystemLevelTest,
                         GetDefaultChromeInstallPathTest,
                         testing::Values(true));

struct Params {
  Params(bool system_level, std::optional<int> target_dir_key)
      : system_level(system_level), target_dir_key(target_dir_key) {}
  bool system_level;
  std::optional<int> target_dir_key;
};

// Tests GetChromeInstallPath with a params object that contains a boolean
// |system_level| which is |true| if the test must use system-level values or
// |false| it the test must use user-level values, and a |target_dir| path in
// which the installation should be made.
class GetChromeInstallPathWithPrefsTest
    : public testing::TestWithParam<Params> {
 protected:
  void SetUp() override {
    ASSERT_TRUE(program_files_.CreateUniqueTempDir());
    ASSERT_TRUE(program_files_x86_.CreateUniqueTempDir());
    ASSERT_TRUE(random_.CreateUniqueTempDir());
    ASSERT_TRUE(local_app_data_.CreateUniqueTempDir());
    ASSERT_NO_FATAL_FAILURE(
        registry_override_manager_.OverrideRegistry(HKEY_LOCAL_MACHINE));
    ASSERT_NO_FATAL_FAILURE(
        registry_override_manager_.OverrideRegistry(HKEY_CURRENT_USER));
    program_files_override_.emplace(base::DIR_PROGRAM_FILES,
                                    program_files_path());
    program_files_x86_override_.emplace(base::DIR_PROGRAM_FILESX86,
                                        program_files_x86_path());
    local_data_app_override_.emplace(base::DIR_LOCAL_APP_DATA,
                                     local_app_data_path());
  }

  base::FilePath random_path() const { return random_.GetPath(); }
  base::FilePath program_files_path() const { return program_files_.GetPath(); }
  base::FilePath program_files_x86_path() const {
    return program_files_x86_.GetPath();
  }
  base::FilePath local_app_data_path() const {
    return local_app_data_.GetPath();
  }
  static bool is_system_level() { return GetParam().system_level; }

  base::FilePath GetExpectedPath(bool system_level) {
    auto path = system_level ? program_files_path() : local_app_data_path();
    return path.Append(install_static::GetChromeInstallSubDirectory())
        .Append(kInstallBinaryDir);
  }

  static base::win::RegKey GetClientsRegKey() {
    return base::win::RegKey(
        is_system_level() ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
        install_static::GetClientsKeyPath().c_str(),
        KEY_SET_VALUE | KEY_WOW64_32KEY);
  }

  static base::win::RegKey GetClientStateRegKey() {
    return base::win::RegKey(
        is_system_level() ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
        install_static::GetClientStateKeyPath().c_str(),
        KEY_SET_VALUE | KEY_WOW64_32KEY);
  }

  base::FilePath GetExpectedPathForSetup(bool system_level,
                                         base::FilePath target_dir) {
    if (system_level && !target_dir.empty() &&
        (target_dir == program_files_path() ||
         target_dir == program_files_x86_path())) {
      return target_dir.Append(install_static::GetChromeInstallSubDirectory())
          .Append(kInstallBinaryDir);
    }
    return GetExpectedPath(system_level);
  }

  static base::FilePath target_dir() {
    base::FilePath result;
    if (GetParam().target_dir_key.has_value())
      base::PathService::Get(GetParam().target_dir_key.value(), &result);
    return result;
  }

  static base::Value::Dict prefs_json() {
    base::FilePath result;
    if (GetParam().target_dir_key.has_value())
      base::PathService::Get(GetParam().target_dir_key.value(), &result);
    base::Value::Dict distribution;
    distribution.SetByDottedPath("distribution.program_files_dir",
                                 result.AsUTF8Unsafe());
    return distribution;
  }

 private:
  base::ScopedTempDir program_files_;
  base::ScopedTempDir program_files_x86_;
  base::ScopedTempDir random_;
  base::ScopedTempDir local_app_data_;
  registry_util::RegistryOverrideManager registry_override_manager_;
  std::optional<base::ScopedPathOverride> program_files_override_;
  std::optional<base::ScopedPathOverride> program_files_x86_override_;
  std::optional<base::ScopedPathOverride> local_data_app_override_;
};

TEST_P(GetChromeInstallPathWithPrefsTest, NoRegistryValue) {
  EXPECT_EQ(GetChromeInstallPathWithPrefs(is_system_level(),
                                          InitialPreferences(prefs_json())),
            GetExpectedPathForSetup(is_system_level(), target_dir()));
}

TEST_P(GetChromeInstallPathWithPrefsTest, RegistryValueSet) {
  const base::FilePath install_path =
      random_path()
          .Append(install_static::GetChromeInstallSubDirectory())
          .Append(kInstallBinaryDir);
  ASSERT_TRUE(base::CreateDirectory(install_path));
  base::win::RegKey client_state_key(GetClientStateRegKey());
  ASSERT_EQ(client_state_key.WriteValue(
                kUninstallStringField,
                install_path.AppendASCII("1.0.0.0\\Installer\\setup.exe")
                    .value()
                    .c_str()),
            ERROR_SUCCESS);

  base::win::RegKey client_key(GetClientsRegKey());
  ASSERT_EQ(client_key.WriteValue(google_update::kRegVersionField, L"1.0.0.0"),
            ERROR_SUCCESS);
  EXPECT_EQ(GetChromeInstallPathWithPrefs(is_system_level(),
                                          InitialPreferences(prefs_json())),
            install_path);
}

TEST_P(GetChromeInstallPathWithPrefsTest, RegistryValueSetWrongScope) {
  base::win::RegKey client_state_key(GetClientStateRegKey());
  ASSERT_EQ(client_state_key.WriteValue(
                kUninstallStringField,
                random_path()
                    .Append(install_static::GetChromeInstallSubDirectory())
                    .Append(kInstallBinaryDir)
                    .AppendASCII("1.0.0.0\\Installer\\setup.exe")
                    .value()
                    .c_str()),
            ERROR_SUCCESS);

  base::win::RegKey client_key(GetClientsRegKey());
  ASSERT_EQ(client_key.WriteValue(google_update::kRegVersionField, L"1.0.0.0"),
            ERROR_SUCCESS);
  EXPECT_EQ(GetChromeInstallPathWithPrefs(!is_system_level(),
                                          InitialPreferences(prefs_json())),
            GetExpectedPathForSetup(!is_system_level(), target_dir()));
}

TEST_P(GetChromeInstallPathWithPrefsTest, RegistryValueSetNoProductVersion) {
  base::win::RegKey client_state_key(GetClientStateRegKey());
  ASSERT_EQ(client_state_key.WriteValue(
                kUninstallStringField,
                random_path()
                    .Append(install_static::GetChromeInstallSubDirectory())
                    .Append(kInstallBinaryDir)
                    .AppendASCII("1.0.0.0\\Installer\\setup.exe")
                    .value()
                    .c_str()),
            ERROR_SUCCESS);
  EXPECT_EQ(GetChromeInstallPathWithPrefs(is_system_level(),
                                          InitialPreferences(prefs_json())),
            GetExpectedPathForSetup(is_system_level(), target_dir()));
}

INSTANTIATE_TEST_SUITE_P(
    UserLevelX86SetupTest,
    GetChromeInstallPathWithPrefsTest,
    testing::Values<Params>(Params(false, base::DIR_PROGRAM_FILESX86)));

INSTANTIATE_TEST_SUITE_P(
    UserLevelX64SetupTest,
    GetChromeInstallPathWithPrefsTest,
    testing::Values<Params>(Params(false, base::DIR_PROGRAM_FILES)));

INSTANTIATE_TEST_SUITE_P(UserLevelUnsupportedPathSetupTest,
                         GetChromeInstallPathWithPrefsTest,
                         testing::Values<Params>(Params(false,
                                                        base::DIR_HOME)));

INSTANTIATE_TEST_SUITE_P(UserLevelEmptyPathSetupTest,
                         GetChromeInstallPathWithPrefsTest,
                         testing::Values<Params>(Params(false, std::nullopt)));

INSTANTIATE_TEST_SUITE_P(
    MachineLevelX86SetupTest,
    GetChromeInstallPathWithPrefsTest,
    testing::Values<Params>(Params(true, base::DIR_PROGRAM_FILESX86)));

INSTANTIATE_TEST_SUITE_P(
    MachineLevelX64SetupTest,
    GetChromeInstallPathWithPrefsTest,
    testing::Values<Params>(Params(true, base::DIR_PROGRAM_FILES)));

INSTANTIATE_TEST_SUITE_P(MachineLevelUnsupportedPathSetupTest,
                         GetChromeInstallPathWithPrefsTest,
                         testing::Values<Params>(Params(true, base::DIR_HOME)));

INSTANTIATE_TEST_SUITE_P(MachineLevelEmptyPathSetupTest,
                         GetChromeInstallPathWithPrefsTest,
                         testing::Values<Params>(Params(true, std::nullopt)));

class FindInstallPathTest
    : public ::testing::TestWithParam<std::tuple<bool, int>> {
 protected:
  void SetUp() override {
    ASSERT_TRUE(program_files_.CreateUniqueTempDir());
    ASSERT_TRUE(program_files_x86_.CreateUniqueTempDir());
    ASSERT_TRUE(program_files_6432_.CreateUniqueTempDir());
    ASSERT_TRUE(local_app_data_.CreateUniqueTempDir());
    program_files_override_.emplace(base::DIR_PROGRAM_FILES,
                                    program_files_path());
    program_files_x86_override_.emplace(base::DIR_PROGRAM_FILESX86,
                                        program_files_x86_path());
    program_files_6432_override_.emplace(base::DIR_PROGRAM_FILES6432,
                                         program_files_6432_path());
    local_data_app_override_.emplace(base::DIR_LOCAL_APP_DATA,
                                     local_app_data_path());
  }

  static bool is_system_level() { return std::get<0>(GetParam()); }
  static int target_path_key() { return std::get<1>(GetParam()); }
  base::FilePath program_files_path() const { return program_files_.GetPath(); }
  base::FilePath program_files_x86_path() const {
    return program_files_x86_.GetPath();
  }
  base::FilePath program_files_6432_path() const {
    return program_files_6432_.GetPath();
  }
  base::FilePath local_app_data_path() const {
    return local_app_data_.GetPath();
  }

 private:
  base::ScopedTempDir program_files_;
  base::ScopedTempDir program_files_x86_;
  base::ScopedTempDir program_files_6432_;
  base::ScopedTempDir local_app_data_;
  std::optional<base::ScopedPathOverride> program_files_override_;
  std::optional<base::ScopedPathOverride> program_files_x86_override_;
  std::optional<base::ScopedPathOverride> program_files_6432_override_;
  std::optional<base::ScopedPathOverride> local_data_app_override_;
};

// Tests that FindInstallPath returns an empty string when no install directory
// is present.
TEST_P(FindInstallPathTest, NoDirectory) {
  EXPECT_EQ(FindInstallPath(is_system_level(), base::Version("1.0.0.0")),
            base::FilePath());
}

// Tests that FindInstallPath returns the path to the installed version
// directory.
TEST_P(FindInstallPathTest, Installed) {
  const auto path = base::PathService::CheckedGet(target_path_key())
                        .Append(install_static::GetChromeInstallSubDirectory())
                        .Append(kInstallBinaryDir)
                        .Append(L"1.0.0.0");
  ASSERT_TRUE(base::CreateDirectoryAndGetError(path, nullptr));
  EXPECT_EQ(FindInstallPath(is_system_level(), base::Version("1.0.0.0")), path);
}

INSTANTIATE_TEST_SUITE_P(
    UserLevelTest,
    FindInstallPathTest,
    testing::Values(std::make_tuple(false, base::DIR_LOCAL_APP_DATA)));
INSTANTIATE_TEST_SUITE_P(
    SystemLevelTest,
    FindInstallPathTest,
    testing::Values(std::make_tuple(true, base::DIR_PROGRAM_FILES),
#if defined(ARCH_CPU_64_BITS)
                    std::make_tuple(true, base::DIR_PROGRAM_FILESX86)
#else
                    std::make_tuple(true, base::DIR_PROGRAM_FILES6432)
#endif

                        ));

class IsCurrentProcessInstalledTest : public testing::TestWithParam<bool> {
 protected:
  void SetUp() override {
    if (GetParam() && !::IsUserAnAdmin()) {
      GTEST_SKIP() << "Test requires admin rights";
    }
    ASSERT_NO_FATAL_FAILURE(registry_override_manager_.OverrideRegistry(
        GetParam() ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER));
  }

  void SetInstalledDirectory(const base::FilePath& installed_dir) {
    const HKEY kRoot = GetParam() ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
    base::win::RegKey clients_key(kRoot,
                                  install_static::GetClientsKeyPath().c_str(),
                                  KEY_SET_VALUE | KEY_WOW64_32KEY);
    ASSERT_EQ(
        clients_key.WriteValue(google_update::kRegVersionField, L"1.0.0.0"),
        ERROR_SUCCESS);

    base::win::RegKey client_state_key(
        kRoot, install_static::GetClientStateKeyPath().c_str(),
        KEY_SET_VALUE | KEY_WOW64_32KEY);
    ASSERT_EQ(client_state_key.WriteValue(
                  kUninstallStringField,
                  installed_dir.AppendASCII("1.0.0.0\\Installer\\setup.exe")
                      .value()
                      .c_str()),
              ERROR_SUCCESS);
  }

 private:
  install_static::ScopedInstallDetails install_details_{
      /*system_level=*/GetParam()};
  registry_util::RegistryOverrideManager registry_override_manager_;
};

// Tests that IsCurrentProcessInstalled returns false when the product is not
// registered with the updater.
TEST_P(IsCurrentProcessInstalledTest, NotInstalled) {
  ASSERT_FALSE(IsCurrentProcessInstalled());
}

// Tests that IsCurrentProcessInstalled returns false when the product is
// registered with the updater but the current exe resides elsewhere.
TEST_P(IsCurrentProcessInstalledTest, InstalledNotInDir) {
  ASSERT_NO_FATAL_FAILURE(
      SetInstalledDirectory(base::PathService::CheckedGet(base::DIR_TEMP)));

  ASSERT_FALSE(IsCurrentProcessInstalled());
}

// Tests that IsCurrentProcessInstalled returns true when the product is
// registered with the updater and the current exe resides in the same dir.
TEST_P(IsCurrentProcessInstalledTest, InstalledInDir) {
  ASSERT_NO_FATAL_FAILURE(
      SetInstalledDirectory(base::PathService::CheckedGet(base::DIR_EXE)));

  ASSERT_TRUE(IsCurrentProcessInstalled());
}

// Tests that IsCurrentProcessInstalled returns true when the product is
// registered with the updater and the current exe resides in a subdir.
TEST_P(IsCurrentProcessInstalledTest, InstalledInSubDir) {
  ASSERT_NO_FATAL_FAILURE(SetInstalledDirectory(
      base::PathService::CheckedGet(base::DIR_EXE).DirName()));

  ASSERT_TRUE(IsCurrentProcessInstalled());
}

INSTANTIATE_TEST_SUITE_P(UserLevelTest,
                         IsCurrentProcessInstalledTest,
                         testing::Values(false));

INSTANTIATE_TEST_SUITE_P(SystemLevelTest,
                         IsCurrentProcessInstalledTest,
                         testing::Values(true));

}  // namespace installer