Add WOW64 support to the installer registry work items

chrome/installer/util/install_util_unittest.cc

 // Copyright (c) 2012 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 <string>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/strings/string_util.h"
 #include "base/test/test_reg_util_win.h"
 #include "base/win/registry.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/product_unittest.h"
+#include "chrome/installer/util/work_item.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::win::RegKey;
 using registry_util::RegistryOverrideManager;
 using ::testing::_;
 using ::testing::Return;
 using ::testing::StrEq;
 
 class MockRegistryValuePredicate : public InstallUtil::RegistryValuePredicate {
  public:
@@ skipping 162 matching lines @@
     // Nothing to delete if the keys aren't even there.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(_)).Times(0);
       ASSERT_FALSE(RegKey(root, parent_key_path.c_str(),
                           KEY_QUERY_VALUE).Valid());
       EXPECT_EQ(InstallUtil::NOT_FOUND,
                 InstallUtil::DeleteRegistryKeyIf(root, parent_key_path,
                                                  child_key_path, value_name,
-                                                 pred));
+                                                 pred,
+                                                 WorkItem::kWow64Default));
       EXPECT_FALSE(RegKey(root, parent_key_path.c_str(),
                           KEY_QUERY_VALUE).Valid());
     }
 
     // Parent exists, but not child: no delete.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(_)).Times(0);
       ASSERT_TRUE(RegKey(root, parent_key_path.c_str(), KEY_SET_VALUE).Valid());
       EXPECT_EQ(InstallUtil::NOT_FOUND,
                 InstallUtil::DeleteRegistryKeyIf(root, parent_key_path,
                                                  child_key_path, value_name,
-                                                 pred));
+                                                 pred,
+                                                 WorkItem::kWow64Default));
       EXPECT_TRUE(RegKey(root, parent_key_path.c_str(),
                          KEY_QUERY_VALUE).Valid());
     }
 
     // Child exists, but no value: no delete.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(_)).Times(0);
       ASSERT_TRUE(RegKey(root, child_key_path.c_str(), KEY_SET_VALUE).Valid());
       EXPECT_EQ(InstallUtil::NOT_FOUND,
                 InstallUtil::DeleteRegistryKeyIf(root, parent_key_path,
                                                  child_key_path, value_name,
-                                                 pred));
+                                                 pred,
+                                                 WorkItem::kWow64Default));
       EXPECT_TRUE(RegKey(root, parent_key_path.c_str(),
                          KEY_QUERY_VALUE).Valid());
     }
 
     // Value exists, but doesn't match: no delete.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(StrEq(L"foosball!"))).WillOnce(Return(false));
       ASSERT_EQ(ERROR_SUCCESS,
                 RegKey(root, child_key_path.c_str(),
                        KEY_SET_VALUE).WriteValue(value_name, L"foosball!"));
       EXPECT_EQ(InstallUtil::NOT_FOUND,
                 InstallUtil::DeleteRegistryKeyIf(root, parent_key_path,
                                                  child_key_path, value_name,
-                                                 pred));
+                                                 pred,
+                                                 WorkItem::kWow64Default));
       EXPECT_TRUE(RegKey(root, parent_key_path.c_str(),
                          KEY_QUERY_VALUE).Valid());
     }
 
     // Value exists, and matches: delete.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(StrEq(value))).WillOnce(Return(true));
       ASSERT_EQ(ERROR_SUCCESS,
                 RegKey(root, child_key_path.c_str(),
                        KEY_SET_VALUE).WriteValue(value_name, value));
       EXPECT_EQ(InstallUtil::DELETED,
                 InstallUtil::DeleteRegistryKeyIf(root, parent_key_path,
                                                  child_key_path, value_name,
-                                                 pred));
+                                                 pred,
+                                                 WorkItem::kWow64Default));
       EXPECT_FALSE(RegKey(root, parent_key_path.c_str(),
                           KEY_QUERY_VALUE).Valid());
     }
 
     // Default value exists and matches: delete.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(StrEq(value))).WillOnce(Return(true));
       ASSERT_EQ(ERROR_SUCCESS,
                 RegKey(root, child_key_path.c_str(),
                        KEY_SET_VALUE).WriteValue(NULL, value));
       EXPECT_EQ(InstallUtil::DELETED,
                 InstallUtil::DeleteRegistryKeyIf(root, parent_key_path,
                                                  child_key_path, NULL,
-                                                 pred));
+                                                 pred,
+                                                 WorkItem::kWow64Default));
       EXPECT_FALSE(RegKey(root, parent_key_path.c_str(),
                           KEY_QUERY_VALUE).Valid());
     }
   }
 }
 
 TEST_F(InstallUtilTest, DeleteRegistryValueIf) {
   const HKEY root = HKEY_CURRENT_USER;
   std::wstring key_path(L"SomeKey\\ToDelete");
   const wchar_t value_name[] = L"some_value_name";
   const wchar_t value[] = L"hi mom";
 
   {
     RegistryOverrideManager override_manager;
     override_manager.OverrideRegistry(root, L"root_key");
     // Nothing to delete if the key isn't even there.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(_)).Times(0);
       ASSERT_FALSE(RegKey(root, key_path.c_str(), KEY_QUERY_VALUE).Valid());
       EXPECT_EQ(InstallUtil::NOT_FOUND,
                 InstallUtil::DeleteRegistryValueIf(root, key_path.c_str(),
-                                                   value_name, pred));
+                                                   value_name, pred,
+                                                   WorkItem::kWow64Default));
       EXPECT_FALSE(RegKey(root, key_path.c_str(), KEY_QUERY_VALUE).Valid());
     }
 
     // Key exists, but no value: no delete.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(_)).Times(0);
       ASSERT_TRUE(RegKey(root, key_path.c_str(), KEY_SET_VALUE).Valid());
       EXPECT_EQ(InstallUtil::NOT_FOUND,
                 InstallUtil::DeleteRegistryValueIf(root, key_path.c_str(),
-                                                   value_name, pred));
+                                                   value_name, pred,
+                                                   WorkItem::kWow64Default));
       EXPECT_TRUE(RegKey(root, key_path.c_str(), KEY_QUERY_VALUE).Valid());
     }
 
     // Value exists, but doesn't match: no delete.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(StrEq(L"foosball!"))).WillOnce(Return(false));
       ASSERT_EQ(ERROR_SUCCESS,
                 RegKey(root, key_path.c_str(),
                        KEY_SET_VALUE).WriteValue(value_name, L"foosball!"));
       EXPECT_EQ(InstallUtil::NOT_FOUND,
                 InstallUtil::DeleteRegistryValueIf(root, key_path.c_str(),
-                                                   value_name, pred));
+                                                   value_name, pred,
+                                                   WorkItem::kWow64Default));
       EXPECT_TRUE(RegKey(root, key_path.c_str(), KEY_QUERY_VALUE).Valid());
       EXPECT_TRUE(RegKey(root, key_path.c_str(),
                          KEY_QUERY_VALUE).HasValue(value_name));
     }
 
     // Value exists, and matches: delete.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(StrEq(value))).WillOnce(Return(true));
       ASSERT_EQ(ERROR_SUCCESS,
                 RegKey(root, key_path.c_str(),
                        KEY_SET_VALUE).WriteValue(value_name, value));
       EXPECT_EQ(InstallUtil::DELETED,
                 InstallUtil::DeleteRegistryValueIf(root, key_path.c_str(),
-                                                   value_name, pred));
+                                                   value_name, pred,
+                                                   WorkItem::kWow64Default));
       EXPECT_TRUE(RegKey(root, key_path.c_str(), KEY_QUERY_VALUE).Valid());
       EXPECT_FALSE(RegKey(root, key_path.c_str(),
                           KEY_QUERY_VALUE).HasValue(value_name));
     }
   }
 
   {
     RegistryOverrideManager override_manager;
     override_manager.OverrideRegistry(root, L"root_key");
     // Default value matches: delete using empty string.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(StrEq(value))).WillOnce(Return(true));
       ASSERT_EQ(ERROR_SUCCESS,
                 RegKey(root, key_path.c_str(),
                        KEY_SET_VALUE).WriteValue(L"", value));
       EXPECT_EQ(InstallUtil::DELETED,
                 InstallUtil::DeleteRegistryValueIf(root, key_path.c_str(), L"",
-                                                   pred));
+                                                   pred,
+                                                   WorkItem::kWow64Default));
       EXPECT_TRUE(RegKey(root, key_path.c_str(), KEY_QUERY_VALUE).Valid());
       EXPECT_FALSE(RegKey(root, key_path.c_str(),
                           KEY_QUERY_VALUE).HasValue(L""));
     }
   }
 
   {
     RegistryOverrideManager override_manager;
     override_manager.OverrideRegistry(root, L"root_key");
     // Default value matches: delete using NULL.
     {
       MockRegistryValuePredicate pred;
 
       EXPECT_CALL(pred, Evaluate(StrEq(value))).WillOnce(Return(true));
       ASSERT_EQ(ERROR_SUCCESS,
                 RegKey(root, key_path.c_str(),
                        KEY_SET_VALUE).WriteValue(L"", value));
       EXPECT_EQ(InstallUtil::DELETED,
                 InstallUtil::DeleteRegistryValueIf(root, key_path.c_str(),
-                                                   NULL, pred));
+                                                   NULL, pred,
+                                                   WorkItem::kWow64Default));
       EXPECT_TRUE(RegKey(root, key_path.c_str(), KEY_QUERY_VALUE).Valid());
       EXPECT_FALSE(RegKey(root, key_path.c_str(),
                           KEY_QUERY_VALUE).HasValue(L""));
     }
   }
 }
 
 TEST_F(InstallUtilTest, ValueEquals) {
   InstallUtil::ValueEquals pred(L"howdy");
 
@@ skipping 43 matching lines @@
                                      WriteInto(&short_expect, MAX_PATH),
                                      MAX_PATH);
   ASSERT_NE(static_cast<DWORD>(0), short_len);
   ASSERT_GT(static_cast<DWORD>(MAX_PATH), short_len);
   short_expect.resize(short_len);
   ASSERT_FALSE(base::FilePath::CompareEqualIgnoreCase(expect.value(),
                                                       short_expect));
   EXPECT_TRUE(InstallUtil::ProgramCompare(expect).Evaluate(
       L"\"" + short_expect + L"\""));
 }