Regkey functions return error code instead of bool

chrome/browser/extensions/external_registry_extension_provider_win.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 "chrome/browser/extensions/external_registry_extension_provider_win.h"
 
 #include "base/file_path.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
@@ skipping 11 matching lines @@
 const wchar_t kRegistryExtensionPath[] = L"path";
 
 // Registry value of that key that defines the current version of the .crx file.
 const wchar_t kRegistryExtensionVersion[] = L"version";
 
 bool OpenKeyById(const std::string& id, base::win::RegKey *key) {
   std::wstring key_path = ASCIIToWide(kRegistryExtensions);
   key_path.append(L"\\");
   key_path.append(ASCIIToWide(id));
 
-  return key->Open(kRegRoot, key_path.c_str(), KEY_READ);
+  LONG result = key->Open(kRegRoot, key_path.c_str(), KEY_READ);
+  return (ERROR_SUCCESS == result);
 }
 
 }  // namespace
 
 ExternalRegistryExtensionProvider::ExternalRegistryExtensionProvider() {
 }
 
 ExternalRegistryExtensionProvider::~ExternalRegistryExtensionProvider() {
 }
 
 void ExternalRegistryExtensionProvider::VisitRegisteredExtension(
     Visitor* visitor) const {
   base::win::RegistryKeyIterator iterator(
       kRegRoot, ASCIIToWide(kRegistryExtensions).c_str());
   while (iterator.Valid()) {
     base::win::RegKey key;
     std::wstring key_path = ASCIIToWide(kRegistryExtensions);
     key_path.append(L"\\");
     key_path.append(iterator.Name());
-    if (key.Open(kRegRoot, key_path.c_str(), KEY_READ)) {
+    if (key.Open(kRegRoot, key_path.c_str(), KEY_READ) == ERROR_SUCCESS) {
       std::wstring extension_path;
-      if (key.ReadValue(kRegistryExtensionPath, &extension_path)) {
+      if (key.ReadValue(kRegistryExtensionPath,
+                        &extension_path) == ERROR_SUCCESS) {
         std::wstring extension_version;
-        if (key.ReadValue(kRegistryExtensionVersion, &extension_version)) {
+        if (key.ReadValue(kRegistryExtensionVersion,
+                          &extension_version) == ERROR_SUCCESS) {
           std::string id = WideToASCII(iterator.Name());
           StringToLowerASCII(&id);
 
           scoped_ptr<Version> version;
           version.reset(Version::GetVersionFromString(
                             WideToASCII(extension_version)));
           if (!version.get()) {
             LOG(ERROR) << "Invalid version value " << extension_version
                        << " for key " << key_path;
             ++iterator;
@@ skipping 27 matching lines @@
 
 bool ExternalRegistryExtensionProvider::GetExtensionDetails(
     const std::string& id,
     Extension::Location* location,
     scoped_ptr<Version>* version) const  {
   base::win::RegKey key;
   if (!OpenKeyById(id, &key))
     return false;
 
   std::wstring extension_version;
-  if (!key.ReadValue(kRegistryExtensionVersion, &extension_version))
+  if (key.ReadValue(kRegistryExtensionVersion,
+                    &extension_version) != ERROR_SUCCESS)
     return false;
 
   if (version) {
     version->reset(Version::GetVersionFromString(
                        WideToASCII(extension_version)));
   }
 
   if (location)
     *location = Extension::EXTERNAL_REGISTRY;
   return true;
 }