Making a few RegKey methods that only read data, const....

base/win/registry.cc

 // Copyright (c) 2010 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/thread_restrictions.h"
@@ skipping 226 matching lines @@
 
   HKEY subkey = NULL;
   LONG result = RegOpenKeyEx(key_, name, 0, access, &subkey);
 
   Close();
 
   key_ = subkey;
   return (result == ERROR_SUCCESS);
 }
 
-DWORD RegKey::ValueCount() {
+DWORD RegKey::ValueCount() const {
   base::ThreadRestrictions::AssertIOAllowed();
   DWORD count = 0;
   HRESULT result = RegQueryInfoKey(key_, NULL, 0, NULL, NULL, NULL,
                                    NULL, &count, NULL, NULL, NULL, NULL);
   return (result != ERROR_SUCCESS) ? 0 : count;
 }
 
-bool RegKey::ReadName(int index, std::wstring* name) {
+bool RegKey::ReadName(int index, std::wstring* name) const {
   base::ThreadRestrictions::AssertIOAllowed();
   wchar_t buf[256];
   DWORD bufsize = arraysize(buf);
   LRESULT r = ::RegEnumValue(key_, index, buf, &bufsize, NULL, NULL,
                              NULL, NULL);
   if (r != ERROR_SUCCESS)
     return false;
   if (name)
     *name = buf;
   return true;
 }
 
 bool RegKey::ValueExists(const wchar_t* name) {
   base::ThreadRestrictions::AssertIOAllowed();
   if (!key_)
     return false;
   HRESULT result = RegQueryValueEx(key_, name, 0, NULL, NULL, NULL);
   return (result == ERROR_SUCCESS);
 }
 
 bool RegKey::ReadValue(const wchar_t* name, void* data,
-                       DWORD* dsize, DWORD* dtype) {
+                       DWORD* dsize, DWORD* dtype) const {
   base::ThreadRestrictions::AssertIOAllowed();
   if (!key_)
     return false;
   HRESULT result = RegQueryValueEx(key_, name, 0, dtype,
                                    reinterpret_cast<LPBYTE>(data), dsize);
   return (result == ERROR_SUCCESS);
 }
 
-bool RegKey::ReadValue(const wchar_t* name, std::wstring* value) {
+bool RegKey::ReadValue(const wchar_t* name, std::wstring* value) const {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(value);
   const size_t kMaxStringLength = 1024;  // This is after expansion.
   // Use the one of the other forms of ReadValue if 1024 is too small for you.
   wchar_t raw_value[kMaxStringLength];
   DWORD type = REG_SZ, size = sizeof(raw_value);
   if (ReadValue(name, raw_value, &size, &type)) {
     if (type == REG_SZ) {
       *value = raw_value;
     } else if (type == REG_EXPAND_SZ) {
       wchar_t expanded[kMaxStringLength];
       size = ExpandEnvironmentStrings(raw_value, expanded, kMaxStringLength);
       // Success: returns the number of wchar_t's copied
       // Fail: buffer too small, returns the size required
       // Fail: other, returns 0
       if (size == 0 || size > kMaxStringLength)
         return false;
       *value = expanded;
     } else {
       // Not a string. Oops.
       return false;
     }
     return true;
   }
 
   return false;
 }
 
-bool RegKey::ReadValueDW(const wchar_t* name, DWORD* value) {
+bool RegKey::ReadValueDW(const wchar_t* name, DWORD* value) const {
   DCHECK(value);
   DWORD type = REG_DWORD;
   DWORD size = sizeof(DWORD);
   DWORD result = 0;
   if (ReadValue(name, &result, &size, &type) &&
       (type == REG_DWORD || type == REG_BINARY) &&
       size == sizeof(DWORD)) {
     *value = result;
     return true;
   }
@@ skipping 81 matching lines @@
     if (WaitForSingleObject(watch_event_, 0) == WAIT_OBJECT_0) {
       StartWatching();
       return true;
     }
   }
   return false;
 }
 
 }  // namespace win
 }  // namespace base