Use InstallDetails in installer_util.

chrome/installer/util/google_update_settings_unittest.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/installer/util/google_update_settings.h"
 
 #include <windows.h>
 #include <shlwapi.h>  // For SHDeleteKey.
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/base_paths.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_path_override.h"
 #include "base/test/test_reg_util_win.h"
 #include "base/win/registry.h"
 #include "base/win/win_util.h"
 #include "chrome/common/chrome_constants.h"
+#include "chrome/install_static/test/scoped_install_details.h"
 #include "chrome/installer/util/app_registration_data.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/channel_info.h"
 #include "chrome/installer/util/fake_installation_state.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item_list.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 22 matching lines @@
       : program_files_override_(base::DIR_PROGRAM_FILES),
         program_files_x86_override_(base::DIR_PROGRAM_FILESX86) {}
 
   void SetUp() override {
     ASSERT_NO_FATAL_FAILURE(
         registry_overrides_.OverrideRegistry(HKEY_LOCAL_MACHINE));
     ASSERT_NO_FATAL_FAILURE(
         registry_overrides_.OverrideRegistry(HKEY_CURRENT_USER));
   }
 
-  void SetApField(SystemUserInstall is_system, const wchar_t* value) {
-    HKEY root = is_system == SYSTEM_INSTALL ?
-        HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
-
-    RegKey update_key;
-    BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-    base::string16 path = dist->GetStateKey();
-    ASSERT_EQ(ERROR_SUCCESS, update_key.Create(root, path.c_str(), KEY_WRITE));
-    ASSERT_EQ(ERROR_SUCCESS, update_key.WriteValue(L"ap", value));
-  }
-
-  // Tests setting the ap= value to various combinations of values with
-  // suffixes, while asserting on the correct channel value.
-  // Note that ap= value has to match "^2.0-d.*" or ".*x64-dev.*" and "^1.1-.*"
-  // or ".*x64-beta.*" for dev and beta channels respectively.
-  void TestCurrentChromeChannelWithVariousApValues(SystemUserInstall install) {
-    static struct Expectation {
-      const wchar_t* ap_value;
-      const wchar_t* channel;
-      bool supports_prefixes;
-    } expectations[] = {
-      { L"2.0-dev", installer::kChromeChannelDev, false},
-      { L"1.1-beta", installer::kChromeChannelBeta, false},
-      { L"x64-dev", installer::kChromeChannelDev, true},
-      { L"x64-beta", installer::kChromeChannelBeta, true},
-      { L"x64-stable", installer::kChromeChannelStable, true},
-    };
-    bool is_system = install == SYSTEM_INSTALL;
-    const wchar_t* prefixes[] = {
-      L"",
-      L"prefix",
-      L"prefix-with-dash",
-    };
-    const wchar_t* suffixes[] = {
-      L"",
-      L"suffix",
-      L"suffix-with-dash",
-    };
-
-    for (const wchar_t* prefix : prefixes) {
-      for (const Expectation& expectation : expectations) {
-        for (const wchar_t* suffix : suffixes) {
-          base::string16 ap = prefix;
-          ap += expectation.ap_value;
-          ap += suffix;
-          const wchar_t* channel = expectation.channel;
-
-          SetApField(install, ap.c_str());
-          const base::string16 ret_channel =
-              GoogleUpdateSettings::GetChromeChannel(is_system);
-
-          // If prefixes are not supported for a channel, we expect the channel
-          // to be "unknown" if a non-empty prefix is present in ap_value.
-          if (!expectation.supports_prefixes && wcslen(prefix) > 0) {
-            EXPECT_STREQ(installer::kChromeChannelUnknown, ret_channel.c_str())
-                << "Expecting channel \"" << installer::kChromeChannelUnknown
-                << "\" for ap=\"" << ap << "\"";
-          } else {
-            EXPECT_STREQ(channel, ret_channel.c_str())
-                << "Expecting channel \"" << channel
-                << "\" for ap=\"" << ap << "\"";
-          }
-        }
-      }
-    }
-  }
-
   // Test the writing and deleting functionality of the experiments label
   // helper.
   void TestExperimentsLabelHelper(SystemUserInstall install) {
+    // Install a basic InstallDetails instance.
+    install_static::ScopedInstallDetails details(install == SYSTEM_INSTALL);

[gab, 2017/02/14 16:57:56]

This is unfortunate, would be much easier to read if
install_static::ScopedInstallDetails used enums instead of bools/ints :(

[grt (UTC plus 2), 2017/02/14 21:04:24]

TODO added to scoped_install_details.h

(I hate to make you sad)

+
     BrowserDistribution* chrome = BrowserDistribution::GetDistribution();
     base::string16 value;
 #if defined(GOOGLE_CHROME_BUILD)
     EXPECT_TRUE(chrome->ShouldSetExperimentLabels());
 
     // Before anything is set, ReadExperimentLabels should succeed but return
     // an empty string.
     EXPECT_TRUE(GoogleUpdateSettings::ReadExperimentLabels(
         install == SYSTEM_INSTALL, &value));
     EXPECT_EQ(base::string16(), value);
@@ skipping 146 matching lines @@
 
   // Path overrides so that SHGetFolderPath isn't needed after the registry
   // is overridden.
   base::ScopedPathOverride program_files_override_;
   base::ScopedPathOverride program_files_x86_override_;
   registry_util::RegistryOverrideManager registry_overrides_;
 };
 
 }  // namespace
 
-// Verify that we return success on no registration (which means stable),
-// whether per-system or per-user install.
-TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelAbsent) {
-  // Per-system first.
-  base::string16 channel;
-  channel = GoogleUpdateSettings::GetChromeChannel(true);
-  EXPECT_STREQ(L"", channel.c_str());
-
-  // Then per-user.
-  channel = GoogleUpdateSettings::GetChromeChannel(false);
-  EXPECT_STREQ(L"", channel.c_str());
-}
-
-// Test an empty Ap key for system and user.
-TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelEmptySystem) {
-  SetApField(SYSTEM_INSTALL, L"");
-  base::string16 channel;
-  channel = GoogleUpdateSettings::GetChromeChannel(true);
-  EXPECT_STREQ(L"", channel.c_str());
-
-  // Per-user lookups still succeed and return empty string.
-  channel = GoogleUpdateSettings::GetChromeChannel(false);
-  EXPECT_STREQ(L"", channel.c_str());
-}
-
-TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelEmptyUser) {
-  SetApField(USER_INSTALL, L"");
-  // Per-system lookups still succeed and return empty string.
-  base::string16 channel;
-  channel = GoogleUpdateSettings::GetChromeChannel(true);
-  EXPECT_STREQ(L"", channel.c_str());
-
-  // Per-user lookup should succeed.
-  channel = GoogleUpdateSettings::GetChromeChannel(false);
-  EXPECT_STREQ(L"", channel.c_str());
-}
-
-TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelVariousApValuesSystem) {
-  TestCurrentChromeChannelWithVariousApValues(SYSTEM_INSTALL);
-}
-
-TEST_F(GoogleUpdateSettingsTest, CurrentChromeChannelVariousApValuesUser) {
-  TestCurrentChromeChannelWithVariousApValues(USER_INSTALL);
-}
-
 // Run through all combinations of diff vs. full install, success and failure
 // results, and a fistful of initial "ap" values checking that the expected
 // final "ap" value is generated by
 // GoogleUpdateSettings::UpdateGoogleUpdateApKey.
 TEST_F(GoogleUpdateSettingsTest, UpdateGoogleUpdateApKey) {
   const installer::ArchiveType archive_types[] = {
     installer::UNKNOWN_ARCHIVE_TYPE,
     installer::FULL_ARCHIVE_TYPE,
     installer::INCREMENTAL_ARCHIVE_TYPE
   };
@@ skipping 217 matching lines @@
                           GoogleUpdateSettings::kPoliciesKey,
                           KEY_QUERY_VALUE));
   is_overridden = true;
   EXPECT_EQ(GoogleUpdateSettings::kDefaultUpdatePolicy,
             GoogleUpdateSettings::GetAppUpdatePolicy(kTestProductGuid,
                                                      &is_overridden));
   EXPECT_FALSE(is_overridden);
 }
 
 TEST_F(GoogleUpdateSettingsTest, UpdateProfileCountsSystemInstall) {
-  // Override FILE_MODULE and FILE_EXE with a path somewhere in the default
-  // system-level install location so that
-  // GoogleUpdateSettings::IsSystemInstall() returns true.
-  base::FilePath file_exe;
-  ASSERT_TRUE(PathService::Get(base::FILE_EXE, &file_exe));
-  base::FilePath install_dir(installer::GetChromeInstallPath(
-      true /* system_install */, BrowserDistribution::GetDistribution()));
-  file_exe = install_dir.Append(file_exe.BaseName());
-  base::ScopedPathOverride file_module_override(
-      base::FILE_MODULE, file_exe, true /* is_absolute */, false /* create */);
-  base::ScopedPathOverride file_exe_override(
-      base::FILE_EXE, file_exe, true /* is_absolute */, false /* create */);
+  // Set up a basic system-level InstallDetails.
+  install_static::ScopedInstallDetails details(true /* system_level */);
 
   // No profile count keys present yet.
   const base::string16& state_key = BrowserDistribution::GetDistribution()->
       GetAppRegistrationData().GetStateMediumKey();
   base::string16 num_profiles_path(state_key);
   num_profiles_path.append(L"\\");
   num_profiles_path.append(google_update::kRegProfilesActive);
   base::string16 num_signed_in_path(state_key);
   num_signed_in_path.append(L"\\");
   num_signed_in_path.append(google_update::kRegProfilesSignedIn);
@@ skipping 560 matching lines @@
   bool system_level_;
   StateSetting state_value_;
   StateSetting state_medium_value_;
 };
 
 const StatsState::UserLevelState StatsState::kUserLevel = {};
 const StatsState::SystemLevelState StatsState::kSystemLevel = {};
 
 // A value parameterized test for testing the stats collection consent setting.
 class CollectStatsConsent : public ::testing::TestWithParam<StatsState> {
- public:
-  static void SetUpTestCase();
-  static void TearDownTestCase();
  protected:
-  void SetUp() override;
-  static void ApplySetting(StatsState::StateSetting setting,
-                           HKEY root_key,
-                           const base::string16& reg_key);
+  CollectStatsConsent();
+  void ApplySetting(StatsState::StateSetting setting,
+                    HKEY root_key,
+                    const base::string16& reg_key);
 
-  // TODO(grt): Get rid of these statics and SetUpTestCase.
-  static base::string16* chrome_version_key_;
-  static base::string16* chrome_state_key_;
-  static base::string16* chrome_state_medium_key_;
+  BrowserDistribution* const dist_;
   registry_util::RegistryOverrideManager override_manager_;
+  std::unique_ptr<install_static::ScopedInstallDetails> scoped_install_details_;
 };
 
-base::string16* CollectStatsConsent::chrome_version_key_;
-base::string16* CollectStatsConsent::chrome_state_key_;
-base::string16* CollectStatsConsent::chrome_state_medium_key_;
-
-void CollectStatsConsent::SetUpTestCase() {
-  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  chrome_version_key_ = new base::string16(dist->GetVersionKey());
-  chrome_state_key_ = new base::string16(dist->GetStateKey());
-  chrome_state_medium_key_ = new base::string16(dist->GetStateMediumKey());
-}
-
-void CollectStatsConsent::TearDownTestCase() {
-  delete chrome_version_key_;
-  delete chrome_state_key_;
-  delete chrome_state_medium_key_;
-}
-
 // Install the registry override and apply the settings to the registry.
-void CollectStatsConsent::SetUp() {
+CollectStatsConsent::CollectStatsConsent()
+    : dist_(BrowserDistribution::GetDistribution()) {
   // Override both HKLM and HKCU as tests may touch either/both.
   ASSERT_NO_FATAL_FAILURE(
       override_manager_.OverrideRegistry(HKEY_LOCAL_MACHINE));
   ASSERT_NO_FATAL_FAILURE(
       override_manager_.OverrideRegistry(HKEY_CURRENT_USER));
 
   const StatsState& stats_state = GetParam();
+  scoped_install_details_ =
+      base::MakeUnique<install_static::ScopedInstallDetails>(
+          stats_state.system_level(), 0 /* install_mode_index */);
   const HKEY root_key = stats_state.root_key();
-  ApplySetting(stats_state.state_value(), root_key, *chrome_state_key_);
+  ApplySetting(stats_state.state_value(), root_key, dist_->GetStateKey());
   ApplySetting(stats_state.state_medium_value(), root_key,
-               *chrome_state_medium_key_);
+               dist_->GetStateMediumKey());
 }
 
 // Write the correct value to represent |setting| in the registry.
 void CollectStatsConsent::ApplySetting(StatsState::StateSetting setting,
                                        HKEY root_key,
                                        const base::string16& reg_key) {
   if (setting != StatsState::NO_SETTING) {
     DWORD value = setting != StatsState::FALSE_SETTING ? 1 : 0;
     ASSERT_EQ(
         ERROR_SUCCESS,
@@ skipping 83 matching lines @@
                                  StatsState::TRUE_SETTING),
                       StatsState(StatsState::kSystemLevel,
                                  StatsState::TRUE_SETTING,
                                  StatsState::NO_SETTING),
                       StatsState(StatsState::kSystemLevel,
                                  StatsState::TRUE_SETTING,
                                  StatsState::FALSE_SETTING),
                       StatsState(StatsState::kSystemLevel,
                                  StatsState::TRUE_SETTING,
                                  StatsState::TRUE_SETTING)));