Remove uses of BrowserDistribution::CHROME_BINARIES 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/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/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"
 
 using base::win::RegKey;
 using installer::ChannelInfo;
 
 namespace {
 
 const wchar_t kTestProductGuid[] = L"{89F1B351-B15D-48D4-8F10-1298721CF13D}";
@@ skipping 23 matching lines @@
     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));
   }
 
-  // Sets the "ap" field for a multi-install product (both the product and
-  // the binaries).
-  void SetMultiApField(SystemUserInstall is_system, const wchar_t* value) {
-    // Caller must specify a multi-install ap value.
-    ASSERT_NE(base::string16::npos, base::string16(value).find(L"-multi"));
-    HKEY root = is_system == SYSTEM_INSTALL ?
-        HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
-    RegKey update_key;
-
-    // Write the ap value for both the product and the binaries.
-    BrowserDistribution* const kDists[] = {
-      BrowserDistribution::GetDistribution(),
-      BrowserDistribution::GetSpecificDistribution(
-          BrowserDistribution::CHROME_BINARIES)
-    };
-    for (size_t i = 0; i < arraysize(kDists); ++i) {
-      base::string16 path = kDists[i]->GetStateKey();
-      ASSERT_EQ(ERROR_SUCCESS, update_key.Create(root, path.c_str(),
-                                                 KEY_WRITE));
-      ASSERT_EQ(ERROR_SUCCESS, update_key.WriteValue(L"ap", value));
-    }
-
-    // Make the product technically multi-install.
-    BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-    ASSERT_EQ(ERROR_SUCCESS,
-              update_key.Create(root, dist->GetStateKey().c_str(), KEY_WRITE));
-    ASSERT_EQ(ERROR_SUCCESS,
-              update_key.WriteValue(installer::kUninstallArgumentsField,
-                                    L"--multi-install"));
-  }
-
   // 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[] = {
@@ skipping 17 matching lines @@
 
     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());
-          base::string16 ret_channel;
-
-          EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(
-            is_system, &ret_channel));
+          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
@@ skipping 173 matching lines @@
   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;
-  EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(true,
-                                                                 &channel));
+  channel = GoogleUpdateSettings::GetChromeChannel(true);
   EXPECT_STREQ(L"", channel.c_str());
 
   // Then per-user.
-  EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(false,
-                                                                 &channel));
+  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;
-  EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(true,
-                                                                 &channel));
+  channel = GoogleUpdateSettings::GetChromeChannel(true);
   EXPECT_STREQ(L"", channel.c_str());
 
   // Per-user lookups still succeed and return empty string.
-  EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(false,
-                                                                 &channel));
+  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;
-  EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(true,
-                                                                 &channel));
+  channel = GoogleUpdateSettings::GetChromeChannel(true);
   EXPECT_STREQ(L"", channel.c_str());
 
   // Per-user lookup should succeed.
-  EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(false,
-                                                                 &channel));
+  channel = GoogleUpdateSettings::GetChromeChannel(false);
   EXPECT_STREQ(L"", channel.c_str());
 }
 
-// Test that the channel is pulled from the binaries for multi-install products.
-TEST_F(GoogleUpdateSettingsTest, MultiInstallChannelFromBinaries) {
-  SetMultiApField(USER_INSTALL, L"2.0-dev-multi-chrome");
-  base::string16 channel;
-
-  EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(false,
-                                                                 &channel));
-  EXPECT_STREQ(L"dev-m", channel.c_str());
-
-  // See if the same happens if the product's ap is cleared.
-  SetApField(USER_INSTALL, L"");
-  EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(false,
-                                                                 &channel));
-  EXPECT_STREQ(L"dev-m", channel.c_str());
-
-  // Test the converse (binaries are stable, Chrome is other).
-  SetMultiApField(USER_INSTALL, L"-multi-chrome");
-  SetApField(USER_INSTALL, L"2.0-dev-multi-chrome");
-  EXPECT_TRUE(GoogleUpdateSettings::GetChromeChannelAndModifiers(false,
-                                                                 &channel));
-  EXPECT_STREQ(L"m", 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, single vs. multi
-// install, success and failure results, and a fistful of initial "ap" values
-// checking that the expected final "ap" value is generated by
+// 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
   };
   const int results[] = {
     installer::FIRST_INSTALL_SUCCESS,
     installer::INSTALL_FAILED
@@ skipping 484 matching lines @@
   // updates.
   EXPECT_TRUE(is_overridden);
   EXPECT_EQ(GoogleUpdateSettings::AUTOMATIC_UPDATES, update_policy);
   EXPECT_TRUE(GoogleUpdateSettings::AreAutoupdatesEnabled());
 }
 
 TEST_F(GoogleUpdateSettingsTest, PerAppUpdatesEnabledWithGlobalDisabled) {
   // Disable updates globally but enable them for Chrome (the app-specific
   // setting should take precedence).
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  BrowserDistribution* binaries = BrowserDistribution::GetSpecificDistribution(
-      BrowserDistribution::CHROME_BINARIES);
   EXPECT_TRUE(
       SetUpdatePolicyForAppGuid(dist->GetAppGuid(),
                                 GoogleUpdateSettings::AUTOMATIC_UPDATES));
-  EXPECT_TRUE(
-      SetUpdatePolicyForAppGuid(binaries->GetAppGuid(),
-                                GoogleUpdateSettings::AUTOMATIC_UPDATES));
   EXPECT_TRUE(SetGlobalUpdatePolicy(GoogleUpdateSettings::UPDATES_DISABLED));
 
   // Make sure we read this as still having updates enabled.
   EXPECT_TRUE(GoogleUpdateSettings::AreAutoupdatesEnabled());
 
   // Make sure that the reset action returns true and is a no-op.
   EXPECT_TRUE(GoogleUpdateSettings::ReenableAutoupdates());
   EXPECT_EQ(GoogleUpdateSettings::AUTOMATIC_UPDATES,
             GetUpdatePolicyForAppGuid(dist->GetAppGuid()));
-  EXPECT_EQ(GoogleUpdateSettings::AUTOMATIC_UPDATES,
-            GetUpdatePolicyForAppGuid(binaries->GetAppGuid()));
   EXPECT_EQ(GoogleUpdateSettings::UPDATES_DISABLED, GetGlobalUpdatePolicy());
 }
 
 TEST_F(GoogleUpdateSettingsTest, GlobalUpdatesDisabledByPolicy) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   EXPECT_TRUE(SetGlobalUpdatePolicy(GoogleUpdateSettings::UPDATES_DISABLED));
   bool is_overridden = false;
 
   // The contract for GetAppUpdatePolicy states that |is_overridden| should be
   // set to false when updates are disabled on a non-app-specific basis.
@@ skipping 242 matching lines @@
       GoogleUpdateSettings::GetGoogleUpdateVersion(!system_install_)
           .IsValid());
 }
 
 INSTANTIATE_TEST_CASE_P(GetGoogleUpdateVersionAtLevel, GetGoogleUpdateVersion,
                         testing::Bool());
 
 // Test values for use by the CollectStatsConsent test fixture.
 class StatsState {
  public:
-  enum InstallType {
-    SINGLE_INSTALL,
-    MULTI_INSTALL,
-  };
   enum StateSetting {
     NO_SETTING,
     FALSE_SETTING,
     TRUE_SETTING,
   };
   struct UserLevelState {};
   struct SystemLevelState {};
   static const UserLevelState kUserLevel;
   static const SystemLevelState kSystemLevel;
 
   StatsState(const UserLevelState&,
-             InstallType install_type,
              StateSetting state_value)
       : system_level_(false),
-        multi_install_(install_type == MULTI_INSTALL),
         state_value_(state_value),
         state_medium_value_(NO_SETTING) {
   }
   StatsState(const SystemLevelState&,
-             InstallType install_type,
              StateSetting state_value,
              StateSetting state_medium_value)
       : system_level_(true),
-        multi_install_(install_type == MULTI_INSTALL),
         state_value_(state_value),
         state_medium_value_(state_medium_value) {
   }
   bool system_level() const { return system_level_; }
-  bool multi_install() const { return multi_install_; }
   HKEY root_key() const {
     return system_level_ ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   }
   StateSetting state_value() const { return state_value_; }
   StateSetting state_medium_value() const {
     return state_medium_value_;
   }
   bool is_consent_granted() const {
     return (system_level_ && state_medium_value_ != NO_SETTING) ?
         (state_medium_value_ == TRUE_SETTING) :
         (state_value_ == TRUE_SETTING);
   }
 
  private:
   bool system_level_;
-  bool multi_install_;
   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 MakeChromeMultiInstall(HKEY root_key);
   static 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_;
-  static base::string16* binaries_state_key_;
-  static base::string16* binaries_state_medium_key_;
   registry_util::RegistryOverrideManager override_manager_;
 };
 
 base::string16* CollectStatsConsent::chrome_version_key_;
 base::string16* CollectStatsConsent::chrome_state_key_;
 base::string16* CollectStatsConsent::chrome_state_medium_key_;
-base::string16* CollectStatsConsent::binaries_state_key_;
-base::string16* CollectStatsConsent::binaries_state_medium_key_;
 
 void CollectStatsConsent::SetUpTestCase() {
   BrowserDistribution* dist =
       BrowserDistribution::GetSpecificDistribution(
           BrowserDistribution::CHROME_BROWSER);
   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());
-
-  dist = BrowserDistribution::GetSpecificDistribution(
-      BrowserDistribution::CHROME_BINARIES);
-  binaries_state_key_ = new base::string16(dist->GetStateKey());
-  binaries_state_medium_key_ = new base::string16(dist->GetStateMediumKey());
 }
 
 void CollectStatsConsent::TearDownTestCase() {
   delete chrome_version_key_;
   delete chrome_state_key_;
   delete chrome_state_medium_key_;
-  delete binaries_state_key_;
-  delete binaries_state_medium_key_;
 }
 
 // Install the registry override and apply the settings to the registry.
 void CollectStatsConsent::SetUp() {
   // Override both HKLM and HKCU as tests may touch either/both.
   override_manager_.OverrideRegistry(HKEY_LOCAL_MACHINE);
   override_manager_.OverrideRegistry(HKEY_CURRENT_USER);
 
   const StatsState& stats_state = GetParam();
   const HKEY root_key = stats_state.root_key();
-  if (stats_state.multi_install()) {
-    MakeChromeMultiInstall(root_key);
-    ApplySetting(stats_state.state_value(), root_key, *binaries_state_key_);
-    ApplySetting(stats_state.state_medium_value(), root_key,
-                 *binaries_state_medium_key_);
-  } else {
-    ApplySetting(stats_state.state_value(), root_key, *chrome_state_key_);
-    ApplySetting(stats_state.state_medium_value(), root_key,
-                 *chrome_state_medium_key_);
-  }
-}
-
-// Write values into the registry so that Chrome is considered to be installed
-// as multi-install.
-void CollectStatsConsent::MakeChromeMultiInstall(HKEY root_key) {
-  ASSERT_EQ(
-      ERROR_SUCCESS,
-      RegKey(root_key, chrome_version_key_->c_str(),
-             KEY_SET_VALUE).WriteValue(google_update::kRegVersionField,
-                                       L"1.2.3.4"));
-  ASSERT_EQ(
-      ERROR_SUCCESS,
-      RegKey(root_key, chrome_state_key_->c_str(),
-             KEY_SET_VALUE).WriteValue(installer::kUninstallArgumentsField,
-                                       L"--multi-install"));
+  ApplySetting(stats_state.state_value(), root_key, *chrome_state_key_);
+  ApplySetting(stats_state.state_medium_value(), root_key,
+               *chrome_state_medium_key_);
 }
 
 // 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 24 matching lines @@
     client_info.client_id = "01234567-89ab-cdef-fedc-ba9876543210";
     client_info.installation_date = 123;
     client_info.reporting_enabled_date = 345;
     GoogleUpdateSettings::StoreMetricsClientInfo(client_info);
   }
 
   EXPECT_TRUE(GoogleUpdateSettings::SetCollectStatsConsentAtLevel(
                   GetParam().system_level(),
                   !GetParam().is_consent_granted()));
 
-  const base::string16* const reg_keys[] = {
-    chrome_state_key_,
-    chrome_state_medium_key_,
-    binaries_state_key_,
-    binaries_state_medium_key_,
-  };
-  int key_index = ((GetParam().system_level() ? 1 : 0) +
-                   (GetParam().multi_install() ? 2 : 0));
-  const base::string16& reg_key = *reg_keys[key_index];
+  const base::string16& reg_key = GetParam().system_level()
+                                      ? *chrome_state_medium_key_
+                                      : *chrome_state_key_;
   DWORD value = 0;
   EXPECT_EQ(
       ERROR_SUCCESS,
       RegKey(GetParam().root_key(), reg_key.c_str(),
              KEY_QUERY_VALUE).ReadValueDW(google_update::kRegUsageStatsField,
                                           &value));
   if (GetParam().is_consent_granted()) {
     EXPECT_FALSE(GoogleUpdateSettings::GetCollectStatsConsentAtLevel(
                      GetParam().system_level()));
     EXPECT_EQ(0UL, value);
   } else {
     EXPECT_TRUE(GoogleUpdateSettings::GetCollectStatsConsentAtLevel(
                     GetParam().system_level()));
     EXPECT_EQ(1UL, value);
     // Verify that backup client info has been cleared.
     EXPECT_FALSE(GoogleUpdateSettings::LoadMetricsClientInfo());
   }
 }
 
 INSTANTIATE_TEST_CASE_P(
-    UserLevelSingleInstall,
+    UserLevel,
     CollectStatsConsent,
     ::testing::Values(
-        StatsState(StatsState::kUserLevel, StatsState::SINGLE_INSTALL,
-                   StatsState::NO_SETTING),
-        StatsState(StatsState::kUserLevel, StatsState::SINGLE_INSTALL,
-                   StatsState::FALSE_SETTING),
-        StatsState(StatsState::kUserLevel, StatsState::SINGLE_INSTALL,
-                   StatsState::TRUE_SETTING)));
+        StatsState(StatsState::kUserLevel, StatsState::NO_SETTING),
+        StatsState(StatsState::kUserLevel, StatsState::FALSE_SETTING),
+        StatsState(StatsState::kUserLevel, StatsState::TRUE_SETTING)));
 INSTANTIATE_TEST_CASE_P(
-    UserLevelMultiInstall,
+    SystemLevel,
     CollectStatsConsent,
-    ::testing::Values(
-        StatsState(StatsState::kUserLevel, StatsState::MULTI_INSTALL,
-                   StatsState::NO_SETTING),
-        StatsState(StatsState::kUserLevel, StatsState::MULTI_INSTALL,
-                   StatsState::FALSE_SETTING),
-        StatsState(StatsState::kUserLevel, StatsState::MULTI_INSTALL,
-                   StatsState::TRUE_SETTING)));
-INSTANTIATE_TEST_CASE_P(
-    SystemLevelSingleInstall,
-    CollectStatsConsent,
-    ::testing::Values(
-        StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL,
-                   StatsState::NO_SETTING, StatsState::NO_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL,
-                   StatsState::NO_SETTING, StatsState::FALSE_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL,
-                   StatsState::NO_SETTING, StatsState::TRUE_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL,
-                   StatsState::FALSE_SETTING, StatsState::NO_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL,
-                   StatsState::FALSE_SETTING, StatsState::FALSE_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL,
-                   StatsState::FALSE_SETTING, StatsState::TRUE_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL,
-                   StatsState::TRUE_SETTING, StatsState::NO_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL,
-                   StatsState::TRUE_SETTING, StatsState::FALSE_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::SINGLE_INSTALL,
-                   StatsState::TRUE_SETTING, StatsState::TRUE_SETTING)));
-INSTANTIATE_TEST_CASE_P(
-    SystemLevelMultiInstall,
-    CollectStatsConsent,
-    ::testing::Values(
-        StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
-                   StatsState::NO_SETTING, StatsState::NO_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
-                   StatsState::NO_SETTING, StatsState::FALSE_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
-                   StatsState::NO_SETTING, StatsState::TRUE_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
-                   StatsState::FALSE_SETTING, StatsState::NO_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
-                   StatsState::FALSE_SETTING, StatsState::FALSE_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
-                   StatsState::FALSE_SETTING, StatsState::TRUE_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
-                   StatsState::TRUE_SETTING, StatsState::NO_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
-                   StatsState::TRUE_SETTING, StatsState::FALSE_SETTING),
-        StatsState(StatsState::kSystemLevel, StatsState::MULTI_INSTALL,
-                   StatsState::TRUE_SETTING, StatsState::TRUE_SETTING)));
+    ::testing::Values(StatsState(StatsState::kSystemLevel,
+                                 StatsState::NO_SETTING,
+                                 StatsState::NO_SETTING),
+                      StatsState(StatsState::kSystemLevel,
+                                 StatsState::NO_SETTING,
+                                 StatsState::FALSE_SETTING),
+                      StatsState(StatsState::kSystemLevel,
+                                 StatsState::NO_SETTING,
+                                 StatsState::TRUE_SETTING),
+                      StatsState(StatsState::kSystemLevel,
+                                 StatsState::FALSE_SETTING,
+                                 StatsState::NO_SETTING),
+                      StatsState(StatsState::kSystemLevel,
+                                 StatsState::FALSE_SETTING,
+                                 StatsState::FALSE_SETTING),
+                      StatsState(StatsState::kSystemLevel,
+                                 StatsState::FALSE_SETTING,
+                                 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)));