Remove sanity check in RegKey to prevent usage of checking...

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 21 matching lines @@
       Open(rootkey, subkey, access);
   } else {
     DCHECK(!subkey);
   }
 }
 
 RegKey::~RegKey() {
   Close();
 }
 
-GONG RegKey::Create(HKEY rootkey, const wchar_t* subkey, REGSAM access) {
+LONG RegKey::Create(HKEY rootkey, const wchar_t* subkey, REGSAM access) {
   DWORD disposition_value;
   return CreateWithDisposition(rootkey, subkey, &disposition_value, access);
 }
 
-GONG RegKey::CreateWithDisposition(HKEY rootkey, const wchar_t* subkey,
+LONG RegKey::CreateWithDisposition(HKEY rootkey, const wchar_t* subkey,
                                    DWORD* disposition, REGSAM access) {
   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;
 }
 
-GONG RegKey::Open(HKEY rootkey, const wchar_t* subkey, REGSAM access) {
+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;
 }
 
-GONG RegKey::CreateKey(const wchar_t* name, REGSAM access) {
+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;
 }
 
-GONG RegKey::OpenKey(const wchar_t* name, REGSAM access) {
+LONG RegKey::OpenKey(const wchar_t* name, REGSAM access) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(name && access);
 
   HKEY subkey = NULL;
   LONG result = RegOpenKeyEx(key_, name, 0, access, &subkey);
 
   Close();
 
   key_ = subkey;
   return result;
 }
 
 void RegKey::Close() {
   base::ThreadRestrictions::AssertIOAllowed();
   StopWatching();
   if (key_) {
     ::RegCloseKey(key_);
     key_ = NULL;
   }
 }
 
 DWORD RegKey::ValueCount() 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;
 }
 
-GONG RegKey::ReadName(int index, std::wstring* name) const {
+LONG RegKey::ReadName(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;
 }
 
-GONG RegKey::DeleteKey(const wchar_t* name) {
+LONG RegKey::DeleteKey(const wchar_t* name) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(key_);
   DCHECK(name);
   LONG result = SHDeleteKey(key_, name);
   return result;
 }
 
-GONG RegKey::DeleteValue(const wchar_t* value_name) {
+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;
 }
 
-GONG RegKey::ReadValue(const wchar_t* name, void* data, DWORD* dsize,
+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;
 }
 
-GONG RegKey::ReadValue(const wchar_t* name, std::wstring* value) const {
+LONG 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);
   LONG result = ReadValue(name, raw_value, &size, &type);
   if (result == ERROR_SUCCESS) {
     if (type == REG_SZ) {
       *value = raw_value;
@@ skipping 10 matching lines @@
       }
     } else {
       // Not a string. Oops.
       result = ERROR_CANTREAD;
     }
   }
 
   return result;
 }
 
-GONG RegKey::ReadValueDW(const wchar_t* name, DWORD* value) const {
+LONG RegKey::ReadValueDW(const wchar_t* name, DWORD* value) const {
   DCHECK(value);
   DWORD type = REG_DWORD;
   DWORD size = sizeof(DWORD);
   DWORD local_value = 0;
   LONG result = ReadValue(name, &local_value, &size, &type);
   if (result == ERROR_SUCCESS) {
     if ((type == REG_DWORD || type == REG_BINARY) && size == sizeof(DWORD)) {
       *value = local_value;
     } else {
       result = ERROR_CANTREAD;
     }
   }
 
   return result;
 }
 
-GONG RegKey::ReadInt64(const wchar_t* name, int64* value) const {
+LONG RegKey::ReadInt64(const wchar_t* name, int64* value) const {
   DCHECK(value);
   DWORD type = REG_QWORD;
   int64 local_value = 0;
   DWORD size = sizeof(local_value);
   LONG result = ReadValue(name, &local_value, &size, &type);
   if (result == ERROR_SUCCESS) {
     if ((type == REG_QWORD || type == REG_BINARY) &&
         size == sizeof(local_value)) {
       *value = local_value;
     } else {
       result = ERROR_CANTREAD;
     }
   }
 
   return result;
 }
 
-GONG RegKey::WriteValue(const wchar_t* name, const void * data,
+LONG RegKey::WriteValue(const wchar_t* name, const void * data,
                         DWORD dsize, DWORD dtype) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(data);
 
   LONG result = RegSetValueEx(key_, name, 0, dtype,
       reinterpret_cast<LPBYTE>(const_cast<void*>(data)), dsize);
   return result;
 }
 
-GONG RegKey::WriteValue(const wchar_t * name, const wchar_t* value) {
+LONG RegKey::WriteValue(const wchar_t * name, const wchar_t* value) {
   return WriteValue(name, value,
       static_cast<DWORD>(sizeof(*value) * (wcslen(value) + 1)), REG_SZ);
 }
 
-GONG RegKey::WriteValue(const wchar_t* name, DWORD value) {
+LONG RegKey::WriteValue(const wchar_t* name, DWORD value) {
   return WriteValue(name, &value, static_cast<DWORD>(sizeof(value)), REG_DWORD);
 }
 
-GONG RegKey::StartWatching() {
+LONG RegKey::StartWatching() {
   DCHECK(key_);
   if (!watch_event_)
     watch_event_ = CreateEvent(NULL, TRUE, FALSE, NULL);
 
   DWORD filter = REG_NOTIFY_CHANGE_NAME |
                  REG_NOTIFY_CHANGE_ATTRIBUTES |
                  REG_NOTIFY_CHANGE_LAST_SET |
                  REG_NOTIFY_CHANGE_SECURITY;
 
   // Watch the registry key for a change of value.
   LONG result = RegNotifyChangeKeyValue(key_, TRUE, filter, watch_event_, TRUE);
   if (result != ERROR_SUCCESS) {
     CloseHandle(watch_event_);
     watch_event_ = 0;
   }
 
   return result;
 }
 
 bool RegKey::HasChanged() {
   if (watch_event_) {
     if (WaitForSingleObject(watch_event_, 0) == WAIT_OBJECT_0) {
       StartWatching();
       return true;
     }
   }
   return false;
 }
 
-GONG RegKey::StopWatching() {
+LONG RegKey::StopWatching() {
   LONG result = ERROR_INVALID_HANDLE;
   if (watch_event_) {
     CloseHandle(watch_event_);
     watch_event_ = 0;
     result = ERROR_SUCCESS;
   }
   return result;
 }
 
 // RegistryValueIterator ------------------------------------------------------
@@ skipping 124 matching lines @@
     if (ERROR_SUCCESS == r)
       return true;
   }
 
   name_[0] = '\0';
   return false;
 }
 
 }  // namespace win
 }  // namespace base