Add WOW64 support to the installer registry work items

chrome/installer/util/shell_util.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.
 //
 // 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 30 matching lines @@
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/l10n_string_util.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/master_preferences_constants.h"
 #include "chrome/installer/util/util_constants.h"
+#include "chrome/installer/util/work_item.h"
 
 #include "installer_util_strings.h"  // NOLINT
 
 using base::win::RegKey;
 
 namespace {
 
 // An enum used to tell QuickIsChromeRegistered() which level of registration
 // the caller wants to confirm.
 enum RegistrationConfirmationLevel {
@@ skipping 463 matching lines @@
 
     // start->Internet shortcut.
     base::string16 start_menu(ShellUtil::kRegStartMenuInternet);
     base::string16 app_name = dist->GetBaseAppName() + suffix;
     entries->push_back(new RegistryEntry(start_menu, app_name));
   }
 
   // Generate work_item tasks required to create current registry entry and
   // add them to the given work item list.
   void AddToWorkItemList(HKEY root, WorkItemList *items) const {
-    items->AddCreateRegKeyWorkItem(root, key_path_);
+    items->AddCreateRegKeyWorkItem(root, key_path_, wow64_access_);
     if (is_string_) {
-      items->AddSetRegValueWorkItem(root, key_path_, name_, value_, true);
+      items->AddSetRegValueWorkItem(
+          root, key_path_, name_, value_, true, wow64_access_);
     } else {
-      items->AddSetRegValueWorkItem(root, key_path_, name_, int_value_, true);
+      items->AddSetRegValueWorkItem(
+          root, key_path_, name_, int_value_, true, wow64_access_);
     }
   }
 
   // Checks if the current registry entry exists in HKCU\|key_path_|\|name_|
   // and value is |value_|. If the key does NOT exist in HKCU, checks for
   // the correct name and value in HKLM.
   // |look_for_in| specifies roots (HKCU and/or HKLM) in which to look for the
   // key, unspecified roots are not looked into (i.e. the the key is assumed not
   // to exist in them).
   // |look_for_in| must at least specify one root to look into.
@@ skipping 19 matching lines @@
     // |name_| does not exist in the registry
     DOES_NOT_EXIST,
     // |name_| exists, but its value != |value_|
     DIFFERENT_VALUE,
     // |name_| exists and its value is |value_|
     SAME_VALUE,
   };
 
   // Create a object that represent default value of a key
   RegistryEntry(const base::string16& key_path, const base::string16& value)
-      : key_path_(key_path), name_(),
-        is_string_(true), value_(value), int_value_(0) {
-  }
+      : key_path_(key_path),
+        name_(),
+        wow64_access_(0),  // TODO(wfh): Add support for WOW64 registry view.

[grt (UTC plus 2), 2014/05/21 16:41:05]

i don't know that this class will ever need to override the default. for now,
how about making the minimal change, and just hardcoding Default in
AddToWorkItemList?

[Will Harris, 2014/05/21 23:23:16]

Done.  I think 64-bit installers will have to remove the 32-bit shell
registrations, but since this CL doesn't actually expose the full functionality
out of RegistryEntry yet, it's probably worth adding that once I actually need
it.

[grt (UTC plus 2), 2014/05/22 01:37:44]

Ah, good point. I'd forgotten about deleting the old values.

+        is_string_(true),
+        value_(value),
+        int_value_(0) {}
 
   // Create a object that represent a key of type REG_SZ
-  RegistryEntry(const base::string16& key_path, const base::string16& name,
+  RegistryEntry(const base::string16& key_path,
+                const base::string16& name,
                 const base::string16& value)
-      : key_path_(key_path), name_(name),
-        is_string_(true), value_(value), int_value_(0) {
-  }
+      : key_path_(key_path),
+        name_(name),
+        wow64_access_(0),
+        is_string_(true),
+        value_(value),
+        int_value_(0) {}
 
   // Create a object that represent a key of integer type
-  RegistryEntry(const base::string16& key_path, const base::string16& name,
+  RegistryEntry(const base::string16& key_path,
+                const base::string16& name,
                 DWORD value)
-      : key_path_(key_path), name_(name),
-        is_string_(false), value_(), int_value_(value) {
-  }
+      : key_path_(key_path),
+        name_(name),
+        wow64_access_(0),
+        is_string_(false),
+        value_(),
+        int_value_(value) {}
 
   base::string16 key_path_;  // key path for the registry entry
   base::string16 name_;      // name of the registry entry
+  // Which view of the registry to use.
+  REGSAM wow64_access_;
   bool is_string_;     // true if current registry entry is of type REG_SZ
   base::string16 value_;     // string value (useful if is_string_ = true)
   DWORD int_value_;    // integer value (useful if is_string_ = false)
 
   // Helper function for ExistsInRegistry().
   // Returns the RegistryStatus of the current registry entry in
   // |root|\|key_path_|\|name_|.
   RegistryStatus StatusInRegistryUnderRoot(HKEY root) const {
     RegKey key(root, key_path_.c_str(), KEY_QUERY_VALUE);
     bool found = false;
@@ skipping 405 matching lines @@
     // There's no need to rollback, so forgo the usual work item lists and just
     // remove the key from the registry.
     base::string16 run_verb_key(ShellUtil::kRegClasses);
     run_verb_key.push_back(base::FilePath::kSeparators[0]);
     run_verb_key.append(ShellUtil::GetBrowserModelId(
         dist, is_per_user_install));
     run_verb_key.append(ShellUtil::kRegExePath);
     run_verb_key.append(ShellUtil::kRegShellPath);
     run_verb_key.push_back(base::FilePath::kSeparators[0]);
     run_verb_key.append(ShellUtil::kRegVerbRun);
-    InstallUtil::DeleteRegistryKey(root_key, run_verb_key);
+    InstallUtil::DeleteRegistryKey(root_key, run_verb_key,
+                                   WorkItem::kWow64Default);
   }
 }
 
 // Gets the short (8.3) form of |path|, putting the result in |short_path| and
 // returning true on success.  |short_path| is not modified on failure.
 bool ShortNameFromPath(const base::FilePath& path, base::string16* short_path) {
   DCHECK(short_path);
   base::string16 result(MAX_PATH, L'\0');
   DWORD short_length = GetShortPathName(path.value().c_str(), &result[0],
                                         result.size());
@@ skipping 1230 matching lines @@
     // are any left...).
     if (free_bits >= 8 && next_byte_index < size) {
       free_bits -= 8;
       bit_stream += bytes[next_byte_index++] << free_bits;
     }
   }
 
   DCHECK_EQ(ret.length(), encoded_length);
   return ret;
 }