Make nt_registry Create/OpenRegKey return a scoped object

chrome_elf/nt_registry/nt_registry_unittest.cc

 // Copyright 2016 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_elf/nt_registry/nt_registry.h"
 
 #include <windows.h>
 #include <rpc.h>
 #include <stddef.h>
 
@@ skipping 13 matching lines @@
 // https://cs.chromium.org/chromium/src/build/toolchain/win/BUILD.gn?sq%3Dpackage:chromium&l=314
 //------------------------------------------------------------------------------
 
 // Utility function for the WOW64 redirection test suites.
 // Note: Testing redirection through ADVAPI32 here as well, to get notice if
 //       expected behaviour changes!
 // If |redirected_path| == nullptr, no redirection is expected in any case.
 void DoRedirectTest(nt::ROOT_KEY nt_root_key,
                     const wchar_t* path,
                     const wchar_t* redirected_path OPTIONAL) {
-  HANDLE handle = INVALID_HANDLE_VALUE;
   HKEY key_handle = nullptr;
   constexpr ACCESS_MASK kAccess = KEY_WRITE | DELETE;
   const HKEY root_key =
       (nt_root_key == nt::HKCU) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
 
   // Make sure clean before starting.
   nt::DeleteRegKey(nt_root_key, nt::NONE, path);
   if (redirected_path)
     nt::DeleteRegKey(nt_root_key, nt::NONE, redirected_path);
 
   //----------------------------------------------------------------------------
   // No redirection through ADVAPI32 on straight x86 or x64.
   ASSERT_EQ(ERROR_SUCCESS,
             RegCreateKeyExW(root_key, path, 0, nullptr, REG_OPTION_NON_VOLATILE,
                             kAccess, nullptr, &key_handle, nullptr));
   ASSERT_EQ(ERROR_SUCCESS, RegCloseKey(key_handle));
-  ASSERT_TRUE(nt::OpenRegKey(nt_root_key, path, kAccess, &handle, nullptr));
-  ASSERT_TRUE(nt::DeleteRegKey(handle));
-  nt::CloseRegKey(handle);
+  {
+    nt::ScopedHANDLE handle(
+        nt::OpenRegKey(nt_root_key, path, kAccess, nullptr));
+    ASSERT_TRUE(handle.is_valid());
+    ASSERT_TRUE(nt::DeleteRegKey(handle.get()));
+  }
 
 #ifdef _WIN64
   //----------------------------------------------------------------------------
   // Try forcing WOW64 redirection on x64 through ADVAPI32.
   ASSERT_EQ(ERROR_SUCCESS,
             RegCreateKeyExW(root_key, path, 0, nullptr, REG_OPTION_NON_VOLATILE,
                             kAccess | KEY_WOW64_32KEY, nullptr, &key_handle,
                             nullptr));
   ASSERT_EQ(ERROR_SUCCESS, RegCloseKey(key_handle));
   // Check path:
-  if (nt::OpenRegKey(nt_root_key, path, kAccess, &handle, nullptr)) {
-    if (redirected_path)
+  {
+    nt::ScopedHANDLE handle(
+        nt::OpenRegKey(nt_root_key, path, kAccess, nullptr));
+    if (handle.is_valid()) {
+      if (redirected_path)
+        ADD_FAILURE();
+      ASSERT_TRUE(nt::DeleteRegKey(handle.get()));
+    } else if (!redirected_path) {
+      // Should have succeeded.
       ADD_FAILURE();
-    ASSERT_TRUE(nt::DeleteRegKey(handle));
-    nt::CloseRegKey(handle);
-  } else if (!redirected_path) {
-    // Should have succeeded.
-    ADD_FAILURE();
+    }
   }
   if (redirected_path) {
     // Check redirected path:
-    if (nt::OpenRegKey(nt_root_key, redirected_path, kAccess, &handle,
-                       nullptr)) {
+    nt::ScopedHANDLE handle(
+        nt::OpenRegKey(nt_root_key, redirected_path, kAccess, nullptr));
+    if (handle.is_valid()) {
       if (!redirected_path)
         ADD_FAILURE();
-      ASSERT_TRUE(nt::DeleteRegKey(handle));
-      nt::CloseRegKey(handle);
+      ASSERT_TRUE(nt::DeleteRegKey(handle.get()));
     } else {
       // Should have succeeded.
       ADD_FAILURE();
     }
   }
 
   //----------------------------------------------------------------------------
   // Try forcing WOW64 redirection on x64 through NTDLL.
-  ASSERT_TRUE(
-      nt::CreateRegKey(nt_root_key, path, kAccess | KEY_WOW64_32KEY, nullptr));
+  ASSERT_TRUE(nt::CreateRegKey(nt_root_key, path, kAccess | KEY_WOW64_32KEY)
+                  .is_valid());
   // Check path:
-  if (nt::OpenRegKey(nt_root_key, path, kAccess, &handle, nullptr)) {
-    if (redirected_path)
+  {
+    nt::ScopedHANDLE handle(
+        nt::OpenRegKey(nt_root_key, path, kAccess, nullptr));
+    if (handle.is_valid()) {
+      if (redirected_path)
+        ADD_FAILURE();
+      ASSERT_TRUE(nt::DeleteRegKey(handle.get()));
+    } else if (!redirected_path) {
+      // Should have succeeded.
       ADD_FAILURE();
-    ASSERT_TRUE(nt::DeleteRegKey(handle));
-    nt::CloseRegKey(handle);
-  } else if (!redirected_path) {
-    // Should have succeeded.
-    ADD_FAILURE();
+    }
   }
   if (redirected_path) {
     // Check redirected path:
-    if (nt::OpenRegKey(nt_root_key, redirected_path, kAccess, &handle,
-                       nullptr)) {
+    nt::ScopedHANDLE handle(
+        nt::OpenRegKey(nt_root_key, redirected_path, kAccess, nullptr));
+    if (handle.is_valid()) {
       if (!redirected_path)
         ADD_FAILURE();
-      ASSERT_TRUE(nt::DeleteRegKey(handle));
-      nt::CloseRegKey(handle);
+      ASSERT_TRUE(nt::DeleteRegKey(handle.get()));
     } else {
       // Should have succeeded.
       ADD_FAILURE();
     }
   }
 #endif  // _WIN64
 }
 
 // These test reg paths match |kClassesSubtree| in nt_registry.cc.
 constexpr const wchar_t* kClassesRedirects[] = {
@@ skipping 189 matching lines @@
 
  private:
   registry_util::RegistryOverrideManager override_manager_;
 };
 
 //------------------------------------------------------------------------------
 // NT registry API tests
 //------------------------------------------------------------------------------
 
 TEST_F(NtRegistryTest, API_DWORD) {
-  HANDLE key_handle;
   const wchar_t* dword_val_name = L"DwordTestValue";
   DWORD dword_val = 1234;
 
   // Create a subkey to play under.
-  ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, L"NTRegistry\\dword", KEY_ALL_ACCESS,
-                               &key_handle));
-  ASSERT_NE(key_handle, INVALID_HANDLE_VALUE);
-  ASSERT_NE(key_handle, nullptr);
+  nt::ScopedHANDLE key_handle(
+      nt::CreateRegKey(nt::HKCU, L"NTRegistry\\dword", KEY_ALL_ACCESS));
+  ASSERT_TRUE(key_handle.is_valid());
+  ASSERT_NE(key_handle.get(), nullptr);
 
   DWORD get_dword = 0;
-  EXPECT_FALSE(nt::QueryRegValueDWORD(key_handle, dword_val_name, &get_dword));
+  EXPECT_FALSE(
+      nt::QueryRegValueDWORD(key_handle.get(), dword_val_name, &get_dword));
 
   // Set
-  EXPECT_TRUE(nt::SetRegValueDWORD(key_handle, dword_val_name, dword_val));
+  EXPECT_TRUE(
+      nt::SetRegValueDWORD(key_handle.get(), dword_val_name, dword_val));
 
   // Get
-  EXPECT_TRUE(nt::QueryRegValueDWORD(key_handle, dword_val_name, &get_dword));
+  EXPECT_TRUE(
+      nt::QueryRegValueDWORD(key_handle.get(), dword_val_name, &get_dword));
   EXPECT_TRUE(get_dword == dword_val);
 
   // Clean up
-  EXPECT_TRUE(nt::DeleteRegKey(key_handle));
-  nt::CloseRegKey(key_handle);
+  EXPECT_TRUE(nt::DeleteRegKey(key_handle.get()));
 }
 
 TEST_F(NtRegistryTest, API_SZ) {
-  HANDLE key_handle;
   const wchar_t* sz_val_name = L"SzTestValue";
   std::wstring sz_val = L"blah de blah de blahhhhh.";
   const wchar_t* sz_val_name2 = L"SzTestValueEmpty";
   std::wstring sz_val2 = L"";
 
   // Create a subkey to play under.
-  ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, L"NTRegistry\\sz", KEY_ALL_ACCESS,
-                               &key_handle));
-  ASSERT_NE(key_handle, INVALID_HANDLE_VALUE);
-  ASSERT_NE(key_handle, nullptr);
+  nt::ScopedHANDLE key_handle(
+      nt::CreateRegKey(nt::HKCU, L"NTRegistry\\sz", KEY_ALL_ACCESS));
+  ASSERT_TRUE(key_handle.is_valid());
+  ASSERT_NE(key_handle.get(), nullptr);
 
   std::wstring get_sz;
-  EXPECT_FALSE(nt::QueryRegValueSZ(key_handle, sz_val_name, &get_sz));
+  EXPECT_FALSE(nt::QueryRegValueSZ(key_handle.get(), sz_val_name, &get_sz));
 
   // Set
-  EXPECT_TRUE(nt::SetRegValueSZ(key_handle, sz_val_name, sz_val));
-  EXPECT_TRUE(nt::SetRegValueSZ(key_handle, sz_val_name2, sz_val2));
+  EXPECT_TRUE(nt::SetRegValueSZ(key_handle.get(), sz_val_name, sz_val));
+  EXPECT_TRUE(nt::SetRegValueSZ(key_handle.get(), sz_val_name2, sz_val2));
 
   // Get
-  EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name, &get_sz));
+  EXPECT_TRUE(nt::QueryRegValueSZ(key_handle.get(), sz_val_name, &get_sz));
   EXPECT_TRUE(get_sz.compare(sz_val) == 0);
-  EXPECT_TRUE(nt::QueryRegValueSZ(key_handle, sz_val_name2, &get_sz));
+  EXPECT_TRUE(nt::QueryRegValueSZ(key_handle.get(), sz_val_name2, &get_sz));
   EXPECT_TRUE(get_sz.compare(sz_val2) == 0);
 
   // Clean up
-  EXPECT_TRUE(nt::DeleteRegKey(key_handle));
-  nt::CloseRegKey(key_handle);
+  EXPECT_TRUE(nt::DeleteRegKey(key_handle.get()));
 }
 
 TEST_F(NtRegistryTest, API_MULTISZ) {
-  HANDLE key_handle;
   const wchar_t* multisz_val_name = L"SzmultiTestValue";
   std::vector<std::wstring> multisz_val;
   std::wstring multi1 = L"one";
   std::wstring multi2 = L"two";
   std::wstring multi3 = L"three";
   const wchar_t* multisz_val_name2 = L"SzmultiTestValueBad";
   std::wstring multi_empty = L"";
 
   // Create a subkey to play under.
-  ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, L"NTRegistry\\multisz", KEY_ALL_ACCESS,
-                               &key_handle));
-  ASSERT_NE(key_handle, INVALID_HANDLE_VALUE);
-  ASSERT_NE(key_handle, nullptr);
+  nt::ScopedHANDLE key_handle(
+      nt::CreateRegKey(nt::HKCU, L"NTRegistry\\multisz", KEY_ALL_ACCESS));
+  ASSERT_TRUE(key_handle.is_valid());
+  ASSERT_NE(key_handle.get(), nullptr);
 
   multisz_val.push_back(multi1);
   multisz_val.push_back(multi2);
   multisz_val.push_back(multi3);
   // Set
   EXPECT_TRUE(
-      nt::SetRegValueMULTISZ(key_handle, multisz_val_name, multisz_val));
+      nt::SetRegValueMULTISZ(key_handle.get(), multisz_val_name, multisz_val));
   multisz_val.clear();
   multisz_val.push_back(multi_empty);
   // Set
   EXPECT_TRUE(
-      nt::SetRegValueMULTISZ(key_handle, multisz_val_name2, multisz_val));
+      nt::SetRegValueMULTISZ(key_handle.get(), multisz_val_name2, multisz_val));
   multisz_val.clear();
 
   // Get
-  EXPECT_TRUE(
-      nt::QueryRegValueMULTISZ(key_handle, multisz_val_name, &multisz_val));
+  EXPECT_TRUE(nt::QueryRegValueMULTISZ(key_handle.get(), multisz_val_name,
+                                       &multisz_val));
   if (multisz_val.size() == 3) {
     EXPECT_TRUE(multi1.compare(multisz_val.at(0)) == 0);
     EXPECT_TRUE(multi2.compare(multisz_val.at(1)) == 0);
     EXPECT_TRUE(multi3.compare(multisz_val.at(2)) == 0);
   } else {
     EXPECT_TRUE(false);
   }
   multisz_val.clear();
 
   // Get
-  EXPECT_TRUE(
-      nt::QueryRegValueMULTISZ(key_handle, multisz_val_name2, &multisz_val));
+  EXPECT_TRUE(nt::QueryRegValueMULTISZ(key_handle.get(), multisz_val_name2,
+                                       &multisz_val));
   if (multisz_val.size() == 1) {
     EXPECT_TRUE(multi_empty.compare(multisz_val.at(0)) == 0);
   } else {
     EXPECT_TRUE(false);
   }
   multisz_val.clear();
 
   // Clean up
-  EXPECT_TRUE(nt::DeleteRegKey(key_handle));
-  nt::CloseRegKey(key_handle);
+  EXPECT_TRUE(nt::DeleteRegKey(key_handle.get()));
 }
 
 TEST_F(NtRegistryTest, CreateRegKeyRecursion) {
-  HANDLE key_handle;
   const wchar_t* sz_new_key_1 = L"test1\\new\\subkey";
   const wchar_t* sz_new_key_2 = L"test2\\new\\subkey\\blah\\";
   const wchar_t* sz_new_key_3 = L"\\test3\\new\\subkey\\\\blah2";
 
   // Tests for CreateRegKey recursion.
-  ASSERT_TRUE(
-      nt::CreateRegKey(nt::HKCU, sz_new_key_1, KEY_ALL_ACCESS, nullptr));
-  EXPECT_TRUE(nt::OpenRegKey(nt::HKCU, sz_new_key_1, KEY_ALL_ACCESS,
-                             &key_handle, nullptr));
-  EXPECT_TRUE(nt::DeleteRegKey(key_handle));
-  nt::CloseRegKey(key_handle);
+  {
+    nt::ScopedHANDLE create_handle(
+        nt::CreateRegKey(nt::HKCU, sz_new_key_1, KEY_ALL_ACCESS));
+    ASSERT_TRUE(create_handle.is_valid());
+  }
+  {
+    nt::ScopedHANDLE key_handle(
+        nt::OpenRegKey(nt::HKCU, sz_new_key_1, KEY_ALL_ACCESS, nullptr));
+    EXPECT_TRUE(key_handle.is_valid());
+    EXPECT_TRUE(nt::DeleteRegKey(key_handle.get()));
+  }
 
-  ASSERT_TRUE(
-      nt::CreateRegKey(nt::HKCU, sz_new_key_2, KEY_ALL_ACCESS, nullptr));
-  EXPECT_TRUE(nt::OpenRegKey(nt::HKCU, sz_new_key_2, KEY_ALL_ACCESS,
-                             &key_handle, nullptr));
-  EXPECT_TRUE(nt::DeleteRegKey(key_handle));
-  nt::CloseRegKey(key_handle);
+  {
+    nt::ScopedHANDLE key_handle(
+        nt::CreateRegKey(nt::HKCU, sz_new_key_2, KEY_ALL_ACCESS));
+    ASSERT_TRUE(key_handle.is_valid());
+  }
+  {
+    nt::ScopedHANDLE key_handle(
+        nt::OpenRegKey(nt::HKCU, sz_new_key_2, KEY_ALL_ACCESS, nullptr));
+    EXPECT_TRUE(key_handle.is_valid());
+    EXPECT_TRUE(nt::DeleteRegKey(key_handle.get()));
+  }
 
-  ASSERT_TRUE(
-      nt::CreateRegKey(nt::HKCU, sz_new_key_3, KEY_ALL_ACCESS, nullptr));
-  EXPECT_TRUE(nt::OpenRegKey(nt::HKCU, L"test3\\new\\subkey\\blah2",
-                             KEY_ALL_ACCESS, &key_handle, nullptr));
-  EXPECT_TRUE(nt::DeleteRegKey(key_handle));
-  nt::CloseRegKey(key_handle);
+  {
+    nt::ScopedHANDLE key_handle(
+        nt::CreateRegKey(nt::HKCU, sz_new_key_3, KEY_ALL_ACCESS));
+    ASSERT_TRUE(key_handle.is_valid());
+  }
+  {
+    nt::ScopedHANDLE key_handle(nt::OpenRegKey(
+        nt::HKCU, L"test3\\new\\subkey\\blah2", KEY_ALL_ACCESS, nullptr));
+    EXPECT_TRUE(key_handle.is_valid());
+    EXPECT_TRUE(nt::DeleteRegKey(key_handle.get()));
+  }
 
   // Subkey path can be null.
-  ASSERT_TRUE(nt::CreateRegKey(nt::HKCU, nullptr, KEY_ALL_ACCESS, &key_handle));
-  ASSERT_NE(key_handle, INVALID_HANDLE_VALUE);
-  ASSERT_NE(key_handle, nullptr);
-  nt::CloseRegKey(key_handle);
+  {
+    nt::ScopedHANDLE key_handle(
+        nt::CreateRegKey(nt::HKCU, nullptr, KEY_ALL_ACCESS));
+    ASSERT_TRUE(key_handle.is_valid());
+    ASSERT_NE(key_handle.get(), nullptr);
+  }
 }
 
 }  // namespace