chrome/installer/setup/setup_util_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/installer/setup/setup_util_unittest.h"
   6
   7 #include <windows.h>
   8
   9 #include <string>
  10
  11 #include "base/command_line.h"
  12 #include "base/files/file_util.h"
  13 #include "base/files/scoped_temp_dir.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/process/kill.h"
  16 #include "base/process/launch.h"
  17 #include "base/process/process_handle.h"
  18 #include "base/strings/string_util.h"
  19 #include "base/test/test_reg_util_win.h"
  20 #include "base/threading/platform_thread.h"
  21 #include "base/time/time.h"
  22 #include "base/version.h"
  23 #include "base/win/scoped_handle.h"
  24 #include "base/win/windows_version.h"
  25 #include "chrome/installer/setup/setup_constants.h"
  26 #include "chrome/installer/setup/setup_util.h"
  27 #include "chrome/installer/util/google_update_constants.h"
  28 #include "chrome/installer/util/installation_state.h"
  29 #include "chrome/installer/util/installer_state.h"
  30 #include "chrome/installer/util/updating_app_registration_data.h"
  31 #include "chrome/installer/util/util_constants.h"
  32 #include "testing/gtest/include/gtest/gtest.h"
  33
  34 namespace {
  35
  36 class SetupUtilTestWithDir : public testing::Test {
  37  protected:
  38   void SetUp() override {
  39     // Create a temp directory for testing.
  40     ASSERT_TRUE(test_dir_.CreateUniqueTempDir());
  41   }
  42
  43   void TearDown() override {
  44     // Clean up test directory manually so we can fail if it leaks.
  45     ASSERT_TRUE(test_dir_.Delete());
  46   }
  47
  48   // The temporary directory used to contain the test operations.
  49   base::ScopedTempDir test_dir_;
  50 };
  51
  52 // The privilege tested in ScopeTokenPrivilege tests below.
  53 // Use SE_RESTORE_NAME as it is one of the many privileges that is available,
  54 // but not enabled by default on processes running at high integrity.
  55 static const wchar_t kTestedPrivilege[] = SE_RESTORE_NAME;
  56
  57 // Returns true if the current process' token has privilege |privilege_name|
  58 // enabled.
  59 bool CurrentProcessHasPrivilege(const wchar_t* privilege_name) {
  60   HANDLE temp_handle;
  61   if (!::OpenProcessToken(::GetCurrentProcess(), TOKEN_QUERY,
  62                           &temp_handle)) {
  63     ADD_FAILURE();
  64     return false;
  65   }
  66
  67   base::win::ScopedHandle token(temp_handle);
  68
  69   // First get the size of the buffer needed for |privileges| below.
  70   DWORD size;
  71   EXPECT_FALSE(::GetTokenInformation(token.Get(), TokenPrivileges, NULL, 0,
  72                                      &size));
  73
  74   scoped_ptr<BYTE[]> privileges_bytes(new BYTE[size]);
  75   TOKEN_PRIVILEGES* privileges =
  76       reinterpret_cast<TOKEN_PRIVILEGES*>(privileges_bytes.get());
  77
  78   if (!::GetTokenInformation(token.Get(), TokenPrivileges, privileges, size,
  79                              &size)) {
  80     ADD_FAILURE();
  81     return false;
  82   }
  83
  84   // There is no point getting a buffer to store more than |privilege_name|\0 as
  85   // anything longer will obviously not be equal to |privilege_name|.
  86   const DWORD desired_size = wcslen(privilege_name);
  87   const DWORD buffer_size = desired_size + 1;
  88   scoped_ptr<wchar_t[]> name_buffer(new wchar_t[buffer_size]);
  89   for (int i = privileges->PrivilegeCount - 1; i >= 0 ; --i) {
  90     LUID_AND_ATTRIBUTES& luid_and_att = privileges->Privileges[i];
  91     DWORD size = buffer_size;
  92     ::LookupPrivilegeName(NULL, &luid_and_att.Luid, name_buffer.get(), &size);
  93     if (size == desired_size &&
  94         wcscmp(name_buffer.get(), privilege_name) == 0) {
  95       return luid_and_att.Attributes == SE_PRIVILEGE_ENABLED;
  96     }
  97   }
  98   return false;
  99 }
 100
 101 }  // namespace
 102
 103 // Test that we are parsing Chrome version correctly.
 104 TEST_F(SetupUtilTestWithDir, GetMaxVersionFromArchiveDirTest) {
 105   // Create a version dir
 106   base::FilePath chrome_dir = test_dir_.path().AppendASCII("1.0.0.0");
 107   base::CreateDirectory(chrome_dir);
 108   ASSERT_TRUE(base::PathExists(chrome_dir));
 109   scoped_ptr<Version> version(
 110       installer::GetMaxVersionFromArchiveDir(test_dir_.path()));
 111   ASSERT_EQ(version->GetString(), "1.0.0.0");
 112
 113   base::DeleteFile(chrome_dir, true);
 114   ASSERT_FALSE(base::PathExists(chrome_dir));
 115   ASSERT_TRUE(installer::GetMaxVersionFromArchiveDir(test_dir_.path()) == NULL);
 116
 117   chrome_dir = test_dir_.path().AppendASCII("ABC");
 118   base::CreateDirectory(chrome_dir);
 119   ASSERT_TRUE(base::PathExists(chrome_dir));
 120   ASSERT_TRUE(installer::GetMaxVersionFromArchiveDir(test_dir_.path()) == NULL);
 121
 122   chrome_dir = test_dir_.path().AppendASCII("2.3.4.5");
 123   base::CreateDirectory(chrome_dir);
 124   ASSERT_TRUE(base::PathExists(chrome_dir));
 125   version.reset(installer::GetMaxVersionFromArchiveDir(test_dir_.path()));
 126   ASSERT_EQ(version->GetString(), "2.3.4.5");
 127
 128   // Create multiple version dirs, ensure that we select the greatest.
 129   chrome_dir = test_dir_.path().AppendASCII("9.9.9.9");
 130   base::CreateDirectory(chrome_dir);
 131   ASSERT_TRUE(base::PathExists(chrome_dir));
 132   chrome_dir = test_dir_.path().AppendASCII("1.1.1.1");
 133   base::CreateDirectory(chrome_dir);
 134   ASSERT_TRUE(base::PathExists(chrome_dir));
 135
 136   version.reset(installer::GetMaxVersionFromArchiveDir(test_dir_.path()));
 137   ASSERT_EQ(version->GetString(), "9.9.9.9");
 138 }
 139
 140 TEST_F(SetupUtilTestWithDir, DeleteFileFromTempProcess) {
 141   base::FilePath test_file;
 142   base::CreateTemporaryFileInDir(test_dir_.path(), &test_file);
 143   ASSERT_TRUE(base::PathExists(test_file));
 144   base::WriteFile(test_file, "foo", 3);
 145   EXPECT_TRUE(installer::DeleteFileFromTempProcess(test_file, 0));
 146   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
 147   EXPECT_FALSE(base::PathExists(test_file));
 148 }
 149
 150 // Note: This test is only valid when run at high integrity (i.e. it will fail
 151 // at medium integrity).
 152 TEST(SetupUtilTest, ScopedTokenPrivilegeBasic) {
 153   ASSERT_FALSE(CurrentProcessHasPrivilege(kTestedPrivilege));
 154
 155   {
 156     installer::ScopedTokenPrivilege test_scoped_privilege(kTestedPrivilege);
 157     ASSERT_TRUE(test_scoped_privilege.is_enabled());
 158     ASSERT_TRUE(CurrentProcessHasPrivilege(kTestedPrivilege));
 159   }
 160
 161   ASSERT_FALSE(CurrentProcessHasPrivilege(kTestedPrivilege));
 162 }
 163
 164 // Note: This test is only valid when run at high integrity (i.e. it will fail
 165 // at medium integrity).
 166 TEST(SetupUtilTest, ScopedTokenPrivilegeAlreadyEnabled) {
 167   ASSERT_FALSE(CurrentProcessHasPrivilege(kTestedPrivilege));
 168
 169   {
 170     installer::ScopedTokenPrivilege test_scoped_privilege(kTestedPrivilege);
 171     ASSERT_TRUE(test_scoped_privilege.is_enabled());
 172     ASSERT_TRUE(CurrentProcessHasPrivilege(kTestedPrivilege));
 173     {
 174       installer::ScopedTokenPrivilege dup_scoped_privilege(kTestedPrivilege);
 175       ASSERT_TRUE(dup_scoped_privilege.is_enabled());
 176       ASSERT_TRUE(CurrentProcessHasPrivilege(kTestedPrivilege));
 177     }
 178     ASSERT_TRUE(CurrentProcessHasPrivilege(kTestedPrivilege));
 179   }
 180
 181   ASSERT_FALSE(CurrentProcessHasPrivilege(kTestedPrivilege));
 182 }
 183
 184 const char kAdjustProcessPriority[] = "adjust-process-priority";
 185
 186 PriorityClassChangeResult DoProcessPriorityAdjustment() {
 187   return installer::AdjustProcessPriority() ? PCCR_CHANGED : PCCR_UNCHANGED;
 188 }
 189
 190 namespace {
 191
 192 // A scoper that sets/resets the current process's priority class.
 193 class ScopedPriorityClass {
 194  public:
 195   // Applies |priority_class|, returning an instance if a change was made.
 196   // Otherwise, returns an empty scoped_ptr.
 197   static scoped_ptr<ScopedPriorityClass> Create(DWORD priority_class);
 198   ~ScopedPriorityClass();
 199
 200  private:
 201   explicit ScopedPriorityClass(DWORD original_priority_class);
 202   DWORD original_priority_class_;
 203   DISALLOW_COPY_AND_ASSIGN(ScopedPriorityClass);
 204 };
 205
 206 scoped_ptr<ScopedPriorityClass> ScopedPriorityClass::Create(
 207     DWORD priority_class) {
 208   HANDLE this_process = ::GetCurrentProcess();
 209   DWORD original_priority_class = ::GetPriorityClass(this_process);
 210   EXPECT_NE(0U, original_priority_class);
 211   if (original_priority_class && original_priority_class != priority_class) {
 212     BOOL result = ::SetPriorityClass(this_process, priority_class);
 213     EXPECT_NE(FALSE, result);
 214     if (result) {
 215       return scoped_ptr<ScopedPriorityClass>(
 216           new ScopedPriorityClass(original_priority_class));
 217     }
 218   }
 219   return scoped_ptr<ScopedPriorityClass>();
 220 }
 221
 222 ScopedPriorityClass::ScopedPriorityClass(DWORD original_priority_class)
 223     : original_priority_class_(original_priority_class) {}
 224
 225 ScopedPriorityClass::~ScopedPriorityClass() {
 226   BOOL result = ::SetPriorityClass(::GetCurrentProcess(),
 227                                    original_priority_class_);
 228   EXPECT_NE(FALSE, result);
 229 }
 230
 231 PriorityClassChangeResult RelaunchAndDoProcessPriorityAdjustment() {
 232   base::CommandLine cmd_line(*base::CommandLine::ForCurrentProcess());
 233   cmd_line.AppendSwitch(kAdjustProcessPriority);
 234   base::Process process = base::LaunchProcess(cmd_line, base::LaunchOptions());
 235   int exit_code = 0;
 236   if (!process.IsValid()) {
 237     ADD_FAILURE() << " to launch subprocess.";
 238   } else if (!process.WaitForExit(&exit_code)) {
 239     ADD_FAILURE() << " to wait for subprocess to exit.";
 240   } else {
 241     return static_cast<PriorityClassChangeResult>(exit_code);
 242   }
 243   return PCCR_UNKNOWN;
 244 }
 245
 246 }  // namespace
 247
 248 // Launching a subprocess at normal priority class is a noop.
 249 TEST(SetupUtilTest, AdjustFromNormalPriority) {
 250   ASSERT_EQ(NORMAL_PRIORITY_CLASS, ::GetPriorityClass(::GetCurrentProcess()));
 251   EXPECT_EQ(PCCR_UNCHANGED, RelaunchAndDoProcessPriorityAdjustment());
 252 }
 253
 254 // Launching a subprocess below normal priority class drops it to bg mode for
 255 // sufficiently recent operating systems.
 256 TEST(SetupUtilTest, AdjustFromBelowNormalPriority) {
 257   scoped_ptr<ScopedPriorityClass> below_normal =
 258       ScopedPriorityClass::Create(BELOW_NORMAL_PRIORITY_CLASS);
 259   ASSERT_TRUE(below_normal);
 260   if (base::win::GetVersion() > base::win::VERSION_SERVER_2003)
 261     EXPECT_EQ(PCCR_CHANGED, RelaunchAndDoProcessPriorityAdjustment());
 262   else
 263     EXPECT_EQ(PCCR_UNCHANGED, RelaunchAndDoProcessPriorityAdjustment());
 264 }
 265
 266 namespace {
 267
 268 // A test fixture that configures an InstallationState and an InstallerState
 269 // with a product being updated.
 270 class FindArchiveToPatchTest : public SetupUtilTestWithDir {
 271  protected:
 272   class FakeInstallationState : public installer::InstallationState {
 273   };
 274
 275   class FakeProductState : public installer::ProductState {
 276    public:
 277     static FakeProductState* FromProductState(const ProductState* product) {
 278       return static_cast<FakeProductState*>(const_cast<ProductState*>(product));
 279     }
 280
 281     void set_version(const Version& version) {
 282       if (version.IsValid())
 283         version_.reset(new Version(version));
 284       else
 285         version_.reset();
 286     }
 287
 288     void set_uninstall_command(const base::CommandLine& uninstall_command) {
 289       uninstall_command_ = uninstall_command;
 290     }
 291   };
 292
 293   void SetUp() override {
 294     SetupUtilTestWithDir::SetUp();
 295     product_version_ = Version("30.0.1559.0");
 296     max_version_ = Version("47.0.1559.0");
 297
 298     // Install the product according to the version.
 299     original_state_.reset(new FakeInstallationState());
 300     InstallProduct();
 301
 302     // Prepare to update the product in the temp dir.
 303     installer_state_.reset(new installer::InstallerState(
 304         kSystemInstall_ ? installer::InstallerState::SYSTEM_LEVEL :
 305         installer::InstallerState::USER_LEVEL));
 306     installer_state_->AddProductFromState(
 307         kProductType_,
 308         *original_state_->GetProductState(kSystemInstall_, kProductType_));
 309
 310     // Create archives in the two version dirs.
 311     ASSERT_TRUE(
 312         base::CreateDirectory(GetProductVersionArchivePath().DirName()));
 313     ASSERT_EQ(1, base::WriteFile(GetProductVersionArchivePath(), "a", 1));
 314     ASSERT_TRUE(
 315         base::CreateDirectory(GetMaxVersionArchivePath().DirName()));
 316     ASSERT_EQ(1, base::WriteFile(GetMaxVersionArchivePath(), "b", 1));
 317   }
 318
 319   void TearDown() override {
 320     original_state_.reset();
 321     SetupUtilTestWithDir::TearDown();
 322   }
 323
 324   base::FilePath GetArchivePath(const Version& version) const {
 325     return test_dir_.path()
 326         .AppendASCII(version.GetString())
 327         .Append(installer::kInstallerDir)
 328         .Append(installer::kChromeArchive);
 329   }
 330
 331   base::FilePath GetMaxVersionArchivePath() const {
 332     return GetArchivePath(max_version_);
 333   }
 334
 335   base::FilePath GetProductVersionArchivePath() const {
 336     return GetArchivePath(product_version_);
 337   }
 338
 339   void InstallProduct() {
 340     FakeProductState* product = FakeProductState::FromProductState(
 341         original_state_->GetNonVersionedProductState(kSystemInstall_,
 342                                                      kProductType_));
 343
 344     product->set_version(product_version_);
 345     base::CommandLine uninstall_command(
 346         test_dir_.path()
 347             .AppendASCII(product_version_.GetString())
 348             .Append(installer::kInstallerDir)
 349             .Append(installer::kSetupExe));
 350     uninstall_command.AppendSwitch(installer::switches::kUninstall);
 351     product->set_uninstall_command(uninstall_command);
 352   }
 353
 354   void UninstallProduct() {
 355     FakeProductState::FromProductState(
 356         original_state_->GetNonVersionedProductState(kSystemInstall_,
 357                                                      kProductType_))
 358         ->set_version(Version());
 359   }
 360
 361   static const bool kSystemInstall_;
 362   static const BrowserDistribution::Type kProductType_;
 363   Version product_version_;
 364   Version max_version_;
 365   scoped_ptr<FakeInstallationState> original_state_;
 366   scoped_ptr<installer::InstallerState> installer_state_;
 367 };
 368
 369 const bool FindArchiveToPatchTest::kSystemInstall_ = false;
 370 const BrowserDistribution::Type FindArchiveToPatchTest::kProductType_ =
 371     BrowserDistribution::CHROME_BROWSER;
 372
 373 }  // namespace
 374
 375 // Test that the path to the advertised product version is found.
 376 TEST_F(FindArchiveToPatchTest, ProductVersionFound) {
 377   base::FilePath patch_source(installer::FindArchiveToPatch(
 378       *original_state_, *installer_state_));
 379   EXPECT_EQ(GetProductVersionArchivePath().value(), patch_source.value());
 380 }
 381
 382 // Test that the path to the max version is found if the advertised version is
 383 // missing.
 384 TEST_F(FindArchiveToPatchTest, MaxVersionFound) {
 385   // The patch file is absent.
 386   ASSERT_TRUE(base::DeleteFile(GetProductVersionArchivePath(), false));
 387   base::FilePath patch_source(installer::FindArchiveToPatch(
 388       *original_state_, *installer_state_));
 389   EXPECT_EQ(GetMaxVersionArchivePath().value(), patch_source.value());
 390
 391   // The product doesn't appear to be installed, so the max version is found.
 392   UninstallProduct();
 393   patch_source = installer::FindArchiveToPatch(
 394       *original_state_, *installer_state_);
 395   EXPECT_EQ(GetMaxVersionArchivePath().value(), patch_source.value());
 396 }
 397
 398 // Test that an empty path is returned if no version is found.
 399 TEST_F(FindArchiveToPatchTest, NoVersionFound) {
 400   // The product doesn't appear to be installed and no archives are present.
 401   UninstallProduct();
 402   ASSERT_TRUE(base::DeleteFile(GetProductVersionArchivePath(), false));
 403   ASSERT_TRUE(base::DeleteFile(GetMaxVersionArchivePath(), false));
 404
 405   base::FilePath patch_source(installer::FindArchiveToPatch(
 406       *original_state_, *installer_state_));
 407   EXPECT_EQ(base::FilePath::StringType(), patch_source.value());
 408 }
 409
 410 namespace {
 411
 412 class MigrateMultiToSingleTest : public testing::Test {
 413  protected:
 414   void SetUp() override {
 415     registry_override_manager_.OverrideRegistry(kRootKey);
 416   }
 417
 418   static const bool kSystemLevel = false;
 419   static const HKEY kRootKey;
 420   static const wchar_t kVersionString[];
 421   static const wchar_t kMultiChannel[];
 422   registry_util::RegistryOverrideManager registry_override_manager_;
 423 };
 424
 425 const bool MigrateMultiToSingleTest::kSystemLevel;
 426 const HKEY MigrateMultiToSingleTest::kRootKey =
 427     kSystemLevel ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 428 const wchar_t MigrateMultiToSingleTest::kVersionString[] = L"30.0.1574.0";
 429 const wchar_t MigrateMultiToSingleTest::kMultiChannel[] =
 430     L"2.0-dev-multi-chromeframe";
 431
 432 }  // namespace
 433
 434 // Test migrating Chrome Frame from multi to single.
 435 TEST_F(MigrateMultiToSingleTest, ChromeFrame) {
 436   installer::ProductState chrome_frame;
 437   installer::ProductState binaries;
 438   DWORD usagestats = 0;
 439
 440   // Set up a config with dev-channel multi-install GCF.
 441   base::win::RegKey key;
 442
 443   BrowserDistribution* dist = BrowserDistribution::GetSpecificDistribution(
 444       BrowserDistribution::CHROME_BINARIES);
 445   ASSERT_EQ(ERROR_SUCCESS,
 446             base::win::RegKey(kRootKey, dist->GetVersionKey().c_str(),
 447                               KEY_SET_VALUE)
 448                 .WriteValue(google_update::kRegVersionField, kVersionString));
 449   ASSERT_EQ(ERROR_SUCCESS,
 450             base::win::RegKey(kRootKey, dist->GetStateKey().c_str(),
 451                               KEY_SET_VALUE)
 452                 .WriteValue(google_update::kRegApField, kMultiChannel));
 453   ASSERT_EQ(ERROR_SUCCESS,
 454             base::win::RegKey(kRootKey, dist->GetStateKey().c_str(),
 455                               KEY_SET_VALUE)
 456                 .WriteValue(google_update::kRegUsageStatsField, 1U));
 457
 458   dist = BrowserDistribution::GetSpecificDistribution(
 459       BrowserDistribution::CHROME_FRAME);
 460   ASSERT_EQ(ERROR_SUCCESS,
 461             base::win::RegKey(kRootKey, dist->GetVersionKey().c_str(),
 462                               KEY_SET_VALUE)
 463                 .WriteValue(google_update::kRegVersionField, kVersionString));
 464   ASSERT_EQ(ERROR_SUCCESS,
 465             base::win::RegKey(kRootKey, dist->GetStateKey().c_str(),
 466                               KEY_SET_VALUE)
 467                 .WriteValue(google_update::kRegApField, kMultiChannel));
 468
 469   // Do the registry migration.
 470   installer::InstallationState machine_state;
 471   machine_state.Initialize();
 472
 473   installer::MigrateGoogleUpdateStateMultiToSingle(
 474       kSystemLevel,
 475       BrowserDistribution::CHROME_FRAME,
 476       machine_state);
 477
 478   // Confirm that usagestats were copied to CF and that its channel was
 479   // stripped.
 480   ASSERT_TRUE(chrome_frame.Initialize(kSystemLevel,
 481                                       BrowserDistribution::CHROME_FRAME));
 482   EXPECT_TRUE(chrome_frame.GetUsageStats(&usagestats));
 483   EXPECT_EQ(1U, usagestats);
 484   EXPECT_EQ(L"2.0-dev", chrome_frame.channel().value());
 485
 486   // Confirm that the binaries' channel no longer contains GCF.
 487   ASSERT_TRUE(binaries.Initialize(kSystemLevel,
 488                                   BrowserDistribution::CHROME_BINARIES));
 489   EXPECT_EQ(L"2.0-dev-multi", binaries.channel().value());
 490 }
 491
 492 TEST(SetupUtilTest, ContainsUnsupportedSwitch) {
 493   EXPECT_FALSE(installer::ContainsUnsupportedSwitch(
 494       base::CommandLine::FromString(L"foo.exe")));
 495   EXPECT_FALSE(installer::ContainsUnsupportedSwitch(
 496       base::CommandLine::FromString(L"foo.exe --multi-install --chrome")));
 497   EXPECT_TRUE(installer::ContainsUnsupportedSwitch(
 498       base::CommandLine::FromString(L"foo.exe --chrome-frame")));
 499 }
 500
 501 TEST(SetupUtilTest, GetRegistrationDataCommandKey) {
 502   base::string16 app_guid = L"{AAAAAAAA-BBBB-1111-0123-456789ABCDEF}";
 503   UpdatingAppRegistrationData reg_data(app_guid);
 504   base::string16 key =
 505       installer::GetRegistrationDataCommandKey(reg_data, L"test_name");
 506   EXPECT_TRUE(base::EndsWith(key, app_guid + L"\\Commands\\test_name", true));
 507 }