Force restoration of Chrome's shortcuts when Active Setup kicks in in response to a major OS upgrad…

chrome/installer/setup/setup_util_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/setup/setup_util_unittest.h"
 
 #include <windows.h>
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_util.h"
 #include "base/test/test_reg_util_win.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/version.h"
+#include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "chrome/installer/setup/setup_constants.h"
 #include "chrome/installer/setup/setup_util.h"
+#include "chrome/installer/setup/update_active_setup_version_work_item.h"
+#include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_constants.h"
+#include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/installer_state.h"
 #include "chrome/installer/util/updating_app_registration_data.h"
 #include "chrome/installer/util/util_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
-class SetupUtilTestWithDir : public testing::Test {
+class SetupUtilTest : public testing::Test {
  protected:
+  SetupUtilTest() {}
+
   void SetUp() override {
-    // Create a temp directory for testing.
     ASSERT_TRUE(test_dir_.CreateUniqueTempDir());
+    registry_override_manager_.OverrideRegistry(HKEY_CURRENT_USER);
+    registry_override_manager_.OverrideRegistry(HKEY_LOCAL_MACHINE);
   }
 
-  void TearDown() override {
-    // Clean up test directory manually so we can fail if it leaks.
-    ASSERT_TRUE(test_dir_.Delete());
-  }
+  base::ScopedTempDir test_dir_;
 
-  // The temporary directory used to contain the test operations.
-  base::ScopedTempDir test_dir_;
+ private:
+  registry_util::RegistryOverrideManager registry_override_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(SetupUtilTest);
 };
 
 // The privilege tested in ScopeTokenPrivilege tests below.
 // Use SE_RESTORE_NAME as it is one of the many privileges that is available,
 // but not enabled by default on processes running at high integrity.
 static const wchar_t kTestedPrivilege[] = SE_RESTORE_NAME;
 
 // Returns true if the current process' token has privilege |privilege_name|
 // enabled.
 bool CurrentProcessHasPrivilege(const wchar_t* privilege_name) {
@@ skipping 33 matching lines @@
     if (size == desired_size &&
         wcscmp(name_buffer.get(), privilege_name) == 0) {
       return luid_and_att.Attributes == SE_PRIVILEGE_ENABLED;
     }
   }
   return false;
 }
 
 }  // namespace
 
+TEST_F(SetupUtilTest, UpdateLastOSUpgradeHandledByActiveSetup) {
+  BrowserDistribution* chrome_dist =
+      BrowserDistribution::GetSpecificDistribution(
+          BrowserDistribution::CHROME_BROWSER);
+  const base::string16 active_setup_path(
+      InstallUtil::GetActiveSetupPath(chrome_dist));
+
+  base::win::RegKey test_key;
+  base::string16 unused_tmp;
+
+  EXPECT_EQ(ERROR_FILE_NOT_FOUND,
+            test_key.Open(HKEY_LOCAL_MACHINE, active_setup_path.c_str(),
+                          KEY_QUERY_VALUE));
+  // The WorkItem assume the ActiveSetup key itself already exists and only
+  // handles the Version entry, create it now, but don't fill the "Version"
+  // entry just yet.
+  EXPECT_EQ(ERROR_SUCCESS,
+            test_key.Create(HKEY_LOCAL_MACHINE, active_setup_path.c_str(),
+                            KEY_QUERY_VALUE));
+  EXPECT_EQ(ERROR_FILE_NOT_FOUND, test_key.ReadValue(L"Version", &unused_tmp));
+
+  // Test returns false when no Active Setup version present (and doesn't alter
+  // that state).
+  EXPECT_FALSE(
+      installer::UpdateLastOSUpgradeHandledByActiveSetup(chrome_dist));
+  EXPECT_EQ(ERROR_FILE_NOT_FOUND, test_key.ReadValue(L"Version", &unused_tmp));
+
+  {
+    UpdateActiveSetupVersionWorkItem active_setup_work_item(
+        active_setup_path, UpdateActiveSetupVersionWorkItem::UPDATE);
+    active_setup_work_item.Do();
+    EXPECT_EQ(ERROR_SUCCESS, test_key.ReadValue(L"Version", &unused_tmp));
+  }
+
+  // Test returns false with default Active Setup version.
+  EXPECT_FALSE(
+      installer::UpdateLastOSUpgradeHandledByActiveSetup(chrome_dist));
+  EXPECT_EQ(ERROR_SUCCESS, test_key.ReadValue(L"Version", &unused_tmp));
+
+  // Run through |kIterations| sequences of bumping the OS upgrade version |i|
+  // times and simulating a regular update |kIterations-i| times, confirming
+  // that handling any number of OS upgrades only results in a single hit and
+  // that no amount of regular updates after that result in any hit.
+  const size_t kIterations = 4U;
+  for (size_t i = 0U; i < kIterations; ++i) {
+    SCOPED_TRACE(i);
+    // Bump the OS_UPGRADES component |i| times.
+    for (size_t j = 0; j < i; ++j) {
+      UpdateActiveSetupVersionWorkItem active_setup_work_item(
+          active_setup_path, UpdateActiveSetupVersionWorkItem::
+                                 UPDATE_AND_BUMP_OS_UPGRADES_COMPONENT);
+      active_setup_work_item.Do();
+    }
+
+    // There should be a single OS upgrade to handle if the OS_UPGRADES
+    // component was bumped at least once.
+    EXPECT_EQ(i > 0, installer::UpdateLastOSUpgradeHandledByActiveSetup(
+                         chrome_dist));
+
+    // We should only be told to handle the latest OS upgrade once above.
+    EXPECT_FALSE(
+        installer::UpdateLastOSUpgradeHandledByActiveSetup(chrome_dist));
+    EXPECT_FALSE(
+        installer::UpdateLastOSUpgradeHandledByActiveSetup(chrome_dist));
+
+    // Run |kIterations-i| regular updates.
+    for (size_t j = i; j < kIterations; ++j) {
+      UpdateActiveSetupVersionWorkItem active_setup_work_item(
+          active_setup_path, UpdateActiveSetupVersionWorkItem::UPDATE);
+      active_setup_work_item.Do();
+    }
+
+    // No amount of regular updates should trigger an OS upgrade to be handled.
+    EXPECT_FALSE(
+        installer::UpdateLastOSUpgradeHandledByActiveSetup(chrome_dist));
+    EXPECT_FALSE(
+        installer::UpdateLastOSUpgradeHandledByActiveSetup(chrome_dist));
+  }
+}
+
 // Test that we are parsing Chrome version correctly.
-TEST_F(SetupUtilTestWithDir, GetMaxVersionFromArchiveDirTest) {
+TEST_F(SetupUtilTest, GetMaxVersionFromArchiveDirTest) {
   // Create a version dir
   base::FilePath chrome_dir = test_dir_.path().AppendASCII("1.0.0.0");
   base::CreateDirectory(chrome_dir);
   ASSERT_TRUE(base::PathExists(chrome_dir));
   scoped_ptr<Version> version(
       installer::GetMaxVersionFromArchiveDir(test_dir_.path()));
   ASSERT_EQ(version->GetString(), "1.0.0.0");
 
   base::DeleteFile(chrome_dir, true);
   ASSERT_FALSE(base::PathExists(chrome_dir));
@@ skipping 15 matching lines @@
   base::CreateDirectory(chrome_dir);
   ASSERT_TRUE(base::PathExists(chrome_dir));
   chrome_dir = test_dir_.path().AppendASCII("1.1.1.1");
   base::CreateDirectory(chrome_dir);
   ASSERT_TRUE(base::PathExists(chrome_dir));
 
   version.reset(installer::GetMaxVersionFromArchiveDir(test_dir_.path()));
   ASSERT_EQ(version->GetString(), "9.9.9.9");
 }
 
-TEST_F(SetupUtilTestWithDir, DeleteFileFromTempProcess) {
+TEST_F(SetupUtilTest, DeleteFileFromTempProcess) {
   base::FilePath test_file;
   base::CreateTemporaryFileInDir(test_dir_.path(), &test_file);
   ASSERT_TRUE(base::PathExists(test_file));
   base::WriteFile(test_file, "foo", 3);
   EXPECT_TRUE(installer::DeleteFileFromTempProcess(test_file, 0));
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
   EXPECT_FALSE(base::PathExists(test_file));
 }
 
 // Note: This test is only valid when run at high integrity (i.e. it will fail
@@ skipping 109 matching lines @@
   if (base::win::GetVersion() > base::win::VERSION_SERVER_2003)
     EXPECT_EQ(PCCR_CHANGED, RelaunchAndDoProcessPriorityAdjustment());
   else
     EXPECT_EQ(PCCR_UNCHANGED, RelaunchAndDoProcessPriorityAdjustment());
 }
 
 namespace {
 
 // A test fixture that configures an InstallationState and an InstallerState
 // with a product being updated.
-class FindArchiveToPatchTest : public SetupUtilTestWithDir {
+class FindArchiveToPatchTest : public SetupUtilTest {
  protected:
   class FakeInstallationState : public installer::InstallationState {
   };
 
   class FakeProductState : public installer::ProductState {
    public:
     static FakeProductState* FromProductState(const ProductState* product) {
       return static_cast<FakeProductState*>(const_cast<ProductState*>(product));
     }
 
     void set_version(const Version& version) {
       if (version.IsValid())
         version_.reset(new Version(version));
       else
         version_.reset();
     }
 
     void set_uninstall_command(const base::CommandLine& uninstall_command) {
       uninstall_command_ = uninstall_command;
     }
   };
 
   void SetUp() override {
-    SetupUtilTestWithDir::SetUp();
+    SetupUtilTest::SetUp();
     product_version_ = Version("30.0.1559.0");
     max_version_ = Version("47.0.1559.0");
 
     // Install the product according to the version.
     original_state_.reset(new FakeInstallationState());
     InstallProduct();
 
     // Prepare to update the product in the temp dir.
     installer_state_.reset(new installer::InstallerState(
         kSystemInstall_ ? installer::InstallerState::SYSTEM_LEVEL :
         installer::InstallerState::USER_LEVEL));
     installer_state_->AddProductFromState(
         kProductType_,
         *original_state_->GetProductState(kSystemInstall_, kProductType_));
 
     // Create archives in the two version dirs.
     ASSERT_TRUE(
         base::CreateDirectory(GetProductVersionArchivePath().DirName()));
     ASSERT_EQ(1, base::WriteFile(GetProductVersionArchivePath(), "a", 1));
     ASSERT_TRUE(
         base::CreateDirectory(GetMaxVersionArchivePath().DirName()));
     ASSERT_EQ(1, base::WriteFile(GetMaxVersionArchivePath(), "b", 1));
   }
 
   void TearDown() override {
     original_state_.reset();
-    SetupUtilTestWithDir::TearDown();
+    SetupUtilTest::TearDown();
   }
 
   base::FilePath GetArchivePath(const Version& version) const {
     return test_dir_.path()
         .AppendASCII(version.GetString())
         .Append(installer::kInstallerDir)
         .Append(installer::kChromeArchive);
   }
 
   base::FilePath GetMaxVersionArchivePath() const {
@@ skipping 95 matching lines @@
 class MigrateMultiToSingleTest : public testing::Test {
  protected:
   void SetUp() override {
     registry_override_manager_.OverrideRegistry(kRootKey);
   }
 
   static const bool kSystemLevel = false;
   static const HKEY kRootKey;
   static const wchar_t kVersionString[];
   static const wchar_t kMultiChannel[];
+
+ private:
   registry_util::RegistryOverrideManager registry_override_manager_;
 };
 
 const bool MigrateMultiToSingleTest::kSystemLevel;
 const HKEY MigrateMultiToSingleTest::kRootKey =
     kSystemLevel ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 const wchar_t MigrateMultiToSingleTest::kVersionString[] = L"30.0.1574.0";
 const wchar_t MigrateMultiToSingleTest::kMultiChannel[] =
     L"2.0-dev-multi-chromeframe";
 
@@ skipping 66 matching lines @@
       base::CommandLine::FromString(L"foo.exe --chrome-frame")));
 }
 
 TEST(SetupUtilTest, GetRegistrationDataCommandKey) {
   base::string16 app_guid = L"{AAAAAAAA-BBBB-1111-0123-456789ABCDEF}";
   UpdatingAppRegistrationData reg_data(app_guid);
   base::string16 key =
       installer::GetRegistrationDataCommandKey(reg_data, L"test_name");
   EXPECT_TRUE(base::EndsWith(key, app_guid + L"\\Commands\\test_name", true));
 }