base/win: small improvement to RegKey API.

base/win/registry.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 "base/win/registry.h"
 
 #include <shlwapi.h>
 
 #include "base/logging.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 38 matching lines @@
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(rootkey && subkey && access && disposition);
   Close();
 
   LONG result = RegCreateKeyEx(rootkey, subkey, 0, NULL,
                                REG_OPTION_NON_VOLATILE, access, NULL, &key_,
                                disposition);
   return result;
 }
 
-LONG RegKey::Open(HKEY rootkey, const wchar_t* subkey, REGSAM access) {
-  base::ThreadRestrictions::AssertIOAllowed();
-  DCHECK(rootkey && subkey && access);
-  Close();
-
-  LONG result = RegOpenKeyEx(rootkey, subkey, 0, access, &key_);
-  return result;
-}
-
 LONG RegKey::CreateKey(const wchar_t* name, REGSAM access) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(name && access);
 
   HKEY subkey = NULL;
   LONG result = RegCreateKeyEx(key_, name, 0, NULL, REG_OPTION_NON_VOLATILE,
                                access, NULL, &subkey, NULL);
   Close();
 
   key_ = subkey;
   return result;
 }
 
-LONG RegKey::OpenKey(const wchar_t* name, REGSAM access) {
+LONG RegKey::Open(HKEY rootkey, const wchar_t* subkey, REGSAM access) {
   base::ThreadRestrictions::AssertIOAllowed();
-  DCHECK(name && access);
+  DCHECK(rootkey && subkey && access);
+  Close();
+
+  LONG result = RegOpenKeyEx(rootkey, subkey, 0, access, &key_);
+  return result;
+}
+
+LONG RegKey::OpenKey(const wchar_t* relative_key_name, REGSAM access) {
+  base::ThreadRestrictions::AssertIOAllowed();
+  DCHECK(relative_key_name && access);
 
   HKEY subkey = NULL;
-  LONG result = RegOpenKeyEx(key_, name, 0, access, &subkey);
+  LONG result = RegOpenKeyEx(key_, relative_key_name, 0, access, &subkey);
 
+  // We have to close the current opened key before replacing it with the new
+  // one.
   Close();
 
   key_ = subkey;
   return result;
 }
 
 void RegKey::Close() {
   base::ThreadRestrictions::AssertIOAllowed();
   StopWatching();
   if (key_) {
     ::RegCloseKey(key_);
     key_ = NULL;
   }
 }
 
-DWORD RegKey::ValueCount() const {
+bool RegKey::HasValue(const wchar_t* name) const {
+  base::ThreadRestrictions::AssertIOAllowed();
+  return RegQueryValueEx(key_, name, 0, NULL, NULL, NULL) == ERROR_SUCCESS;
+}
+
+DWORD RegKey::GetValueCount() const {
   base::ThreadRestrictions::AssertIOAllowed();
   DWORD count = 0;
   LONG result = RegQueryInfoKey(key_, NULL, 0, NULL, NULL, NULL, NULL, &count,
                                 NULL, NULL, NULL, NULL);
-  return (result != ERROR_SUCCESS) ? 0 : count;
+  return (result == ERROR_SUCCESS) ? count : 0;
 }
 
-LONG RegKey::ReadName(int index, std::wstring* name) const {
+LONG RegKey::GetValueNameAt(int index, std::wstring* name) const {
   base::ThreadRestrictions::AssertIOAllowed();
   wchar_t buf[256];
   DWORD bufsize = arraysize(buf);
   LONG r = ::RegEnumValue(key_, index, buf, &bufsize, NULL, NULL, NULL, NULL);
   if (r == ERROR_SUCCESS)
     *name = buf;
 
   return r;
 }
 
 LONG RegKey::DeleteKey(const wchar_t* name) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(key_);
   DCHECK(name);
   LONG result = SHDeleteKey(key_, name);
   return result;
 }
 
 LONG RegKey::DeleteValue(const wchar_t* value_name) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(key_);
   DCHECK(value_name);
   LONG result = RegDeleteValue(key_, value_name);
   return result;
 }
 
-bool RegKey::ValueExists(const wchar_t* name) const {
-  base::ThreadRestrictions::AssertIOAllowed();
-  LONG result = RegQueryValueEx(key_, name, 0, NULL, NULL, NULL);
-  return result == ERROR_SUCCESS;
-}
-
 LONG RegKey::ReadValue(const wchar_t* name, void* data, DWORD* dsize,
                        DWORD* dtype) const {
   base::ThreadRestrictions::AssertIOAllowed();
   LONG result = RegQueryValueEx(key_, name, 0, dtype,
                                 reinterpret_cast<LPBYTE>(data), dsize);
   return result;
 }
 
 LONG RegKey::ReadValue(const wchar_t* name, std::wstring* value) const {
   base::ThreadRestrictions::AssertIOAllowed();
@@ skipping 248 matching lines @@
     if (ERROR_SUCCESS == r)
       return true;
   }
 
   name_[0] = '\0';
   return false;
 }
 
 }  // namespace win
 }  // namespace base