Regkey functions return error code instead of bool

chrome/installer/util/shell_util.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.
 //
 // This file defines functions that integrate Chrome in Windows shell. These
 // functions can be used by Chrome as well as Chrome installer. All of the
 // work is done by the local functions defined in anonymous namespace in
 // this class.
 
 #include "chrome/installer/util/shell_util.h"
@@ skipping 182 matching lines @@
     }
   }
 
   // Checks if the current registry entry exists in HKLM registry and the value
   // is same.
   bool ExistsInHKLM() const {
     RegKey key(HKEY_LOCAL_MACHINE, _key_path.c_str(), KEY_READ);
     bool found = false;
     if (_is_string) {
       std::wstring read_value;
-      found = (key.ReadValue(_name.c_str(), &read_value)) &&
+      found = (key.ReadValue(_name.c_str(), &read_value) == ERROR_SUCCESS) &&
               (read_value.size() == _value.size()) &&
               (std::equal(_value.begin(), _value.end(), read_value.begin(),
                           base::CaseInsensitiveCompare<wchar_t>()));
     } else {
       DWORD read_value;
-      found = key.ReadValueDW(_name.c_str(), &read_value) &&
+      found = (key.ReadValueDW(_name.c_str(), &read_value) == ERROR_SUCCESS) &&
               read_value == _int_value;

[grt (UTC plus 2), 2011/01/14 15:53:43]

For consistency, this should have parens, no?

[amit, 2011/01/15 01:28:11]

Done.

     }
     key.Close();
     return found;
   }
 
   // Checks if the current registry entry exists in HKLM registry
   // (only the name).
   bool NameExistsInHKLM() const {
     RegKey key(HKEY_LOCAL_MACHINE, _key_path.c_str(), KEY_READ);
     bool found = false;
     if (_is_string) {
       std::wstring read_value;
-      found = key.ReadValue(_name.c_str(), &read_value);
+      found = key.ReadValue(_name.c_str(), &read_value) == ERROR_SUCCESS;
     } else {
       DWORD read_value;
-      found = key.ReadValueDW(_name.c_str(), &read_value);
+      found = key.ReadValueDW(_name.c_str(), &read_value) == ERROR_SUCCESS;
     }
     key.Close();
     return found;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RegistryEntry);
 
   // Create a object that represent default value of a key
   RegistryEntry(const std::wstring& key_path, const std::wstring& value)
@@ skipping 112 matching lines @@
 // - The value should not be same as given value in |chrome_exe|
 // - Finally to handle the default install path (C:\Document and Settings\
 //   <user>\Local Settings\Application Data\Chromium\Application) the value
 //   of the above key should differ from |chrome_exe| only in user name.
 bool AnotherUserHasDefaultBrowser(BrowserDistribution* dist,
                                   const std::wstring& chrome_exe) {
   std::wstring reg_key(ShellUtil::kRegStartMenuInternet);
   reg_key.append(L"\\" + dist->GetApplicationName() + ShellUtil::kRegShellOpen);
   RegKey key(HKEY_LOCAL_MACHINE, reg_key.c_str(), KEY_READ);
   std::wstring registry_chrome_exe;
-  if (!key.ReadValue(L"", &registry_chrome_exe) ||
+  if ((key.ReadValue(L"", &registry_chrome_exe) != ERROR_SUCCESS) ||
       registry_chrome_exe.length() < 2)
     return false;
 
   registry_chrome_exe = registry_chrome_exe.substr(1,
       registry_chrome_exe.length() - 2);
   if ((registry_chrome_exe.size() == chrome_exe.size()) &&
       (std::equal(chrome_exe.begin(), chrome_exe.end(),
                   registry_chrome_exe.begin(),
                   base::CaseInsensitiveCompare<wchar_t>()))) {
     return false;
@@ skipping 206 matching lines @@
                                       std::map<std::wstring,
                                       std::wstring>* browsers) {
   std::wstring base_key(ShellUtil::kRegStartMenuInternet);
   HKEY root = HKEY_LOCAL_MACHINE;
   for (base::win::RegistryKeyIterator iter(root, base_key.c_str());
        iter.Valid(); ++iter) {
     std::wstring key = base_key + L"\\" + iter.Name();
     RegKey capabilities(root, (key + L"\\Capabilities").c_str(), KEY_READ);
     std::wstring name;
     if (!capabilities.Valid() ||
-        !capabilities.ReadValue(L"ApplicationName", &name)) {
+        capabilities.ReadValue(L"ApplicationName", &name) != ERROR_SUCCESS) {
       RegKey base_key(root, key.c_str(), KEY_READ);
-      if (!base_key.ReadValue(L"", &name))
+      if (base_key.ReadValue(L"", &name) != ERROR_SUCCESS)
         continue;
     }
     RegKey install_info(root, (key + L"\\InstallInfo").c_str(), KEY_READ);
     std::wstring command;
     if (!install_info.Valid() ||
-        !install_info.ReadValue(L"ReinstallCommand", &command))
+        (install_info.ReadValue(L"ReinstallCommand",
+                                &command) != ERROR_SUCCESS))
       continue;
     if (!name.empty() && !command.empty() &&
         name.find(dist->GetApplicationName()) == std::wstring::npos)
       (*browsers)[name] = command;
   }
 }
 
 bool ShellUtil::GetUserSpecificDefaultBrowserSuffix(BrowserDistribution* dist,
                                                     std::wstring* entry) {
   wchar_t user_name[256];
@@ skipping 203 matching lines @@
         chrome_exe.c_str(),                // target
         shortcut.c_str(),                  // shortcut
         chrome_path.c_str(),               // working dir
         NULL,                              // arguments
         description.c_str(),               // description
         chrome_exe.c_str(),                // icon file
         icon_index,                        // icon index
         dist->GetBrowserAppId().c_str());  // app id
   }
 }