RegistryEntry: Moved ApplicationInfo and static methods out of class.

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 136 matching lines @@
 
 bool UserSpecificRegistrySuffix::GetSuffix(base::string16* suffix) {
   if (suffix_.empty()) {
     NOTREACHED();
     return false;
   }
   suffix->assign(suffix_);
   return true;
 }
 
+// Details about a Windows application, to be entered into the registry for the
+// purpose of file associations.
+struct ApplicationInfo {
+  ApplicationInfo() : file_type_icon_index(0), application_icon_index(0) {}
+
+  // The ProgId used by Windows for file associations with this application.
+  // Must not be empty or start with a '.'.
+  base::string16 prog_id;
+  // The friendly name, and the path of the icon that will be used for files of
+  // these types when associated with this application by default. (They are NOT
+  // the name/icon that will represent the application under the Open With
+  // menu.)
+  base::string16 file_type_name;
+  base::FilePath file_type_icon_path;
+  int file_type_icon_index;
+  // The command to execute when opening a file via this association. It should
+  // contain "%1" (to tell Windows to pass the filename as an argument).
+  // TODO(mgiuca): |command_line| should be a base::CommandLine.
+  base::string16 command_line;
+  // The AppUserModelId used by Windows 8 for this application. Distinct from
+  // |prog_id|.
+  base::string16 app_id;
+
+  // User-visible details about this application. Any of these may be empty.
+  base::string16 application_name;
+  base::FilePath application_icon_path;
+  int application_icon_index;
+  base::string16 application_description;
+  base::string16 publisher_name;
+
+  // The CLSID for the application's DelegateExecute handler. May be empty.
+  base::string16 delegate_clsid;
+};
+
 // This class represents a single registry entry (a key and its value). A
 // collection of registry entries should be collected into a list and written
 // transactionally using a WorkItemList. This is preferred to writing to the
 // registry directly, because if anything goes wrong, they can be rolled back.
 class RegistryEntry {
  public:
   // A bit-field enum of places to look for this key in the Windows registry.
   enum LookForIn {
     LOOK_IN_HKCU = 1 << 0,
     LOOK_IN_HKLM = 1 << 1,
     LOOK_IN_HKCU_THEN_HKLM = LOOK_IN_HKCU | LOOK_IN_HKLM,
   };
 
   // Identifies the type of removal this RegistryEntry is flagged for, if any.
   enum class RemovalFlag {
     // Default case: install the key/value.
     NONE,
     // Registry value under |key_path_|\|name_| is flagged for deletion.
     VALUE,
     // Registry key under |key_path_| is flag for deletion.
     KEY,
   };
 
-  // Details about a Windows application, to be entered into the registry for
-  // the purpose of file associations.
-  struct ApplicationInfo {
-    ApplicationInfo() : file_type_icon_index(0), application_icon_index(0) {}
-
-    // The ProgId used by Windows for file associations with this application.
-    // Must not be empty or start with a '.'.
-    base::string16 prog_id;
-    // The friendly name, and the path of the icon that will be used for files
-    // of these types when associated with this application by default. (They
-    // are NOT the name/icon that will represent the application under the Open
-    // With menu.)
-    base::string16 file_type_name;
-    base::FilePath file_type_icon_path;
-    int file_type_icon_index;
-    // The command to execute when opening a file via this association. It
-    // should contain "%1" (to tell Windows to pass the filename as an
-    // argument).
-    // TODO(mgiuca): |command_line| should be a base::CommandLine.
-    base::string16 command_line;
-    // The AppUserModelId used by Windows 8 for this application. Distinct from
-    // |prog_id|.
-    base::string16 app_id;
-
-    // User-visible details about this application. Any of these may be empty.
-    base::string16 application_name;
-    base::FilePath application_icon_path;
-    int application_icon_index;
-    base::string16 application_description;
-    base::string16 publisher_name;
-
-    // The CLSID for the application's DelegateExecute handler. May be empty.
-    base::string16 delegate_clsid;
-  };
-
   // Create an object that represent default value of a key.
   RegistryEntry(const base::string16& key_path, const base::string16& value);
 
   // Create an object that represent a key of type REG_SZ.
   RegistryEntry(const base::string16& key_path,
                 const base::string16& name,
                 const base::string16& value);
 
   // Create an object that represent a key of integer type.
   RegistryEntry(const base::string16& key_path,
                 const base::string16& name,
                 DWORD value);
 
-  // Returns the Windows browser client registration key for Chrome.  For
-  // example: "Software\Clients\StartMenuInternet\Chromium[.user]".  Strictly
-  // speaking, we should use the name of the executable (e.g., "chrome.exe"),
-  // but that ship has sailed.  The cost of switching now is re-prompting users
-  // to make Chrome their default browser, which isn't polite.  |suffix| is the
-  // user-specific registration suffix; see GetUserSpecificDefaultBrowserSuffix
-  // in shell_util.h for details.
-  static base::string16 GetBrowserClientKey(BrowserDistribution* dist,
-                                            const base::string16& suffix);
-
-  // Returns the Windows Default Programs capabilities key for Chrome.  For
-  // example:
-  // "Software\Clients\StartMenuInternet\Chromium[.user]\Capabilities".
-  static base::string16 GetCapabilitiesKey(BrowserDistribution* dist,
-                                           const base::string16& suffix);
-
-  // DelegateExecute ProgId. Needed for Chrome Metro in Windows 8. This is
-  // only needed for registring a web browser, not for general associations.
-  static ScopedVector<RegistryEntry> GetChromeDelegateExecuteEntries(
-      const base::FilePath& chrome_exe,
-      const ApplicationInfo& app_info);
-
-  // This method returns a list of all the registry entries that
-  // are needed to register this installation's ProgId and AppId.
-  // These entries need to be registered in HKLM prior to Win8.
-  static void GetChromeProgIdEntries(BrowserDistribution* dist,
-                                     const base::FilePath& chrome_exe,
-                                     const base::string16& suffix,
-                                     ScopedVector<RegistryEntry>* entries);
-
-  // Gets the registry entries to register an application in the Windows
-  // registry. |app_info| provides all of the information needed.
-  static void GetProgIdEntries(const ApplicationInfo& app_info,
-                               ScopedVector<RegistryEntry>* entries);
-
-  // This method returns a list of the registry entries needed to declare a
-  // capability of handling a protocol on Windows.
-  static void GetProtocolCapabilityEntries(
-      BrowserDistribution* dist,
-      const base::string16& suffix,
-      const base::string16& protocol,
-      ScopedVector<RegistryEntry>* entries);
-
-  // This method returns a list of the registry entries required to register
-  // this installation in "RegisteredApplications" on Windows (to appear in
-  // Default Programs, StartMenuInternet, etc.).
-  // These entries need to be registered in HKLM prior to Win8.
-  // If |suffix| is not empty, these entries are guaranteed to be unique on this
-  // machine.
-  static void GetShellIntegrationEntries(BrowserDistribution* dist,
-                                         const base::FilePath& chrome_exe,
-                                         const base::string16& suffix,
-                                         ScopedVector<RegistryEntry>* entries);
-
-  // This method returns a list of the registry entries required for this
-  // installation to be registered in the Windows shell.
-  // In particular:
-  //  - App Paths
-  //    http://msdn.microsoft.com/en-us/library/windows/desktop/ee872121
-  //  - File Associations
-  //    http://msdn.microsoft.com/en-us/library/bb166549
-  // These entries need to be registered in HKLM prior to Win8.
-  static void GetChromeAppRegistrationEntries(
-      const base::FilePath& chrome_exe,
-      const base::string16& suffix,
-      ScopedVector<RegistryEntry>* entries);
-
-  // Gets the registry entries to register an application as a handler for a
-  // particular file extension. |prog_id| is the ProgId used by Windows for the
-  // application. |ext| is the file extension, which must begin with a '.'.
-  static void GetAppExtRegistrationEntries(
-      const base::string16& prog_id,
-      const base::string16& ext,
-      ScopedVector<RegistryEntry>* entries);
-
-  // Gets the registry entries to register an application as the default handler
-  // for a particular file extension. |prog_id| is the ProgId used by Windows
-  // for the application. |ext| is the file extension, which must begin with a
-  // '.'. If |overwrite_existing|, always sets the default handler; otherwise
-  // only sets if there is no existing default.
-  //
-  // This has no effect on Windows 8. Windows 8 ignores the default and lets the
-  // user choose. If there is only one handler for a file, it will automatically
-  // become the default. Otherwise, the first time the user opens a file, they
-  // are presented with the dialog to set the default handler. (This is roughly
-  // equivalent to being called with |overwrite_existing| false.)
-  static void GetAppDefaultRegistrationEntries(
-      const base::string16& prog_id,
-      const base::string16& ext,
-      bool overwrite_existing,
-      ScopedVector<RegistryEntry>* entries);
-
-  // This method returns a list of all the user level registry entries that
-  // are needed to make Chromium the default handler for a protocol on XP.
-  static void GetXPStyleUserProtocolEntries(
-      const base::string16& protocol,
-      const base::string16& chrome_icon,
-      const base::string16& chrome_open,
-      ScopedVector<RegistryEntry>* entries);
-
-  // This method returns a list of all the user level registry entries that
-  // are needed to make Chromium default browser on XP.
-  // Some of these entries are irrelevant in recent versions of Windows, but
-  // we register them anyways as some legacy apps are hardcoded to lookup those
-  // values.
-  static void GetXPStyleDefaultBrowserUserEntries(
-      BrowserDistribution* dist,
-      const base::FilePath& chrome_exe,
-      const base::string16& suffix,
-      ScopedVector<RegistryEntry>* entries);
-
   // Flags this RegistryKey with |removal_flag|, indicating that it should be
   // removed rather than created. Note that this will not result in cleaning up
   // the entire registry hierarchy below RegistryEntry even if it is left empty
   // by this operation (this should thus not be used for uninstall, but only to
   // unregister keys that should explicitly no longer be active in the current
   // configuration).
   void set_removal_flag(RemovalFlag removal_flag) {
     removal_flag_ = removal_flag;
   }
 
@@ skipping 78 matching lines @@
 RegistryEntry::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),
       removal_flag_(RemovalFlag::NONE) {}
 
-// static
-base::string16 RegistryEntry::GetBrowserClientKey(
-    BrowserDistribution* dist,
-    const base::string16& suffix) {
+void RegistryEntry::AddToWorkItemList(HKEY root, WorkItemList* items) const {
+  if (removal_flag_ == RemovalFlag::VALUE) {
+    items->AddDeleteRegValueWorkItem(root, key_path_, WorkItem::kWow64Default,
+                                     name_);
+  } else if (removal_flag_ == RemovalFlag::KEY) {
+    items->AddDeleteRegKeyWorkItem(root, key_path_, WorkItem::kWow64Default);
+  } else {
+    DCHECK(removal_flag_ == RemovalFlag::NONE);
+    items->AddCreateRegKeyWorkItem(root, key_path_, WorkItem::kWow64Default);
+    if (is_string_) {
+      items->AddSetRegValueWorkItem(root, key_path_, WorkItem::kWow64Default,
+                                    name_, value_, true);
+    } else {
+      items->AddSetRegValueWorkItem(root, key_path_, WorkItem::kWow64Default,
+                                    name_, int_value_, true);
+    }
+  }
+}
+
+bool RegistryEntry::ExistsInRegistry(uint32 look_for_in) const {
+  DCHECK(look_for_in);
+
+  RegistryStatus status = DOES_NOT_EXIST;
+  if (look_for_in & LOOK_IN_HKCU)
+    status = StatusInRegistryUnderRoot(HKEY_CURRENT_USER);
+  if (status == DOES_NOT_EXIST && (look_for_in & LOOK_IN_HKLM))
+    status = StatusInRegistryUnderRoot(HKEY_LOCAL_MACHINE);
+  return status == SAME_VALUE;
+}
+
+bool RegistryEntry::KeyExistsInRegistry(uint32 look_for_in) const {
+  DCHECK(look_for_in);
+
+  RegistryStatus status = DOES_NOT_EXIST;
+  if (look_for_in & LOOK_IN_HKCU)
+    status = StatusInRegistryUnderRoot(HKEY_CURRENT_USER);
+  if (status == DOES_NOT_EXIST && (look_for_in & LOOK_IN_HKLM))
+    status = StatusInRegistryUnderRoot(HKEY_LOCAL_MACHINE);
+  return status != DOES_NOT_EXIST;
+}
+
+RegistryEntry::RegistryStatus RegistryEntry::StatusInRegistryUnderRoot(
+    HKEY root) const {
+  RegKey key(root, key_path_.c_str(), KEY_QUERY_VALUE);
+  bool found = false;
+  bool correct_value = false;
+  if (is_string_) {
+    base::string16 read_value;
+    found = key.ReadValue(name_.c_str(), &read_value) == ERROR_SUCCESS;
+    if (found) {
+      correct_value =
+          read_value.size() == value_.size() &&
+          ::CompareString(
+              LOCALE_USER_DEFAULT, NORM_IGNORECASE, read_value.data(),
+              base::saturated_cast<int>(read_value.size()), value_.data(),
+              base::saturated_cast<int>(value_.size())) == CSTR_EQUAL;
+    }
+  } else {
+    DWORD read_value;
+    found = key.ReadValueDW(name_.c_str(), &read_value) == ERROR_SUCCESS;
+    if (found)
+      correct_value = read_value == int_value_;
+  }
+  return found ? (correct_value ? SAME_VALUE : DIFFERENT_VALUE)
+               : DOES_NOT_EXIST;
+}
+
+// Returns the Windows browser client registration key for Chrome.  For example:
+// "Software\Clients\StartMenuInternet\Chromium[.user]".  Strictly speaking, we
+// should use the name of the executable (e.g., "chrome.exe"), but that ship has
+// sailed.  The cost of switching now is re-prompting users to make Chrome their
+// default browser, which isn't polite.  |suffix| is the user-specific
+// registration suffix; see GetUserSpecificDefaultBrowserSuffix in shell_util.h
+// for details.
+base::string16 GetBrowserClientKey(BrowserDistribution* dist,
+                                   const base::string16& suffix) {
   DCHECK(suffix.empty() || suffix[0] == L'.');
   return base::string16(ShellUtil::kRegStartMenuInternet)
       .append(1, L'\\')
       .append(dist->GetBaseAppName())
       .append(suffix);
 }
 
-// static
-base::string16 RegistryEntry::GetCapabilitiesKey(BrowserDistribution* dist,
-                                                 const base::string16& suffix) {
+// Returns the Windows Default Programs capabilities key for Chrome.  For
+// example:
+// "Software\Clients\StartMenuInternet\Chromium[.user]\Capabilities".
+base::string16 GetCapabilitiesKey(BrowserDistribution* dist,
+                                  const base::string16& suffix) {
   return GetBrowserClientKey(dist, suffix).append(L"\\Capabilities");
 }
 
-// static
-ScopedVector<RegistryEntry> RegistryEntry::GetChromeDelegateExecuteEntries(
+// DelegateExecute ProgId. Needed for Chrome Metro in Windows 8. This is only
+// needed for registring a web browser, not for general associations.
+ScopedVector<RegistryEntry> GetChromeDelegateExecuteEntries(
     const base::FilePath& chrome_exe,
-    const RegistryEntry::ApplicationInfo& app_info) {
+    const ApplicationInfo& app_info) {
   ScopedVector<RegistryEntry> entries;
 
   base::string16 app_id_shell_key(ShellUtil::kRegClasses);
   app_id_shell_key.push_back(base::FilePath::kSeparators[0]);
   app_id_shell_key.append(app_info.app_id);
   app_id_shell_key.append(ShellUtil::kRegExePath);
   app_id_shell_key.append(ShellUtil::kRegShellPath);
 
   // <root hkey>\Software\Classes\<app_id>\.exe\shell @=open
   entries.push_back(
@@ skipping 37 matching lines @@
 
     // <root hkey>\Software\Classes\<app_id>\.exe\shell\<verb>\command
     entries.push_back(new RegistryEntry(sub_path, delegate_command));
     entries.push_back(new RegistryEntry(
         sub_path, ShellUtil::kRegDelegateExecute, app_info.delegate_clsid));
   }
 
   return entries.Pass();
 }
 
-// static
-void RegistryEntry::GetChromeProgIdEntries(
-    BrowserDistribution* dist,
-    const base::FilePath& chrome_exe,
-    const base::string16& suffix,
-    ScopedVector<RegistryEntry>* entries) {
-  int chrome_icon_index =
-      dist->GetIconIndex(BrowserDistribution::SHORTCUT_CHROME);
-
-  ApplicationInfo app_info;
-  app_info.prog_id = GetBrowserProgId(suffix);
-  app_info.file_type_name = dist->GetBrowserProgIdDesc();
-  // File types associated with Chrome are just given the Chrome icon.
-  app_info.file_type_icon_path = chrome_exe;
-  app_info.file_type_icon_index = chrome_icon_index;
-  app_info.command_line = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
-  // For user-level installs: entries for the app id will be in HKCU; thus we
-  // do not need a suffix on those entries.
-  app_info.app_id = ShellUtil::GetBrowserModelId(
-      dist, InstallUtil::IsPerUserInstall(chrome_exe));
-
-  // TODO(grt): http://crbug.com/75152 Write a reference to a localized
-  // resource for name, description, and company.
-  app_info.application_name = dist->GetDisplayName();
-  app_info.application_icon_path = chrome_exe;
-  app_info.application_icon_index = chrome_icon_index;
-  app_info.application_description = dist->GetAppDescription();
-  app_info.publisher_name = dist->GetPublisherName();
-
-  app_info.delegate_clsid = dist->GetCommandExecuteImplClsid();
-
-  GetProgIdEntries(app_info, entries);
-
-  if (!app_info.delegate_clsid.empty()) {
-    ScopedVector<RegistryEntry> delegate_execute_entries =
-        GetChromeDelegateExecuteEntries(chrome_exe, app_info);
-    if (!base::win::IsChromeMetroSupported()) {
-      // Remove the keys (not only their values) so that Windows will continue
-      // to launch Chrome without a pesky association error.
-      for (RegistryEntry* entry : delegate_execute_entries)
-        entry->set_removal_flag(RemovalFlag::KEY);
-    }
-    // Move |delegate_execute_entries| to |entries|.
-    entries->insert(entries->end(), delegate_execute_entries.begin(),
-                    delegate_execute_entries.end());
-    delegate_execute_entries.weak_clear();
-  }
-}
-
-// static
-void RegistryEntry::GetProgIdEntries(
-    const RegistryEntry::ApplicationInfo& app_info,
-    ScopedVector<RegistryEntry>* entries) {
+// Gets the registry entries to register an application in the Windows registry.
+// |app_info| provides all of the information needed.
+void GetProgIdEntries(const ApplicationInfo& app_info,
+                      ScopedVector<RegistryEntry>* entries) {
   // Basic sanity checks.
   DCHECK(!app_info.prog_id.empty());
   DCHECK_NE(L'.', app_info.prog_id[0]);
 
   // File association ProgId
   base::string16 prog_id_path(ShellUtil::kRegClasses);
   prog_id_path.push_back(base::FilePath::kSeparators[0]);
   prog_id_path.append(app_info.prog_id);
   entries->push_back(new RegistryEntry(prog_id_path, app_info.file_type_name));
   entries->push_back(new RegistryEntry(
       prog_id_path + ShellUtil::kRegDefaultIcon,
       ShellUtil::FormatIconLocation(app_info.file_type_icon_path,
                                     app_info.file_type_icon_index)));
   entries->push_back(new RegistryEntry(prog_id_path + ShellUtil::kRegShellOpen,
                                        app_info.command_line));
   if (!app_info.delegate_clsid.empty()) {
     entries->push_back(new RegistryEntry(
         prog_id_path + ShellUtil::kRegShellOpen, ShellUtil::kRegDelegateExecute,
         app_info.delegate_clsid));
     // If Metro is not supported, remove the DelegateExecute entry instead of
     // adding it.
     if (!base::win::IsChromeMetroSupported())
-      entries->back()->set_removal_flag(RemovalFlag::VALUE);
+      entries->back()->set_removal_flag(RegistryEntry::RemovalFlag::VALUE);
   }
 
   // The following entries are required as of Windows 8, but do not
   // depend on the DelegateExecute verb handler being set.
   if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
     if (!app_info.app_id.empty()) {
       entries->push_back(new RegistryEntry(
           prog_id_path, ShellUtil::kRegAppUserModelId, app_info.app_id));
     }
 
@@ skipping 20 matching lines @@
           app_info.application_description));
     }
     if (!app_info.publisher_name.empty()) {
       entries->push_back(new RegistryEntry(application_path,
                                            ShellUtil::kRegApplicationCompany,
                                            app_info.publisher_name));
     }
   }
 }
 
-// static
-void RegistryEntry::GetProtocolCapabilityEntries(
-    BrowserDistribution* dist,
-    const base::string16& suffix,
-    const base::string16& protocol,
-    ScopedVector<RegistryEntry>* entries) {
+// This method returns a list of all the registry entries that are needed to
+// register this installation's ProgId and AppId. These entries need to be
+// registered in HKLM prior to Win8.
+void GetChromeProgIdEntries(BrowserDistribution* dist,
+                            const base::FilePath& chrome_exe,
+                            const base::string16& suffix,
+                            ScopedVector<RegistryEntry>* entries) {
+  int chrome_icon_index =
+      dist->GetIconIndex(BrowserDistribution::SHORTCUT_CHROME);
+
+  ApplicationInfo app_info;
+  app_info.prog_id = GetBrowserProgId(suffix);
+  app_info.file_type_name = dist->GetBrowserProgIdDesc();
+  // File types associated with Chrome are just given the Chrome icon.
+  app_info.file_type_icon_path = chrome_exe;
+  app_info.file_type_icon_index = chrome_icon_index;
+  app_info.command_line = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
+  // For user-level installs: entries for the app id will be in HKCU; thus we
+  // do not need a suffix on those entries.
+  app_info.app_id = ShellUtil::GetBrowserModelId(
+      dist, InstallUtil::IsPerUserInstall(chrome_exe));
+
+  // TODO(grt): http://crbug.com/75152 Write a reference to a localized
+  // resource for name, description, and company.
+  app_info.application_name = dist->GetDisplayName();
+  app_info.application_icon_path = chrome_exe;
+  app_info.application_icon_index = chrome_icon_index;
+  app_info.application_description = dist->GetAppDescription();
+  app_info.publisher_name = dist->GetPublisherName();
+
+  app_info.delegate_clsid = dist->GetCommandExecuteImplClsid();
+
+  GetProgIdEntries(app_info, entries);
+
+  if (!app_info.delegate_clsid.empty()) {
+    ScopedVector<RegistryEntry> delegate_execute_entries =
+        GetChromeDelegateExecuteEntries(chrome_exe, app_info);
+    if (!base::win::IsChromeMetroSupported()) {
+      // Remove the keys (not only their values) so that Windows will continue
+      // to launch Chrome without a pesky association error.
+      for (RegistryEntry* entry : delegate_execute_entries)
+        entry->set_removal_flag(RegistryEntry::RemovalFlag::KEY);
+    }
+    // Move |delegate_execute_entries| to |entries|.
+    entries->insert(entries->end(), delegate_execute_entries.begin(),
+                    delegate_execute_entries.end());
+    delegate_execute_entries.weak_clear();
+  }
+}
+
+// This method returns a list of the registry entries needed to declare a
+// capability of handling a protocol on Windows.
+void GetProtocolCapabilityEntries(BrowserDistribution* dist,
+                                  const base::string16& suffix,
+                                  const base::string16& protocol,
+                                  ScopedVector<RegistryEntry>* entries) {
   entries->push_back(new RegistryEntry(
       GetCapabilitiesKey(dist, suffix).append(L"\\URLAssociations"), protocol,
       GetBrowserProgId(suffix)));
 }
 
-// static
-void RegistryEntry::GetShellIntegrationEntries(
-    BrowserDistribution* dist,
-    const base::FilePath& chrome_exe,
-    const base::string16& suffix,
-    ScopedVector<RegistryEntry>* entries) {
+// This method returns a list of the registry entries required to register this
+// installation in "RegisteredApplications" on Windows (to appear in Default
+// Programs, StartMenuInternet, etc.). These entries need to be registered in
+// HKLM prior to Win8. If |suffix| is not empty, these entries are guaranteed to
+// be unique on this machine.
+void GetShellIntegrationEntries(BrowserDistribution* dist,
+                                const base::FilePath& chrome_exe,
+                                const base::string16& suffix,
+                                ScopedVector<RegistryEntry>* entries) {
   const base::string16 icon_path(ShellUtil::FormatIconLocation(
       chrome_exe, dist->GetIconIndex(BrowserDistribution::SHORTCUT_CHROME)));
   const base::string16 quoted_exe_path(L"\"" + chrome_exe.value() + L"\"");
 
   // Register for the Start Menu "Internet" link (pre-Win7).
   const base::string16 start_menu_entry(GetBrowserClientKey(dist, suffix));
   // Register Chrome's display name.
   // TODO(grt): http://crbug.com/75152 Also set LocalizedString; see
   // http://msdn.microsoft.com/en-us/library/windows/desktop/cc144109(v=VS.85).aspx#registering_the_display_name
   entries->push_back(
@@ skipping 47 matching lines @@
         capabilities + L"\\FileAssociations",
         ShellUtil::kPotentialFileAssociations[i], html_prog_id));
   }
   for (int i = 0; ShellUtil::kPotentialProtocolAssociations[i] != NULL; i++) {
     entries->push_back(new RegistryEntry(
         capabilities + L"\\URLAssociations",
         ShellUtil::kPotentialProtocolAssociations[i], html_prog_id));
   }
 }
 
-// static
-void RegistryEntry::GetChromeAppRegistrationEntries(
-    const base::FilePath& chrome_exe,
-    const base::string16& suffix,
-    ScopedVector<RegistryEntry>* entries) {
+// Gets the registry entries to register an application as a handler for a
+// particular file extension. |prog_id| is the ProgId used by Windows for the
+// application. |ext| is the file extension, which must begin with a '.'.
+void GetAppExtRegistrationEntries(const base::string16& prog_id,
+                                  const base::string16& ext,
+                                  ScopedVector<RegistryEntry>* entries) {
+  // In HKEY_CURRENT_USER\Software\Classes\EXT\OpenWithProgids, create an
+  // empty value with this class's ProgId.
+  base::string16 key_name(ShellUtil::kRegClasses);
+  key_name.push_back(base::FilePath::kSeparators[0]);
+  key_name.append(ext);
+  key_name.push_back(base::FilePath::kSeparators[0]);
+  key_name.append(ShellUtil::kRegOpenWithProgids);
+  entries->push_back(new RegistryEntry(key_name, prog_id, base::string16()));
+}
+
+// This method returns a list of the registry entries required for this
+// installation to be registered in the Windows shell.
+// In particular:
+//  - App Paths
+//    http://msdn.microsoft.com/en-us/library/windows/desktop/ee872121
+//  - File Associations
+//    http://msdn.microsoft.com/en-us/library/bb166549
+// These entries need to be registered in HKLM prior to Win8.
+void GetChromeAppRegistrationEntries(const base::FilePath& chrome_exe,
+                                     const base::string16& suffix,
+                                     ScopedVector<RegistryEntry>* entries) {
   base::string16 app_path_key(ShellUtil::kAppPathsRegistryKey);
   app_path_key.push_back(base::FilePath::kSeparators[0]);
   app_path_key.append(chrome_exe.BaseName().value());
   entries->push_back(new RegistryEntry(app_path_key, chrome_exe.value()));
   entries->push_back(new RegistryEntry(app_path_key,
                                        ShellUtil::kAppPathsRegistryPathName,
                                        chrome_exe.DirName().value()));
 
   const base::string16 html_prog_id(GetBrowserProgId(suffix));
   for (int i = 0; ShellUtil::kPotentialFileAssociations[i] != NULL; i++) {
     GetAppExtRegistrationEntries(
         html_prog_id, ShellUtil::kPotentialFileAssociations[i], entries);
   }
 }
 
-// static
-void RegistryEntry::GetAppExtRegistrationEntries(
-    const base::string16& prog_id,
-    const base::string16& ext,
-    ScopedVector<RegistryEntry>* entries) {
-  // In HKEY_CURRENT_USER\Software\Classes\EXT\OpenWithProgids, create an
-  // empty value with this class's ProgId.
-  base::string16 key_name(ShellUtil::kRegClasses);
-  key_name.push_back(base::FilePath::kSeparators[0]);
-  key_name.append(ext);
-  key_name.push_back(base::FilePath::kSeparators[0]);
-  key_name.append(ShellUtil::kRegOpenWithProgids);
-  entries->push_back(new RegistryEntry(key_name, prog_id, base::string16()));
-}
-
-// static
-void RegistryEntry::GetAppDefaultRegistrationEntries(
-    const base::string16& prog_id,
-    const base::string16& ext,
-    bool overwrite_existing,
-    ScopedVector<RegistryEntry>* entries) {
+// Gets the registry entries to register an application as the default handler
+// for a particular file extension. |prog_id| is the ProgId used by Windows for
+// the application. |ext| is the file extension, which must begin with a '.'. If
+// |overwrite_existing|, always sets the default handler; otherwise only sets if
+// there is no existing default.
+//
+// This has no effect on Windows 8. Windows 8 ignores the default and lets the
+// user choose. If there is only one handler for a file, it will automatically
+// become the default. Otherwise, the first time the user opens a file, they are
+// presented with the dialog to set the default handler. (This is roughly
+// equivalent to being called with |overwrite_existing| false.)
+void GetAppDefaultRegistrationEntries(const base::string16& prog_id,
+                                      const base::string16& ext,
+                                      bool overwrite_existing,
+                                      ScopedVector<RegistryEntry>* entries) {
   // Set the default value of HKEY_CURRENT_USER\Software\Classes\EXT to this
   // class's name.
   base::string16 key_name(ShellUtil::kRegClasses);
   key_name.push_back(base::FilePath::kSeparators[0]);
   key_name.append(ext);
   scoped_ptr<RegistryEntry> default_association(
       new RegistryEntry(key_name, prog_id));
   if (overwrite_existing ||
       !default_association->KeyExistsInRegistry(RegistryEntry::LOOK_IN_HKCU)) {
     entries->push_back(default_association.release());
   }
 }
 
-// static
-void RegistryEntry::GetXPStyleUserProtocolEntries(
-    const base::string16& protocol,
-    const base::string16& chrome_icon,
-    const base::string16& chrome_open,
-    ScopedVector<RegistryEntry>* entries) {
+// This method returns a list of all the user level registry entries that are
+// needed to make Chromium the default handler for a protocol on XP.
+void GetXPStyleUserProtocolEntries(const base::string16& protocol,
+                                   const base::string16& chrome_icon,
+                                   const base::string16& chrome_open,
+                                   ScopedVector<RegistryEntry>* entries) {
   // Protocols associations.
   base::string16 url_key(ShellUtil::kRegClasses);
   url_key.push_back(base::FilePath::kSeparators[0]);
   url_key.append(protocol);
 
   // This registry value tells Windows that this 'class' is a URL scheme
   // so IE, explorer and other apps will route it to our handler.
   // <root hkey>\Software\Classes\<protocol>\URL Protocol
   entries->push_back(
       new RegistryEntry(url_key, ShellUtil::kRegUrlProtocol, base::string16()));
 
   // <root hkey>\Software\Classes\<protocol>\DefaultIcon
   base::string16 icon_key = url_key + ShellUtil::kRegDefaultIcon;
   entries->push_back(new RegistryEntry(icon_key, chrome_icon));
 
   // <root hkey>\Software\Classes\<protocol>\shell\open\command
   base::string16 shell_key = url_key + ShellUtil::kRegShellOpen;
   entries->push_back(new RegistryEntry(shell_key, chrome_open));
 
   // <root hkey>\Software\Classes\<protocol>\shell\open\ddeexec
   base::string16 dde_key = url_key + L"\\shell\\open\\ddeexec";
   entries->push_back(new RegistryEntry(dde_key, base::string16()));
 
   // <root hkey>\Software\Classes\<protocol>\shell\@
   base::string16 protocol_shell_key = url_key + ShellUtil::kRegShellPath;
   entries->push_back(new RegistryEntry(protocol_shell_key, L"open"));
 }
 
-// static
-void RegistryEntry::GetXPStyleDefaultBrowserUserEntries(
-    BrowserDistribution* dist,
-    const base::FilePath& chrome_exe,
-    const base::string16& suffix,
-    ScopedVector<RegistryEntry>* entries) {
+// This method returns a list of all the user level registry entries that are
+// needed to make Chromium default browser on XP. Some of these entries are
+// irrelevant in recent versions of Windows, but we register them anyways as
+// some legacy apps are hardcoded to lookup those values.
+void GetXPStyleDefaultBrowserUserEntries(BrowserDistribution* dist,
+                                         const base::FilePath& chrome_exe,
+                                         const base::string16& suffix,
+                                         ScopedVector<RegistryEntry>* entries) {
   // File extension associations.
   base::string16 html_prog_id(GetBrowserProgId(suffix));
   for (int i = 0; ShellUtil::kDefaultFileAssociations[i] != NULL; i++) {
     GetAppDefaultRegistrationEntries(
         html_prog_id, ShellUtil::kDefaultFileAssociations[i], true, entries);
   }
 
   // Protocols associations.
   base::string16 chrome_open = ShellUtil::GetChromeShellOpenCmd(chrome_exe);
   base::string16 chrome_icon = ShellUtil::FormatIconLocation(
       chrome_exe, dist->GetIconIndex(BrowserDistribution::SHORTCUT_CHROME));
   for (int i = 0; ShellUtil::kBrowserProtocolAssociations[i] != NULL; i++) {
     GetXPStyleUserProtocolEntries(ShellUtil::kBrowserProtocolAssociations[i],
                                   chrome_icon, chrome_open, entries);
   }
 
   // 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));
 }
 
-void RegistryEntry::AddToWorkItemList(HKEY root, WorkItemList* items) const {
-  if (removal_flag_ == RemovalFlag::VALUE) {
-    items->AddDeleteRegValueWorkItem(root, key_path_, WorkItem::kWow64Default,
-                                     name_);
-  } else if (removal_flag_ == RemovalFlag::KEY) {
-    items->AddDeleteRegKeyWorkItem(root, key_path_, WorkItem::kWow64Default);
-  } else {
-    DCHECK(removal_flag_ == RemovalFlag::NONE);
-    items->AddCreateRegKeyWorkItem(root, key_path_, WorkItem::kWow64Default);
-    if (is_string_) {
-      items->AddSetRegValueWorkItem(root, key_path_, WorkItem::kWow64Default,
-                                    name_, value_, true);
-    } else {
-      items->AddSetRegValueWorkItem(root, key_path_, WorkItem::kWow64Default,
-                                    name_, int_value_, true);
-    }
-  }
-}
-
-bool RegistryEntry::ExistsInRegistry(uint32 look_for_in) const {
-  DCHECK(look_for_in);
-
-  RegistryStatus status = DOES_NOT_EXIST;
-  if (look_for_in & LOOK_IN_HKCU)
-    status = StatusInRegistryUnderRoot(HKEY_CURRENT_USER);
-  if (status == DOES_NOT_EXIST && (look_for_in & LOOK_IN_HKLM))
-    status = StatusInRegistryUnderRoot(HKEY_LOCAL_MACHINE);
-  return status == SAME_VALUE;
-}
-
-bool RegistryEntry::KeyExistsInRegistry(uint32 look_for_in) const {
-  DCHECK(look_for_in);
-
-  RegistryStatus status = DOES_NOT_EXIST;
-  if (look_for_in & LOOK_IN_HKCU)
-    status = StatusInRegistryUnderRoot(HKEY_CURRENT_USER);
-  if (status == DOES_NOT_EXIST && (look_for_in & LOOK_IN_HKLM))
-    status = StatusInRegistryUnderRoot(HKEY_LOCAL_MACHINE);
-  return status != DOES_NOT_EXIST;
-}
-
-RegistryEntry::RegistryStatus RegistryEntry::StatusInRegistryUnderRoot(
-    HKEY root) const {
-  RegKey key(root, key_path_.c_str(), KEY_QUERY_VALUE);
-  bool found = false;
-  bool correct_value = false;
-  if (is_string_) {
-    base::string16 read_value;
-    found = key.ReadValue(name_.c_str(), &read_value) == ERROR_SUCCESS;
-    if (found) {
-      correct_value =
-          read_value.size() == value_.size() &&
-          ::CompareString(
-              LOCALE_USER_DEFAULT, NORM_IGNORECASE, read_value.data(),
-              base::saturated_cast<int>(read_value.size()), value_.data(),
-              base::saturated_cast<int>(value_.size())) == CSTR_EQUAL;
-    }
-  } else {
-    DWORD read_value;
-    found = key.ReadValueDW(name_.c_str(), &read_value) == ERROR_SUCCESS;
-    if (found)
-      correct_value = read_value == int_value_;
-  }
-  return found ? (correct_value ? SAME_VALUE : DIFFERENT_VALUE)
-               : DOES_NOT_EXIST;
-}
-
 // This method converts all the RegistryEntries from the given list to
 // Set/CreateRegWorkItems and runs them using WorkItemList.
 bool AddRegistryEntries(HKEY root, const ScopedVector<RegistryEntry>& entries) {
   scoped_ptr<WorkItemList> items(WorkItem::CreateWorkItemList());
 
   for (ScopedVector<RegistryEntry>::const_iterator itr = entries.begin();
        itr != entries.end(); ++itr)
     (*itr)->AddToWorkItemList(root, items.get());
 
   // Apply all the registry changes and if there is a problem, rollback
@@ skipping 24 matching lines @@
 // under a single registry root. Not doing so caused http://crbug.com/144910 for
 // users who first-installed Chrome in that revision range (those users are
 // still impacted by http://crbug.com/144910). This method will keep returning
 // true for affected users (i.e. who have all the registrations, but over both
 // registry roots).
 bool IsChromeRegistered(BrowserDistribution* dist,
                         const base::FilePath& chrome_exe,
                         const base::string16& suffix,
                         uint32 look_for_in) {
   ScopedVector<RegistryEntry> entries;
-  RegistryEntry::GetChromeProgIdEntries(dist, chrome_exe, suffix, &entries);
-  RegistryEntry::GetShellIntegrationEntries(dist, chrome_exe, suffix, &entries);
-  RegistryEntry::GetChromeAppRegistrationEntries(chrome_exe, suffix, &entries);
+  GetChromeProgIdEntries(dist, chrome_exe, suffix, &entries);
+  GetShellIntegrationEntries(dist, chrome_exe, suffix, &entries);
+  GetChromeAppRegistrationEntries(chrome_exe, suffix, &entries);
   return AreEntriesAsDesired(entries, look_for_in);
 }
 
 // This method checks if Chrome is already registered on the local machine
 // for the requested protocol. It just checks the one value required for this.
 // See RegistryEntry::ExistsInRegistry for the behavior of |look_for_in|.
 bool IsChromeRegisteredForProtocol(BrowserDistribution* dist,
                                    const base::string16& suffix,
                                    const base::string16& protocol,
                                    uint32 look_for_in) {
   ScopedVector<RegistryEntry> entries;
-  RegistryEntry::GetProtocolCapabilityEntries(dist, suffix, protocol, &entries);
+  GetProtocolCapabilityEntries(dist, suffix, protocol, &entries);
   return AreEntriesAsDesired(entries, look_for_in);
 }
 
 // This method registers Chrome on Vista by launching an elevated setup.exe.
 // That will show the user the standard Vista elevation prompt. If the user
 // accepts it the new process will make the necessary changes and return SUCCESS
 // that we capture and return.
 // If protocol is non-empty we will also register Chrome as being capable of
 // handling the protocol.
 bool ElevateAndRegisterChrome(BrowserDistribution* dist,
@@ skipping 100 matching lines @@
     case CONFIRM_PROGID_REGISTRATION:
       // Software\Classes\ChromeHTML|suffix|
       reg_key = ShellUtil::kRegClasses;
       reg_key.push_back(base::FilePath::kSeparators[0]);
       reg_key.append(dist->GetBrowserProgIdPrefix());
       reg_key.append(suffix);
       break;
     case CONFIRM_SHELL_REGISTRATION:
     case CONFIRM_SHELL_REGISTRATION_IN_HKLM:
       // Software\Clients\StartMenuInternet\Google Chrome|suffix|
-      reg_key = RegistryEntry::GetBrowserClientKey(dist, suffix);
+      reg_key = GetBrowserClientKey(dist, suffix);
       break;
     default:
       NOTREACHED();
       break;
   }
   reg_key.append(ShellUtil::kRegShellOpen);
 
   // ProgId registrations are allowed to reside in HKCU for user-level installs
   // (and values there have priority over values in HKLM). The same is true for
   // shell integration entries as of Windows 8.
@@ skipping 61 matching lines @@
 }
 
 // Associates Chrome with supported protocols and file associations. This should
 // not be required on Vista+ but since some applications still read
 // Software\Classes\http key directly, we have to do this on Vista+ as well.
 bool RegisterChromeAsDefaultXPStyle(BrowserDistribution* dist,
                                     int shell_change,
                                     const base::FilePath& chrome_exe) {
   bool ret = true;
   ScopedVector<RegistryEntry> entries;
-  RegistryEntry::GetXPStyleDefaultBrowserUserEntries(
+  GetXPStyleDefaultBrowserUserEntries(
       dist, chrome_exe,
       ShellUtil::GetCurrentInstallationSuffix(dist, chrome_exe), &entries);
 
   // Change the default browser for current user.
   if ((shell_change & ShellUtil::CURRENT_USER) &&
       !AddRegistryEntries(HKEY_CURRENT_USER, entries)) {
     ret = false;
     LOG(ERROR) << "Could not make Chrome default browser (XP/current user).";
   }
 
@@ skipping 15 matching lines @@
     BrowserDistribution* dist,
     const base::FilePath& chrome_exe,
     const base::string16& protocol) {
   ScopedVector<RegistryEntry> entries;
   const base::string16 chrome_open(
       ShellUtil::GetChromeShellOpenCmd(chrome_exe));
   const base::string16 chrome_icon(
       ShellUtil::FormatIconLocation(
           chrome_exe,
           dist->GetIconIndex(BrowserDistribution::SHORTCUT_CHROME)));
-  RegistryEntry::GetXPStyleUserProtocolEntries(protocol, chrome_icon,
-                                               chrome_open, &entries);
+  GetXPStyleUserProtocolEntries(protocol, chrome_icon, chrome_open, &entries);
   // Change the default protocol handler for current user.
   if (!AddRegistryEntries(HKEY_CURRENT_USER, entries)) {
     LOG(ERROR) << "Could not make Chrome default protocol client (XP).";
     return false;
   }
 
   return true;
 }
 
 // Returns |properties.shortcut_name| if the property is set, otherwise it
@@ skipping 1105 matching lines @@
   // Check if chrome is already registered with this suffix.
   if (IsChromeRegistered(dist, chrome_exe, suffix, look_for_in))
     return true;
 
   bool result = true;
   if (root == HKEY_CURRENT_USER || IsUserAnAdmin()) {
     // Do the full registration if we can do it at user-level or if the user is
     // an admin.
     ScopedVector<RegistryEntry> progid_and_appreg_entries;
     ScopedVector<RegistryEntry> shell_entries;
-    RegistryEntry::GetChromeProgIdEntries(
-        dist, chrome_exe, suffix, &progid_and_appreg_entries);
-    RegistryEntry::GetChromeAppRegistrationEntries(
-        chrome_exe, suffix, &progid_and_appreg_entries);
-    RegistryEntry::GetShellIntegrationEntries(
-        dist, chrome_exe, suffix, &shell_entries);
+    GetChromeProgIdEntries(dist, chrome_exe, suffix,
+                           &progid_and_appreg_entries);
+    GetChromeAppRegistrationEntries(chrome_exe, suffix,
+                                    &progid_and_appreg_entries);
+    GetShellIntegrationEntries(dist, chrome_exe, suffix, &shell_entries);
     result = (AddRegistryEntries(root, progid_and_appreg_entries) &&
               AddRegistryEntries(root, shell_entries));
   } else if (elevate_if_not_admin &&
       base::win::GetVersion() >= base::win::VERSION_VISTA &&
       ElevateAndRegisterChrome(dist, chrome_exe, suffix, base::string16())) {
     // If the user is not an admin and OS is between Vista and Windows 7
     // inclusively, try to elevate and register. This is only intended for
     // user-level installs as system-level installs should always be run with
     // admin rights.
     result = true;
   } else {
     // If we got to this point then all we can do is create ProgId and basic app
     // registrations under HKCU.
     ScopedVector<RegistryEntry> entries;
-    RegistryEntry::GetChromeProgIdEntries(
-        dist, chrome_exe, base::string16(), &entries);
+    GetChromeProgIdEntries(dist, chrome_exe, base::string16(), &entries);
     // Prefer to use |suffix|; unless Chrome's ProgIds are already registered
     // with no suffix (as per the old registration style): in which case some
     // other registry entries could refer to them and since we were not able to
     // set our HKLM entries above, we are better off not altering these here.
     if (!AreEntriesAsDesired(entries, RegistryEntry::LOOK_IN_HKCU)) {
       if (!suffix.empty()) {
         entries.clear();
-        RegistryEntry::GetChromeProgIdEntries(
-            dist, chrome_exe, suffix, &entries);
-        RegistryEntry::GetChromeAppRegistrationEntries(
-            chrome_exe, suffix, &entries);
+        GetChromeProgIdEntries(dist, chrome_exe, suffix, &entries);
+        GetChromeAppRegistrationEntries(chrome_exe, suffix, &entries);
       }
       result = AddRegistryEntries(HKEY_CURRENT_USER, entries);
     } else {
       // The ProgId is registered unsuffixed in HKCU, also register the app with
       // Windows in HKCU (this was not done in the old registration style and
       // thus needs to be done after the above check for the unsuffixed
       // registration).
       entries.clear();
-      RegistryEntry::GetChromeAppRegistrationEntries(
-          chrome_exe, base::string16(), &entries);
+      GetChromeAppRegistrationEntries(chrome_exe, base::string16(), &entries);
       result = AddRegistryEntries(HKEY_CURRENT_USER, entries);
     }
   }
   SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
   return result;
 }
 
 bool ShellUtil::RegisterChromeForProtocol(BrowserDistribution* dist,
                                           const base::FilePath& chrome_exe,
                                           const base::string16& unique_suffix,
@@ skipping 26 matching lines @@
     return true;
 
   if (root == HKEY_CURRENT_USER || IsUserAnAdmin()) {
     // We can do this operation directly.
     // First, make sure Chrome is fully registered on this machine.
     if (!RegisterChromeBrowser(dist, chrome_exe, suffix, false))
       return false;
 
     // Write in the capabillity for the protocol.
     ScopedVector<RegistryEntry> entries;
-    RegistryEntry::GetProtocolCapabilityEntries(dist, suffix, protocol,
-                                                &entries);
+    GetProtocolCapabilityEntries(dist, suffix, protocol, &entries);
     return AddRegistryEntries(root, entries);
   } else if (elevate_if_not_admin &&
              base::win::GetVersion() >= base::win::VERSION_VISTA) {
     // Elevate to do the whole job
     return ElevateAndRegisterChrome(dist, chrome_exe, suffix, protocol);
   } else {
     // Admin rights are required to register capabilities before Windows 8.
     return false;
   }
 }
@@ skipping 132 matching lines @@
 // static
 bool ShellUtil::AddFileAssociations(
     const base::string16& prog_id,
     const base::CommandLine& command_line,
     const base::string16& file_type_name,
     const base::FilePath& icon_path,
     const std::set<base::string16>& file_extensions) {
   ScopedVector<RegistryEntry> entries;
 
   // Create a class for this app.
-  RegistryEntry::ApplicationInfo app_info;
+  ApplicationInfo app_info;
   app_info.prog_id = prog_id;
   app_info.file_type_name = file_type_name;
   app_info.file_type_icon_path = icon_path;
   app_info.file_type_icon_index = 0;
   app_info.command_line = command_line.GetCommandLineStringWithPlaceholders();
-  RegistryEntry::GetProgIdEntries(app_info, &entries);
+  GetProgIdEntries(app_info, &entries);
 
   // Associate each extension that the app can handle with the class. Set this
   // app as the default handler if and only if there is no existing default.
   for (std::set<base::string16>::const_iterator it = file_extensions.begin();
        it != file_extensions.end();
        ++it) {
     // Do not allow empty file extensions, or extensions beginning with a '.'.
     DCHECK(!it->empty());
     DCHECK_NE(L'.', (*it)[0]);
     base::string16 ext(1, L'.');
     ext.append(*it);
-    RegistryEntry::GetAppExtRegistrationEntries(prog_id, ext, &entries);
+    GetAppExtRegistrationEntries(prog_id, ext, &entries);
 
     // Regstering as the default will have no effect on Windows 8 (see
     // documentation for GetAppDefaultRegistrationEntries). However, if our app
     // is the only handler, it will automatically become the default, so the
     // same effect is achieved.
-    RegistryEntry::GetAppDefaultRegistrationEntries(
-        prog_id, ext, false, &entries);
+    GetAppDefaultRegistrationEntries(prog_id, ext, false, &entries);
   }
 
   return AddRegistryEntries(HKEY_CURRENT_USER, entries);
 }
 
 // static
 bool ShellUtil::DeleteFileAssociations(const base::string16& prog_id) {
   // Delete the key HKEY_CURRENT_USER\Software\Classes\PROGID.
   base::string16 key_path(ShellUtil::kRegClasses);
   key_path.push_back(base::FilePath::kSeparators[0]);
   key_path.append(prog_id);
   return InstallUtil::DeleteRegistryKey(
       HKEY_CURRENT_USER, key_path, WorkItem::kWow64Default);
 
   // TODO(mgiuca): Remove the extension association entries. This requires that
   // the extensions associated with a particular prog_id are stored in that
   // prog_id's key.
 }