Tommi: I need an owner review for the chrome frame changes.

chrome/installer/util/installer_state_unittest.cc

 // Copyright (c) 2011 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 <windows.h>
 
 #include <fstream>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string_util.h"
+#include "base/test/test_reg_util_win.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/installer/util/fake_installation_state.h"
 #include "chrome/installer/util/fake_product_state.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/installer_state.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/product_unittest.h"
 #include "chrome/installer/util/work_item.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "installer_util_strings.h"  // NOLINT
 
 using base::win::RegKey;
 using installer::InstallationState;
 using installer::InstallerState;
 using installer::MasterPreferences;
+using registry_util::RegistryOverrideManager;
 
 class InstallerStateTest : public TestWithTempDirAndDeleteTempOverrideKeys {
  protected:
 };
 
 // An installer state on which we can tweak the target path.
 class MockInstallerState : public InstallerState {
  public:
   MockInstallerState() : InstallerState() { }
   void set_target_path(const FilePath& target_path) {
@@ skipping 288 matching lines @@
   installer_state.set_target_path(test_dir_.path());
   EXPECT_EQ(1U, installer_state.products().size());
   EXPECT_EQ(system_level, installer_state.system_install());
 
   const char kCurrentVersion[] = "1.2.3.4";
   scoped_ptr<Version> current_version(
       Version::GetVersionFromString(kCurrentVersion));
 
   HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   EXPECT_EQ(root, installer_state.root_key());
+
   {
-    TempRegKeyOverride override(root, L"root_pit");
+    RegistryOverrideManager override_manager;
+    override_manager.OverrideRegistry(root, L"root_pit");
     BrowserDistribution* dist = BrowserDistribution::GetSpecificDistribution(
         BrowserDistribution::CHROME_BROWSER);
     RegKey chrome_key(root, dist->GetVersionKey().c_str(), KEY_ALL_ACCESS);
     EXPECT_TRUE(chrome_key.Valid());
     if (chrome_key.Valid()) {
       chrome_key.WriteValue(google_update::kRegVersionField,
                             UTF8ToWide(current_version->GetString()).c_str());
       machine_state.Initialize();
       // TODO(tommi): Also test for when there exists a new_chrome.exe.
       scoped_ptr<Version> found_version(installer_state.GetCurrentVersion(
@@ skipping 11 matching lines @@
   bool multi_install = false;
   HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 
   RegKey key;
   std::wstring launch_cmd = L"hey diddle diddle";
   std::wstring value;
   DWORD dw_value;
 
   // check results for a fresh install of single Chrome
   {
-    TempRegKeyOverride override(root, L"root_inst_res");
+    RegistryOverrideManager override_manager;
+    override_manager.OverrideRegistry(root, L"root_inst_res");
     CommandLine cmd_line = CommandLine::FromString(L"setup.exe --system-level");
     const MasterPreferences prefs(cmd_line);
     InstallationState machine_state;
     machine_state.Initialize();
     InstallerState state;
     state.Initialize(cmd_line, prefs, machine_state);
     state.WriteInstallerResult(installer::FIRST_INSTALL_SUCCESS,
                                IDS_INSTALL_OS_ERROR_BASE, &launch_cmd);
     BrowserDistribution* distribution =
         BrowserDistribution::GetSpecificDistribution(
             BrowserDistribution::CHROME_BROWSER);
     EXPECT_EQ(ERROR_SUCCESS,
         key.Open(root, distribution->GetStateKey().c_str(), KEY_READ));
     EXPECT_EQ(ERROR_SUCCESS,
         key.ReadValueDW(installer::kInstallerResult, &dw_value));
     EXPECT_EQ(static_cast<DWORD>(0), dw_value);
     EXPECT_EQ(ERROR_SUCCESS,
         key.ReadValueDW(installer::kInstallerError, &dw_value));
     EXPECT_EQ(static_cast<DWORD>(installer::FIRST_INSTALL_SUCCESS), dw_value);
     EXPECT_EQ(ERROR_SUCCESS,
         key.ReadValue(installer::kInstallerResultUIString, &value));
     EXPECT_FALSE(value.empty());
     EXPECT_EQ(ERROR_SUCCESS,
         key.ReadValue(installer::kInstallerSuccessLaunchCmdLine, &value));
     EXPECT_EQ(launch_cmd, value);
   }
-  TempRegKeyOverride::DeleteAllTempKeys();
 
   // check results for a fresh install of multi Chrome
   {
-    TempRegKeyOverride override(root, L"root_inst_res");
+    RegistryOverrideManager override_manager;
+    override_manager.OverrideRegistry(root, L"root_inst_res");
     CommandLine cmd_line = CommandLine::FromString(
         L"setup.exe --system-level --multi-install --chrome");
     const MasterPreferences prefs(cmd_line);
     InstallationState machine_state;
     machine_state.Initialize();
     InstallerState state;
     state.Initialize(cmd_line, prefs, machine_state);
     state.WriteInstallerResult(installer::FIRST_INSTALL_SUCCESS, 0,
                                &launch_cmd);
     BrowserDistribution* distribution =
         BrowserDistribution::GetSpecificDistribution(
             BrowserDistribution::CHROME_BROWSER);
     BrowserDistribution* binaries =
         BrowserDistribution::GetSpecificDistribution(
             BrowserDistribution::CHROME_BINARIES);
     EXPECT_EQ(ERROR_SUCCESS,
         key.Open(root, distribution->GetStateKey().c_str(), KEY_READ));
     EXPECT_EQ(ERROR_SUCCESS,
         key.ReadValue(installer::kInstallerSuccessLaunchCmdLine, &value));
     EXPECT_EQ(launch_cmd, value);
     EXPECT_EQ(ERROR_SUCCESS,
         key.Open(root, binaries->GetStateKey().c_str(), KEY_READ));
     EXPECT_EQ(ERROR_SUCCESS,
         key.ReadValue(installer::kInstallerSuccessLaunchCmdLine, &value));
     EXPECT_EQ(launch_cmd, value);
     key.Close();
   }
-  TempRegKeyOverride::DeleteAllTempKeys();
 }
 
 // Test GetCurrentVersion when migrating single Chrome to multi
 TEST_F(InstallerStateTest, GetCurrentVersionMigrateChrome) {
   using installer::FakeInstallationState;
 
   const bool system_install = false;
   FakeInstallationState machine_state;
 
   // Pretend that this version of single-install Chrome is already installed.
@@ skipping 31 matching lines @@
                    NULL, OPEN_EXISTING, 0, 0));
     ASSERT_TRUE(temp_handle != NULL);
 
     // The file should now be in use.
     EXPECT_TRUE(MockInstallerState::IsFileInUse(temp_file));
   }
 
   // And once the handle is gone, it should no longer be in use.
   EXPECT_FALSE(MockInstallerState::IsFileInUse(temp_file));
 }