Use InstallDetails in installer_util.

chrome/installer/util/beacons_unittest.cc

 // Copyright 2015 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/beacons.h"
 
-#include "base/base_paths.h"
+#include <memory>
+#include <tuple>
+
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/path_service.h"
-#include "base/test/scoped_path_override.h"
 #include "base/test/test_reg_util_win.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/win/registry.h"
 #include "base/win/win_util.h"
+#include "chrome/install_static/install_details.h"
+#include "chrome/install_static/install_modes.h"
+#include "chrome/install_static/test/scoped_install_details.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/test_app_registration_data.h"
 #include "chrome/installer/util/util_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Bool;
 using ::testing::Combine;
 using ::testing::Values;
 using BeaconType = installer_util::Beacon::BeaconType;
@@ skipping 106 matching lines @@
 }
 
 // Run the tests for all combinations of beacon type, scope, and install level.
 INSTANTIATE_TEST_CASE_P(BeaconTest,
                         BeaconTest,
                         Combine(Values(BeaconType::FIRST, BeaconType::LAST),
                                 Values(BeaconScope::PER_USER,
                                        BeaconScope::PER_INSTALL),
                                 Bool()));
 
-enum class DistributionVariant {
-  SYSTEM_LEVEL,
-  USER_LEVEL,
-  SXS,
-};
-
 class DefaultBrowserBeaconTest
-    : public ::testing::TestWithParam<DistributionVariant> {
+    : public ::testing::TestWithParam<
+          std::tuple<install_static::InstallConstantIndex, const char*>> {
  protected:
-  using Super = ::testing::TestWithParam<DistributionVariant>;
-
-  DefaultBrowserBeaconTest()
-      : system_install_(GetParam() == DistributionVariant::SYSTEM_LEVEL),
-        chrome_sxs_(GetParam() == DistributionVariant::SXS),
-        chrome_exe_(GetChromePathForParams()),
-        distribution_(nullptr) {}
+  using Super = ::testing::TestWithParam<
+      std::tuple<install_static::InstallConstantIndex, const char*>>;
 
   void SetUp() override {
     Super::SetUp();
 
-    // Override FILE_EXE so that various InstallUtil functions will consider
-    // this to be a user/system Chrome or Chrome SxS.
-    path_overrides_.push_back(new base::ScopedPathOverride(
-        base::FILE_EXE, chrome_exe_, true /* is_absolute */,
-        false /* !create */));
+    install_static::InstallConstantIndex mode_index;
+    const char* level;
+    std::tie(mode_index, level) = GetParam();
 
-    // Override these paths with their own values so that they can be found
-    // after the registry override manager is in place. Getting them would
-    // otherwise fail since the underlying calls to the OS need to see the real
-    // contents of the registry.
-    static const int kPathKeys[] = {
-        base::DIR_PROGRAM_FILES,
-        base::DIR_PROGRAM_FILESX86,
-        base::DIR_LOCAL_APP_DATA,
-    };
-    for (int key : kPathKeys) {
-      base::FilePath temp;
-      PathService::Get(key, &temp);
-      path_overrides_.push_back(new base::ScopedPathOverride(key, temp));
-    }
+    system_install_ = (std::string(level) != "user");

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

Why not just strcmp?

+
+    // Configure InstallDetails for the test.
+    scoped_install_details_ =
+        base::MakeUnique<install_static::ScopedInstallDetails>(system_install_,
+                                                               mode_index);
+    chrome_exe_ = GetChromePath();
 
     // Override the registry so that tests can freely push state to it.
     ASSERT_NO_FATAL_FAILURE(
         registry_override_manager_.OverrideRegistry(HKEY_CURRENT_USER));
     ASSERT_NO_FATAL_FAILURE(
         registry_override_manager_.OverrideRegistry(HKEY_LOCAL_MACHINE));
 
     // Ensure that IsPerUserInstall returns the proper value.
     ASSERT_EQ(!system_install_, InstallUtil::IsPerUserInstall(chrome_exe_));
 
     distribution_ = BrowserDistribution::GetDistribution();
   }
 
-  bool system_install_;
-  bool chrome_sxs_;
+  bool system_install_ = false;
   base::FilePath chrome_exe_;
-  BrowserDistribution* distribution_;
+  BrowserDistribution* distribution_ = nullptr;
 
  private:
-  base::FilePath GetChromePathForParams() const {
+  base::FilePath GetChromePath() const {
     base::FilePath chrome_exe;
     int dir_key = base::DIR_LOCAL_APP_DATA;
 
     if (system_install_) {
 #if defined(_WIN64)
       static const int kSystemKey = base::DIR_PROGRAM_FILESX86;
 #else
       static const int kSystemKey = base::DIR_PROGRAM_FILES;
 #endif
       dir_key = kSystemKey;
     }
     PathService::Get(dir_key, &chrome_exe);
-#if defined(GOOGLE_CHROME_BUILD)
-    chrome_exe = chrome_exe.Append(installer::kGoogleChromeInstallSubDir1);
-    if (chrome_sxs_) {
-      chrome_exe = chrome_exe.Append(
-          base::string16(installer::kGoogleChromeInstallSubDir2) +
-          installer::kSxSSuffix);
-    } else {
-      chrome_exe = chrome_exe.Append(installer::kGoogleChromeInstallSubDir2);
-    }
-#else
-    chrome_exe = chrome_exe.AppendASCII("Chromium");
-#endif
+    if (*install_static::kCompanyPathName)
+      chrome_exe = chrome_exe.Append(install_static::kCompanyPathName);
+    chrome_exe = chrome_exe.Append(
+        base::string16(install_static::kProductPathName)
+            .append(install_static::InstallDetails::Get().install_suffix()));
     chrome_exe = chrome_exe.Append(installer::kInstallBinaryDir);
     return chrome_exe.Append(installer::kChromeExe);
   }
 
-  ScopedVector<base::ScopedPathOverride> path_overrides_;
+  std::unique_ptr<install_static::ScopedInstallDetails> scoped_install_details_;
   registry_util::RegistryOverrideManager registry_override_manager_;
 };
 
 // Tests that the default browser beacons work as expected.
 TEST_P(DefaultBrowserBeaconTest, All) {
   std::unique_ptr<Beacon> last_was_default(MakeLastWasDefaultBeacon(
       system_install_, distribution_->GetAppRegistrationData()));
   std::unique_ptr<Beacon> first_not_default(MakeFirstNotDefaultBeacon(
       system_install_, distribution_->GetAppRegistrationData()));
 
@@ skipping 24 matching lines @@
   ASSERT_FALSE(last_was_default->Get().is_null());
   ASSERT_FALSE(first_not_default->Get().is_null());
 
   // And it still isn't.
   UpdateDefaultBrowserBeaconWithState(chrome_exe_, distribution_,
                                       ShellUtil::NOT_DEFAULT);
   ASSERT_FALSE(last_was_default->Get().is_null());
   ASSERT_FALSE(first_not_default->Get().is_null());
 }
 
-INSTANTIATE_TEST_CASE_P(SystemLevelChrome,
-                        DefaultBrowserBeaconTest,
-                        Values(DistributionVariant::SYSTEM_LEVEL));
-INSTANTIATE_TEST_CASE_P(UserLevelChrome,
-                        DefaultBrowserBeaconTest,
-                        Values(DistributionVariant::USER_LEVEL));
-#if 0 && defined(GOOGLE_CHROME_BUILD)
-// Disabled for now since InstallUtil::IsChromeSxSProcess makes this impossible.

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

Nice :)! Was there an associated bug that this resolves?

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

Hooray for test seams! I can't find a bug for this, or for general
"IsChromeSxSProcess can't be mocked/faked".

-INSTANTIATE_TEST_CASE_P(ChromeSxS, DefaultBrowserBeaconTest,
-                        Values(DistributionVariant::SXS));
-#endif
+#if defined(GOOGLE_CHROME_BUILD)
+// Stable supports user and system levels.
+INSTANTIATE_TEST_CASE_P(
+    Stable,
+    DefaultBrowserBeaconTest,
+    testing::Combine(testing::Values(install_static::STABLE_INDEX),
+                     testing::Values("user", "system")));
+// Canary is only at user level.
+INSTANTIATE_TEST_CASE_P(
+    Canary,
+    DefaultBrowserBeaconTest,
+    testing::Combine(testing::Values(install_static::CANARY_INDEX),
+                     testing::Values("user")));
+#else   // GOOGLE_CHROME_BUILD
+// Chromium supports user and system levels.
+INSTANTIATE_TEST_CASE_P(
+    Chromium,
+    DefaultBrowserBeaconTest,
+    testing::Combine(testing::Values(install_static::CHROMIUM_INDEX),
+                     testing::Values("user", "system")));
+#endif  // !GOOGLE_CHROME_BUILD

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

remove "!"

 
 }  // namespace installer_util