Clean up unused param in RegistryOverrideManager

chrome/installer/util/install_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 <string>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/strings/string_util.h"
@@ skipping 64 matching lines @@
 }
 
 TEST_F(InstallUtilTest, UpdateInstallerStageAP) {
   const bool system_level = false;
   const HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   std::wstring state_key_path(L"PhonyClientState");
 
   // Update the stage when there's no "ap" value.
   {
     RegistryOverrideManager override_manager;
-    override_manager.OverrideRegistry(root, L"root_inst_res");
+    override_manager.OverrideRegistry(root);
     RegKey(root, state_key_path.c_str(), KEY_SET_VALUE);
     InstallUtil::UpdateInstallerStage(system_level, state_key_path,
                                       installer::BUILDING);
     std::wstring value;
     EXPECT_EQ(ERROR_SUCCESS,
               RegKey(root, state_key_path.c_str(), KEY_QUERY_VALUE)
                   .ReadValue(google_update::kRegApField, &value));
     EXPECT_EQ(L"-stage:building", value);
   }
 
   // Update the stage when there is an "ap" value.
   {
     RegistryOverrideManager override_manager;
-    override_manager.OverrideRegistry(root, L"root_inst_res");
+    override_manager.OverrideRegistry(root);
     RegKey(root, state_key_path.c_str(), KEY_SET_VALUE)
         .WriteValue(google_update::kRegApField, L"2.0-dev");
     InstallUtil::UpdateInstallerStage(system_level, state_key_path,
                                       installer::BUILDING);
     std::wstring value;
     EXPECT_EQ(ERROR_SUCCESS,
               RegKey(root, state_key_path.c_str(), KEY_QUERY_VALUE)
                   .ReadValue(google_update::kRegApField, &value));
     EXPECT_EQ(L"2.0-dev-stage:building", value);
   }
 
   // Clear the stage.
   {
     RegistryOverrideManager override_manager;
-    override_manager.OverrideRegistry(root, L"root_inst_res");
+    override_manager.OverrideRegistry(root);
     RegKey(root, state_key_path.c_str(), KEY_SET_VALUE)
       .WriteValue(google_update::kRegApField, L"2.0-dev-stage:building");
     InstallUtil::UpdateInstallerStage(system_level, state_key_path,
                                       installer::NO_STAGE);
     std::wstring value;
     EXPECT_EQ(ERROR_SUCCESS,
               RegKey(root, state_key_path.c_str(), KEY_QUERY_VALUE)
                   .ReadValue(google_update::kRegApField, &value));
     EXPECT_EQ(L"2.0-dev", value);
   }
 }
 
 TEST_F(InstallUtilTest, UpdateInstallerStage) {
   const bool system_level = false;
   const HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   std::wstring state_key_path(L"PhonyClientState");
 
   // Update the stage when there's no "InstallerExtraCode1" value.
   {
     RegistryOverrideManager override_manager;
-    override_manager.OverrideRegistry(root, L"root_inst_res");
+    override_manager.OverrideRegistry(root);
     RegKey(root, state_key_path.c_str(), KEY_SET_VALUE)
         .DeleteValue(installer::kInstallerExtraCode1);
     InstallUtil::UpdateInstallerStage(system_level, state_key_path,
                                       installer::BUILDING);
     DWORD value;
     EXPECT_EQ(ERROR_SUCCESS,
               RegKey(root, state_key_path.c_str(), KEY_QUERY_VALUE)
                   .ReadValueDW(installer::kInstallerExtraCode1, &value));
     EXPECT_EQ(static_cast<DWORD>(installer::BUILDING), value);
   }
 
   // Update the stage when there is an "InstallerExtraCode1" value.
   {
     RegistryOverrideManager override_manager;
-    override_manager.OverrideRegistry(root, L"root_inst_res");
+    override_manager.OverrideRegistry(root);
     RegKey(root, state_key_path.c_str(), KEY_SET_VALUE)
         .WriteValue(installer::kInstallerExtraCode1,
                     static_cast<DWORD>(installer::UNPACKING));
     InstallUtil::UpdateInstallerStage(system_level, state_key_path,
                                       installer::BUILDING);
     DWORD value;
     EXPECT_EQ(ERROR_SUCCESS,
               RegKey(root, state_key_path.c_str(), KEY_QUERY_VALUE)
                   .ReadValueDW(installer::kInstallerExtraCode1, &value));
     EXPECT_EQ(static_cast<DWORD>(installer::BUILDING), value);
   }
 
   // Clear the stage.
   {
     RegistryOverrideManager override_manager;
-    override_manager.OverrideRegistry(root, L"root_inst_res");
+    override_manager.OverrideRegistry(root);
     RegKey(root, state_key_path.c_str(), KEY_SET_VALUE)
         .WriteValue(installer::kInstallerExtraCode1, static_cast<DWORD>(5));
     InstallUtil::UpdateInstallerStage(system_level, state_key_path,
                                       installer::NO_STAGE);
     DWORD value;
     EXPECT_EQ(ERROR_FILE_NOT_FOUND,
               RegKey(root, state_key_path.c_str(), KEY_QUERY_VALUE)
                   .ReadValueDW(installer::kInstallerExtraCode1, &value));
   }
 }
 
 TEST_F(InstallUtilTest, DeleteRegistryKeyIf) {
   const HKEY root = HKEY_CURRENT_USER;
   std::wstring parent_key_path(L"SomeKey\\ToDelete");
   std::wstring child_key_path(parent_key_path);
   child_key_path.append(L"\\ChildKey\\WithAValue");
   const wchar_t value_name[] = L"some_value_name";
   const wchar_t value[] = L"hi mom";
 
   {
     RegistryOverrideManager override_manager;
-    override_manager.OverrideRegistry(root, L"root_key");
+    override_manager.OverrideRegistry(root);
     // Nothing to delete if the keys aren't even there.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(_)).Times(0);
       ASSERT_FALSE(RegKey(root, parent_key_path.c_str(),
                           KEY_QUERY_VALUE).Valid());
       EXPECT_EQ(InstallUtil::NOT_FOUND,
                 InstallUtil::DeleteRegistryKeyIf(root, parent_key_path,
                                                  child_key_path,
@@ skipping 87 matching lines @@
 }
 
 TEST_F(InstallUtilTest, DeleteRegistryValueIf) {
   const HKEY root = HKEY_CURRENT_USER;
   std::wstring key_path(L"SomeKey\\ToDelete");
   const wchar_t value_name[] = L"some_value_name";
   const wchar_t value[] = L"hi mom";
 
   {
     RegistryOverrideManager override_manager;
-    override_manager.OverrideRegistry(root, L"root_key");
+    override_manager.OverrideRegistry(root);
     // Nothing to delete if the key isn't even there.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(_)).Times(0);
       ASSERT_FALSE(RegKey(root, key_path.c_str(), KEY_QUERY_VALUE).Valid());
       EXPECT_EQ(InstallUtil::NOT_FOUND,
                 InstallUtil::DeleteRegistryValueIf(root, key_path.c_str(),
                                                    WorkItem::kWow64Default,
                                                    value_name, pred));
@@ skipping 43 matching lines @@
                                                    WorkItem::kWow64Default,
                                                    value_name, pred));
       EXPECT_TRUE(RegKey(root, key_path.c_str(), KEY_QUERY_VALUE).Valid());
       EXPECT_FALSE(RegKey(root, key_path.c_str(),
                           KEY_QUERY_VALUE).HasValue(value_name));
     }
   }
 
   {
     RegistryOverrideManager override_manager;
-    override_manager.OverrideRegistry(root, L"root_key");
+    override_manager.OverrideRegistry(root);
     // Default value matches: delete using empty string.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(StrEq(value))).WillOnce(Return(true));
       ASSERT_EQ(ERROR_SUCCESS,
                 RegKey(root, key_path.c_str(),
                        KEY_SET_VALUE).WriteValue(L"", value));
       EXPECT_EQ(InstallUtil::DELETED,
                 InstallUtil::DeleteRegistryValueIf(root, key_path.c_str(),
                                                    WorkItem::kWow64Default, L"",
                                                    pred));
       EXPECT_TRUE(RegKey(root, key_path.c_str(), KEY_QUERY_VALUE).Valid());
       EXPECT_FALSE(RegKey(root, key_path.c_str(),
                           KEY_QUERY_VALUE).HasValue(L""));
     }
   }
 
   {
     RegistryOverrideManager override_manager;
-    override_manager.OverrideRegistry(root, L"root_key");
+    override_manager.OverrideRegistry(root);
     // Default value matches: delete using NULL.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(StrEq(value))).WillOnce(Return(true));
       ASSERT_EQ(ERROR_SUCCESS,
                 RegKey(root, key_path.c_str(),
                        KEY_SET_VALUE).WriteValue(L"", value));
       EXPECT_EQ(InstallUtil::DELETED,
                 InstallUtil::DeleteRegistryValueIf(root, key_path.c_str(),
@@ skipping 55 matching lines @@
                                      WriteInto(&short_expect, MAX_PATH),
                                      MAX_PATH);
   ASSERT_NE(static_cast<DWORD>(0), short_len);
   ASSERT_GT(static_cast<DWORD>(MAX_PATH), short_len);
   short_expect.resize(short_len);
   ASSERT_FALSE(base::FilePath::CompareEqualIgnoreCase(expect.value(),
                                                       short_expect));
   EXPECT_TRUE(InstallUtil::ProgramCompare(expect).Evaluate(
       L"\"" + short_expect + L"\""));
 }