Allow Registry Iterator functions to use a specified WOW64 mode when iterating.

content/common/plugin_list_win.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 "content/common/plugin_list.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/file_version_info.h"
@@ skipping 75 matching lines @@
     if (hklm_key.ReadValue(kRegistryPath, &path) == ERROR_SUCCESS) {
       *out = base::FilePath(path);
       return true;
     }
   }
 
   return false;
 }
 
 // Search the registry at the given path and detect plugin directories.
-void GetPluginsInRegistryDirectory(
-    HKEY root_key,
-    const base::string16& registry_folder,
-    std::set<base::FilePath>* plugin_dirs) {
-  for (base::win::RegistryKeyIterator iter(root_key, registry_folder.c_str());
-       iter.Valid(); ++iter) {
+void GetPluginsInRegistryDirectory(HKEY root_key,
+                                   const base::string16& registry_folder,
+                                   REGSAM wow64_access,
+                                   std::set<base::FilePath>* plugin_dirs) {
+  for (base::win::RegistryKeyIterator iter(
+           root_key, registry_folder.c_str(), wow64_access);
+       iter.Valid();
+       ++iter) {
     // Use the registry to gather plugin across the file system.
     base::string16 reg_path = registry_folder;
     reg_path.append(L"\\");
     reg_path.append(iter.Name());
-    base::win::RegKey key(root_key, reg_path.c_str(), KEY_READ);
+    base::win::RegKey key(root_key, reg_path.c_str(), KEY_READ | wow64_access);
 
     base::string16 path;
     if (key.ReadValue(kRegistryPath, &path) == ERROR_SUCCESS)
       plugin_dirs->insert(base::FilePath(path));
   }
 }
 
 // Enumerate through the registry key to find all installed FireFox paths.
 // FireFox 3 beta and version 2 can coexist. See bug: 1025003
 void GetFirefoxInstalledPaths(std::vector<base::FilePath>* out) {
   base::win::RegistryKeyIterator it(HKEY_LOCAL_MACHINE,
-                                    kRegistryFirefoxInstalled);
+                                    kRegistryFirefoxInstalled,
+                                    KEY_WOW64_32KEY);
   for (; it.Valid(); ++it) {
     base::string16 full_path = base::string16(kRegistryFirefoxInstalled) +
         L"\\" + it.Name() + L"\\Main";
     base::win::RegKey key(HKEY_LOCAL_MACHINE, full_path.c_str(), KEY_READ);
     base::string16 install_dir;
     if (key.ReadValue(L"Install Directory", &install_dir) != ERROR_SUCCESS)
       continue;
     out->push_back(base::FilePath(install_dir));
   }
 }
@@ skipping 223 matching lines @@
   FindClose(find_handle);
 }
 
 void PluginList::GetPluginPathsFromRegistry(
     std::vector<base::FilePath>* plugins) {
   if (PluginList::plugins_discovery_disabled_)
     return;
 
   std::set<base::FilePath> plugin_dirs;
 
-  GetPluginsInRegistryDirectory(
-      HKEY_CURRENT_USER, kRegistryMozillaPlugins, &plugin_dirs);
-  GetPluginsInRegistryDirectory(
-      HKEY_LOCAL_MACHINE, kRegistryMozillaPlugins, &plugin_dirs);
+  GetPluginsInRegistryDirectory(HKEY_CURRENT_USER,
+                                kRegistryMozillaPlugins,
+                                0,
+                                &plugin_dirs);
+  GetPluginsInRegistryDirectory(HKEY_LOCAL_MACHINE,

[ananta, 2014/10/08 20:36:09]

Getting 32 bit plugins from a 64 bit process and vice versa. Is this needed?

[Will Harris, 2014/10/08 20:43:23]

it potentially overpopulates the list at this stage but they get filtered out by
the PE header check later on.

This is realy just to cater for some NPAPI plugins that register in the wrong
place e.g. I think quicktime does this.  If we don't care too much about this we
can search in fewer places but I thought it would better to cover all the bases.

+                                kRegistryMozillaPlugins,
+                                KEY_WOW64_64KEY,
+                                &plugin_dirs);
+  GetPluginsInRegistryDirectory(HKEY_LOCAL_MACHINE,
+                                kRegistryMozillaPlugins,
+                                KEY_WOW64_32KEY,
+                                &plugin_dirs);
 
   for (std::set<base::FilePath>::iterator i = plugin_dirs.begin();
        i != plugin_dirs.end(); ++i) {
     plugins->push_back(*i);
   }
 }
 
 bool PluginList::ShouldLoadPluginUsingPluginList(
     const WebPluginInfo& info,
     std::vector<WebPluginInfo>* plugins) {
@@ skipping 94 matching lines @@
     return false;
 #else
   // The plugin in question could be a 64 bit plugin which we cannot load.
   if (!IsValid32BitImage(base::MakeAbsoluteFilePath(plugin_path)))
     return false;
 #endif
   return true;
 }
 
 }  // namespace content