Regkey functions return error code instead of bool

chrome/installer/util/google_update_settings_unittest.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 <windows.h>
 #include <shlwapi.h>  // For SHDeleteKey.
 
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/win/registry.h"
@@ skipping 27 matching lines @@
   virtual void SetUp() {
     // Wipe the keys we redirect to.
     // This gives us a stable run, even in the presence of previous
     // crashes or failures.
     LSTATUS err = SHDeleteKey(HKEY_CURRENT_USER, kHKCUReplacement);
     EXPECT_TRUE(err == ERROR_SUCCESS || err == ERROR_FILE_NOT_FOUND);
     err = SHDeleteKey(HKEY_CURRENT_USER, kHKLMReplacement);
     EXPECT_TRUE(err == ERROR_SUCCESS || err == ERROR_FILE_NOT_FOUND);
 
     // Create the keys we're redirecting HKCU and HKLM to.
-    ASSERT_TRUE(hkcu_.Create(HKEY_CURRENT_USER, kHKCUReplacement, KEY_READ));
-    ASSERT_TRUE(hklm_.Create(HKEY_CURRENT_USER, kHKLMReplacement, KEY_READ));
+    ASSERT_EQ(ERROR_SUCCESS,
+        hkcu_.Create(HKEY_CURRENT_USER, kHKCUReplacement, KEY_READ));
+    ASSERT_EQ(ERROR_SUCCESS,
+        hklm_.Create(HKEY_CURRENT_USER, kHKLMReplacement, KEY_READ));
 
     // And do the switcharoo.
     ASSERT_EQ(ERROR_SUCCESS,
               ::RegOverridePredefKey(HKEY_CURRENT_USER, hkcu_.Handle()));
     ASSERT_EQ(ERROR_SUCCESS,
               ::RegOverridePredefKey(HKEY_LOCAL_MACHINE, hklm_.Handle()));
   }
 
   virtual void TearDown() {
     // Undo the redirection.
@@ skipping 12 matching lines @@
     USER_INSTALL,
   };
 
   void SetApField(SystemUserInstall is_system, const wchar_t* value) {
     HKEY root = is_system == SYSTEM_INSTALL ?
         HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 
     RegKey update_key;
     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     std::wstring path = dist->GetStateKey();
-    ASSERT_TRUE(update_key.Create(root, path.c_str(), KEY_WRITE));
-    ASSERT_TRUE(update_key.WriteValue(L"ap", value));
+    ASSERT_EQ(ERROR_SUCCESS, update_key.Create(root, path.c_str(), KEY_WRITE));
+    ASSERT_EQ(ERROR_SUCCESS, update_key.WriteValue(L"ap", value));
   }
 
   // Tests setting the ap= value to various combinations of values with
   // prefixes and suffixes, while asserting on the correct channel value.
   // Note that any non-empty ap= value that doesn't match ".*-{dev|beta}.*"
   // will return the "unknown" channel.
   void TestCurrentChromeChannelWithVariousApValues(SystemUserInstall install) {
     static struct Expectations {
       const wchar_t* ap_value;
       const wchar_t* channel;
@@ skipping 60 matching lines @@
     reg_key.append(L"\\");
     reg_key.append(kTestProductGuid);
     return reg_key;
   }
 
   // Utility method to read "ap" key value
   std::wstring ReadApKeyValue() {
     RegKey key;
     std::wstring ap_key_value;
     std::wstring reg_key = GetApKeyPath();
-    if (key.Open(HKEY_CURRENT_USER, reg_key.c_str(), KEY_ALL_ACCESS) &&
-        key.ReadValue(google_update::kRegApField, &ap_key_value)) {
-      return ap_key_value;
+    LONG result = key.Open(HKEY_CURRENT_USER, reg_key.c_str(), KEY_ALL_ACCESS);
+    if (result == ERROR_SUCCESS) {
+      key.ReadValue(google_update::kRegApField, &ap_key_value);
     }
-    return std::wstring();
+
+    return ap_key_value;
   }
 
   RegKey hkcu_;
   RegKey hklm_;
 };
 
 }  // namespace
 
 // Verify that we return failure on no registration,
 // whether per-system or per-user install.
@@ skipping 185 matching lines @@
   EXPECT_STREQ(ReadApKeyValue().c_str(), L"");
   work_item_list->Rollback();
 
   work_item_list.reset(WorkItem::CreateWorkItemList());
   // Test the case of when "ap" key doesnt exist at all
   std::wstring ap_key_value = ReadApKeyValue();
   std::wstring reg_key = GetApKeyPath();
   HKEY reg_root = HKEY_CURRENT_USER;
   bool ap_key_deleted = false;
   RegKey key;
-  if (!key.Open(HKEY_CURRENT_USER, reg_key.c_str(), KEY_ALL_ACCESS)) {
+  LONG result = key.Open(HKEY_CURRENT_USER, reg_key.c_str(), KEY_ALL_ACCESS);
+  if (result != ERROR_SUCCESS) {
     work_item_list->AddCreateRegKeyWorkItem(reg_root, reg_key);
     ASSERT_TRUE(work_item_list->Do()) << "Failed to create ClientState key.";
-  } else if (key.DeleteValue(google_update::kRegApField)) {
+  } else if (key.DeleteValue(google_update::kRegApField) == ERROR_SUCCESS) {
     ap_key_deleted = true;
   }
   // try differential installer
   GoogleUpdateSettings::UpdateDiffInstallStatus(false, true,
                                        installer::INSTALL_FAILED,
                                        kTestProductGuid);
   EXPECT_STREQ(ReadApKeyValue().c_str(), L"-full");
   // try full installer now
   GoogleUpdateSettings::UpdateDiffInstallStatus(false, false,
                                        installer::INSTALL_FAILED,
@@ skipping 27 matching lines @@
   scoped_refptr<installer::Package> package(
       new installer::Package(multi_install, system_level, FilePath(),
                              &properties));
   scoped_refptr<installer::Product> product(
       new installer::Product(distribution, package.get()));
   RegKey key;
   DWORD value;
 
   // By default, eulaconsent ends up on the package.
   EXPECT_TRUE(GoogleUpdateSettings::SetEULAConsent(*package.get(), true));
-  EXPECT_TRUE(key.Open(HKEY_LOCAL_MACHINE,
-                       properties.GetStateMediumKey().c_str(),
-                       KEY_QUERY_VALUE | KEY_SET_VALUE));
-  EXPECT_TRUE(key.ReadValueDW(google_update::kRegEULAAceptedField, &value));
+  EXPECT_EQ(ERROR_SUCCESS,
+      key.Open(HKEY_LOCAL_MACHINE, properties.GetStateMediumKey().c_str(),
+               KEY_QUERY_VALUE | KEY_SET_VALUE));
+  EXPECT_EQ(ERROR_SUCCESS,
+      key.ReadValueDW(google_update::kRegEULAAceptedField, &value));
   EXPECT_EQ(1U, value);
-  EXPECT_TRUE(key.DeleteValue(google_update::kRegEULAAceptedField));
+  EXPECT_EQ(ERROR_SUCCESS,
+      key.DeleteValue(google_update::kRegEULAAceptedField));
 
   // But it will end up on the product if needed
-  EXPECT_TRUE(key.Create(HKEY_LOCAL_MACHINE,
-                         distribution->GetStateKey().c_str(), KEY_SET_VALUE));
-  EXPECT_TRUE(key.WriteValue(google_update::kRegEULAAceptedField,
-                             static_cast<DWORD>(0)));
+  EXPECT_EQ(ERROR_SUCCESS,
+      key.Create(HKEY_LOCAL_MACHINE, distribution->GetStateKey().c_str(),
+                 KEY_SET_VALUE));
+  EXPECT_EQ(ERROR_SUCCESS,
+      key.WriteValue(google_update::kRegEULAAceptedField,
+                     static_cast<DWORD>(0)));
   EXPECT_TRUE(GoogleUpdateSettings::SetEULAConsent(*package.get(), true));
-  EXPECT_TRUE(key.Open(HKEY_LOCAL_MACHINE,
-                       distribution->GetStateMediumKey().c_str(),
-                       KEY_QUERY_VALUE | KEY_SET_VALUE));
-  EXPECT_TRUE(key.ReadValueDW(google_update::kRegEULAAceptedField, &value));
+  EXPECT_EQ(ERROR_SUCCESS,
+      key.Open(HKEY_LOCAL_MACHINE, distribution->GetStateMediumKey().c_str(),
+               KEY_QUERY_VALUE | KEY_SET_VALUE));
+  EXPECT_EQ(ERROR_SUCCESS,
+      key.ReadValueDW(google_update::kRegEULAAceptedField, &value));
   EXPECT_EQ(1U, value);
 }