Regkey functions return error code instead of bool

ceee/ie/common/ceee_module_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.
 //
 // CEEE module-wide utilities.
 
 #include "ceee/ie/common/ceee_module_util.h"
 
 #include <iepmapi.h>
 
@@ skipping 25 matching lines @@
 // Global state needed by the BHO and the
 // toolband, to indicate whether ShowDW calls should affect
 // registry tracking of the user's visibility preference. A
 // non-zero value indicates that the calls should be ignored.
 LONG g_ignore_show_dw_changes = 0;
 
 bool GetCeeeRegistryBoolean(const wchar_t* key, bool default_value) {
   base::win::RegKey hkcu(HKEY_CURRENT_USER, kRegistryPath, KEY_READ);
   LOG_IF(ERROR, !hkcu.Valid()) << "Could not open reg key: " << kRegistryPath;
 
-  DWORD dword_value_representation = 0;
-  DWORD size = sizeof(dword_value_representation);
-  DWORD type = REG_DWORD;
-
-  if (!hkcu.Valid() ||
-      !hkcu.ReadValue(key, &dword_value_representation, &size, &type)) {
-    return default_value;
-  }
-
-  return dword_value_representation != 0;
+  DWORD value = default_value ? 1 : 0;
+  hkcu.ReadValueDW(key, &value);
+  return value != 0;
 }
 
 void SetCeeeRegistryBoolean(const wchar_t* key, bool assign_value) {
   base::win::RegKey hkcu(HKEY_CURRENT_USER, kRegistryPath, KEY_WRITE);
   LOG_IF(ERROR, !hkcu.Valid()) << "Could not open reg key: " << kRegistryPath;
 
   DWORD dword_value_representation = assign_value ? 1 : 0;
-  bool write_result = hkcu.WriteValue(key, &dword_value_representation,
+  LONG write_result = hkcu.WriteValue(key, &dword_value_representation,
                                       sizeof(dword_value_representation),
                                       REG_DWORD);
 
-  LOG_IF(ERROR, !write_result) << "Failed to write a registry key: " << key;
+  LOG_IF(ERROR, write_result != ERROR_SUCCESS)
+      << "Failed to write a registry key: " << key
+      << " error: " << com::LogWe(write_result);
 }
 
 }  // anonymous namespace
 
 namespace ceee_module_util {
 
 
 // The name of the profile we want ChromeFrame to use (for Internet Explorer).
 const wchar_t kChromeProfileName[] = L"iexplore";
 
@@ skipping 26 matching lines @@
   // "[32-bit program files]\Google\CEEE\Extensions", look for the
   // first valid directory and use that.  Eventually, when we support more
   // than one extension, we can load/install all directories and/or crx files
   // found here.
   std::wstring crx_path;
   base::win::RegKey hkcu(HKEY_CURRENT_USER, kRegistryPath, KEY_READ);
   base::win::RegKey hklm(HKEY_LOCAL_MACHINE, kRegistryPath, KEY_READ);
 
   base::win::RegKey* keys[] = { &hkcu, &hklm };
   for (int i = 0; i < arraysize(keys); ++i) {
-    if (keys[i]->Valid() && keys[i]->ReadValue(kRegistryValue, &crx_path))
+    if (keys[i]->Valid() &&
+        (keys[i]->ReadValue(kRegistryValue, &crx_path) == ERROR_SUCCESS))
       break;
   }
 
   if (crx_path.size() == 0u) {
     FilePath file_path;
     PathService::Get(base::DIR_PROGRAM_FILES, &file_path);
 
     file_path = file_path.Append(L"Google").Append(L"CEEE").
         Append(L"Extensions");
     if (!file_path.empty()) {
@@ skipping 64 matching lines @@
       if (!success ||
           extension_info.last_modified > GetInstalledExtensionTime()) {
         return true;
       } else {
         // We also check that the current version of Chrome was the one
         // that attempted installation; if not, changes such as a change
         // in the location of a profile directory might have occurred, and
         // we might need to retry installation.
         std::wstring version_string;
         base::win::RegKey hkcu(HKEY_CURRENT_USER, kRegistryPath, KEY_READ);
-        success = hkcu.ReadValue(
-            kRegistryValueCrxInstalledByVersion, &version_string);
+        success = hkcu.ReadValue(kRegistryValueCrxInstalledByVersion,
+                                 &version_string) == ERROR_SUCCESS;
         return !success || version_string != TO_L_STRING(CHROME_VERSION_STRING);
       }
     }
 
     return true;
   }
 
   return false;
 }
 
 void SetInstalledExtensionPath(const FilePath& path) {
   base::PlatformFileInfo extension_info;
   const bool success = file_util::GetFileInfo(path, &extension_info);
   const int64 crx_time = success ?
       extension_info.last_modified.ToInternalValue() :
       base::Time::Now().ToInternalValue();
 
   base::win::RegKey key(HKEY_CURRENT_USER, kRegistryPath, KEY_WRITE);
-  bool write_result = key.WriteValue(kRegistryValueCrxInstalledTime,
+  LONG write_result = key.WriteValue(kRegistryValueCrxInstalledTime,
                                      &crx_time,
                                      sizeof(crx_time),
                                      REG_QWORD);
-  DCHECK(write_result);
+  DCHECK_EQ(ERROR_SUCCESS, write_result);
   write_result = key.WriteValue(kRegistryValueCrxInstalledPath,
                                 path.value().c_str());
-  DCHECK(write_result);
+  DCHECK_EQ(ERROR_SUCCESS, write_result);
 
   write_result = key.WriteValue(kRegistryValueCrxInstalledByVersion,
                                 TO_L_STRING(CHROME_VERSION_STRING));
+  DCHECK_EQ(ERROR_SUCCESS, write_result);
 }
 
 bool IsCrxOrEmpty(const std::wstring& path) {
   return (path.empty() ||
       (path.substr(std::max(path.size() - 4, 0u)) == L".crx"));
 }
 
 void SetOptionToolbandIsHidden(bool is_hidden) {
   SetCeeeRegistryBoolean(kRegistryValueToolbandIsHidden, is_hidden);
 }
@@ skipping 54 matching lines @@
   key.append(kChromeFrameGuid);
   return key;
 }
 
 // TODO(vitalybuka@google.com) : remove this code and use
 // GoogleUpdateSettings::GetCollectStatsConsent() code.
 // BrowserDistribution requires modification to know about CEEE (bb3136374).
 bool GetCollectStatsConsent() {
   std::wstring reg_path = GetCromeFrameClientStateKey();
   base::win::RegKey key(HKEY_CURRENT_USER, reg_path.c_str(), KEY_READ);
-  DWORD value;
-  if (!key.ReadValueDW(google_update::kRegUsageStatsField, &value)) {
+  DWORD value = 0;
+  LONG result = key.ReadValueDW(google_update::kRegUsageStatsField, &value);
+  if (result != ERROR_SUCCESS) {
     base::win::RegKey hklm_key(HKEY_LOCAL_MACHINE, reg_path.c_str(), KEY_READ);
-    if (!hklm_key.ReadValueDW(google_update::kRegUsageStatsField, &value))
-      return false;
+    result = key.ReadValueDW(google_update::kRegUsageStatsField, &value);
   }
+
   return (1 == value);
 }
 
 bool RefreshElevationPolicyIfNeeded() {
   if (ie_util::GetIeVersion() < ie_util::IEVERSION_IE7)
     return false;
 
   // This may access InternetRegistry instead of real one. However this is
   // acceptable, we just refresh policy twice.
   base::win::RegKey hkcu(HKEY_CURRENT_USER, kRegistryPath,
                          KEY_WRITE | KEY_QUERY_VALUE);
   LOG_IF(ERROR, !hkcu.Valid()) << "Failed to open reg key: " << kRegistryPath;
   if (!hkcu.Valid())
     return false;
 
   std::wstring expected_version = TO_L_STRING(CHROME_VERSION_STRING);
 
   static const wchar_t kValueName[] = L"last_elevation_refresh";
   std::wstring last_elevation_refresh_version;
-  bool result = hkcu.ReadValue(kValueName, &last_elevation_refresh_version);
+  LONG result = hkcu.ReadValue(kValueName, &last_elevation_refresh_version);
   if (last_elevation_refresh_version == expected_version)
     return false;
 
   HRESULT hr = ::IERefreshElevationPolicy();
   VLOG(1) << "Elevation policy refresh result: " << com::LogHr(hr);
 
   // Write after refreshing because it's better to refresh twice, than to miss
   // once.
   result = hkcu.WriteValue(kValueName, expected_version.c_str());
-  LOG_IF(ERROR, !result) << "Failed to write a registry value: " << kValueName;
+  LOG_IF(ERROR, result != ERROR_SUCCESS) << "Failed to write a registry value: "
+      << kValueName << " error: " << com::LogWe(result);
 
   return true;
 }
 
 }  // namespace ceee_module_util