Cleanup Registry API: part 3.

chrome/installer/util/shell_util.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.
 //
 // 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 173 matching lines @@
     if (_is_string) {
       items->AddSetRegValueWorkItem(root, _key_path, _name, _value, true);
     } else {
       items->AddSetRegValueWorkItem(root, _key_path, _name, _int_value, true);
     }
   }
 
   // Checks if the current registry entry exists in HKLM registry and the value
   // is same.
   bool ExistsInHKLM() const {
-    RegKey key(HKEY_LOCAL_MACHINE, _key_path.c_str());
+    RegKey key(HKEY_LOCAL_MACHINE, _key_path.c_str(), KEY_READ);
     bool found = false;
     if (_is_string) {
       std::wstring read_value;
       found = (key.ReadValue(_name.c_str(), &read_value)) &&
               (read_value.size() == _value.size()) &&
               (std::equal(_value.begin(), _value.end(), read_value.begin(),
                           CaseInsensitiveCompare<wchar_t>()));
     } else {
       DWORD read_value;
       found = key.ReadValueDW(_name.c_str(), &read_value) &&
               read_value == _int_value;
     }
     key.Close();
     return found;
   }
 
   // Checks if the current registry entry exists in HKLM registry
   // (only the name).
   bool NameExistsInHKLM() const {
-    RegKey key(HKEY_LOCAL_MACHINE, _key_path.c_str());
+    RegKey key(HKEY_LOCAL_MACHINE, _key_path.c_str(), KEY_READ);
     bool found = false;
     if (_is_string) {
       std::wstring read_value;
       found = key.ReadValue(_name.c_str(), &read_value);
     } else {
       DWORD read_value;
       found = key.ReadValueDW(_name.c_str(), &read_value);
     }
     key.Close();
     return found;
@@ skipping 71 matching lines @@
 // the new process will make the necessary changes and return SUCCESS that
 // we capture and return.
 bool ElevateAndRegisterChrome(const std::wstring& chrome_exe,
                               const std::wstring& suffix) {
   std::wstring exe_path(file_util::GetDirectoryFromPath(chrome_exe));
   file_util::AppendToPath(&exe_path, installer_util::kSetupExe);
   if (!file_util::PathExists(FilePath::FromWStringHack(exe_path))) {
     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     HKEY reg_root = InstallUtil::IsPerUserInstall(chrome_exe.c_str()) ?
         HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
-    RegKey key(reg_root, dist->GetUninstallRegPath().c_str());
+    RegKey key(reg_root, dist->GetUninstallRegPath().c_str(), KEY_READ);
     key.ReadValue(installer_util::kUninstallStringField, &exe_path);
     CommandLine command_line = CommandLine::FromString(exe_path);
     exe_path = command_line.program();
   }
   if (file_util::PathExists(FilePath::FromWStringHack(exe_path))) {
     std::wstring params(L"--");
     params.append(
         ASCIIToWide(installer_util::switches::kRegisterChromeBrowser));
     params.append(L"=\"" + chrome_exe + L"\"");
     if (!suffix.empty()) {
@@ skipping 25 matching lines @@
 // - Software\Clients\StartMenuInternet\Chromium\"" key should have a valid
 //   value.
 // - The value should not be same as given value in |chrome_exe|
 // - Finally to handle the default install path (C:\Document and Settings\
 //   <user>\Local Settings\Application Data\Chromium\Application) the value
 //   of the above key should differ from |chrome_exe| only in user name.
 bool AnotherUserHasDefaultBrowser(const std::wstring& chrome_exe) {
   std::wstring reg_key(ShellUtil::kRegStartMenuInternet);
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   reg_key.append(L"\\" + dist->GetApplicationName() + ShellUtil::kRegShellOpen);
-  RegKey key(HKEY_LOCAL_MACHINE, reg_key.c_str());
+  RegKey key(HKEY_LOCAL_MACHINE, reg_key.c_str(), KEY_READ);
   std::wstring registry_chrome_exe;
   if (!key.ReadValue(L"", &registry_chrome_exe) ||
       registry_chrome_exe.length() < 2)
     return false;
 
   registry_chrome_exe = registry_chrome_exe.substr(1,
       registry_chrome_exe.length() - 2);
   if ((registry_chrome_exe.size() == chrome_exe.size()) &&
       (std::equal(chrome_exe.begin(), chrome_exe.end(),
                   registry_chrome_exe.begin(),
@@ skipping 199 matching lines @@
   file_util::AppendToPath(path, kQuickLaunchPath);
   return true;
 }
 
 void ShellUtil::GetRegisteredBrowsers(std::map<std::wstring,
                                       std::wstring>* browsers) {
   std::wstring base_key(ShellUtil::kRegStartMenuInternet);
   HKEY root = HKEY_LOCAL_MACHINE;
   for (RegistryKeyIterator iter(root, base_key.c_str()); iter.Valid(); ++iter) {
     std::wstring key = base_key + L"\\" + iter.Name();
-    RegKey capabilities(root, (key + L"\\Capabilities").c_str());
+    RegKey capabilities(root, (key + L"\\Capabilities").c_str(), KEY_READ);
     std::wstring name;
     if (!capabilities.Valid() ||
         !capabilities.ReadValue(L"ApplicationName", &name)) {
-      RegKey base_key(root, key.c_str());
+      RegKey base_key(root, key.c_str(), KEY_READ);
       if (!base_key.ReadValue(L"", &name))
         continue;
     }
-    RegKey install_info(root, (key + L"\\InstallInfo").c_str());
+    RegKey install_info(root, (key + L"\\InstallInfo").c_str(), KEY_READ);
     std::wstring command;
     if (!install_info.Valid() ||
         !install_info.ReadValue(L"ReinstallCommand", &command))
       continue;
     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     if (!name.empty() && !command.empty() &&
         name.find(dist->GetApplicationName()) == std::wstring::npos)
       (*browsers)[name] = command;
   }
 }
 
 bool ShellUtil::GetUserSpecificDefaultBrowserSuffix(std::wstring* entry) {
   wchar_t user_name[256];
   DWORD size = _countof(user_name);
   if (::GetUserName(user_name, &size) == 0)
     return false;
   entry->assign(L".");
   entry->append(user_name);
 
   std::wstring start_menu_entry(ShellUtil::kRegStartMenuInternet);
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   start_menu_entry.append(L"\\" + dist->GetApplicationName() + *entry);
-  RegKey key(HKEY_LOCAL_MACHINE, start_menu_entry.c_str());
+  RegKey key(HKEY_LOCAL_MACHINE, start_menu_entry.c_str(), KEY_READ);
   return key.Valid();
 }
 
 bool ShellUtil::MakeChromeDefault(int shell_change,
                                   const std::wstring& chrome_exe,
                                   bool elevate_if_not_admin) {
   if (!BrowserDistribution::GetDistribution()->CanSetAsDefault())
     return false;
 
   ShellUtil::RegisterChromeBrowser(chrome_exe, L"", elevate_if_not_admin);
@@ skipping 183 matching lines @@
         chrome_exe.c_str(),                // target
         shortcut.c_str(),                  // shortcut
         chrome_path.c_str(),               // working dir
         NULL,                              // arguments
         description.c_str(),               // description
         chrome_exe.c_str(),                // icon file
         icon_index,                        // icon index
         dist->GetBrowserAppId().c_str());  // app id
   }
 }