Refactoring the master_preferences functions....

chrome/installer/setup/setup_main.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.
 
 #include <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include <string>
@@ skipping 20 matching lines @@
 #include "chrome/installer/util/delete_tree_work_item.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/html_dialog.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/l10n_string_util.h"
 #include "chrome/installer/util/logging_installer.h"
 #include "chrome/installer/util/lzma_util.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/master_preferences.h"
+#include "chrome/installer/util/master_preferences_constants.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 
 #include "installer_util_strings.h"
 
 namespace {
 
 // This method unpacks and uncompresses the given archive file. For Chrome
 // install we are creating a uncompressed archive that contains all the files
 // needed for the installer. This uncompressed archive is later compressed.
@@ skipping 159 matching lines @@
       int str_id = IDS_INSTALL_DIR_IN_USE_BASE;
       InstallUtil::WriteInstallerResult(system_install, status, str_id, NULL);
       return false;
     }
   }
 
   return true;
 }
 
 installer_util::InstallStatus InstallChrome(const CommandLine& cmd_line,
-    const installer::Version* installed_version, const DictionaryValue* prefs) {
+    const installer::Version* installed_version,
+    const installer_util::MasterPreferences& prefs) {
   bool system_level = false;
-  installer_util::GetDistroBooleanPreference(prefs,
-      installer_util::master_preferences::kSystemLevel, &system_level);
+  prefs.GetBool(installer_util::master_preferences::kSystemLevel,
+                &system_level);
   installer_util::InstallStatus install_status = installer_util::UNKNOWN_STATUS;
   if (!CheckPreInstallConditions(installed_version,
                                  system_level, install_status))
     return install_status;
 
   // For install the default location for chrome.packed.7z is in current
   // folder, so get that value first.
   FilePath archive =
       cmd_line.GetProgram().DirName().Append(
           installer::kChromeCompressedArchive);
@@ skipping 84 matching lines @@
             install_msg_base = IDS_INSTALL_OS_ERROR_BASE;
             install_status = installer_util::OS_ERROR;
           } else {
             file_util::AppendToPath(&chrome_exe, installer_util::kChromeExe);
             chrome_exe = L"\"" + chrome_exe + L"\"";
             install_msg_base = 0;
           }
         }
 
         bool value = false;
-        installer_util::GetDistroBooleanPreference(prefs,
+        prefs.GetBool(
             installer_util::master_preferences::kDoNotRegisterForUpdateLaunch,
             &value);
         bool write_chrome_launch_string = (!value) &&
             (install_status != installer_util::IN_USE_UPDATED);
 
         InstallUtil::WriteInstallerResult(system_level, install_status,
             install_msg_base, write_chrome_launch_string ? &chrome_exe : NULL);
 
         if (install_status == installer_util::FIRST_INSTALL_SUCCESS) {
           VLOG(1) << "First install successful.";
           // We never want to launch Chrome in system level install mode.
           bool do_not_launch_chrome = false;
-          installer_util::GetDistroBooleanPreference(prefs,
-              installer_util::master_preferences::kDoNotLaunchChrome,
-              &do_not_launch_chrome);
+          prefs.GetBool(installer_util::master_preferences::kDoNotLaunchChrome,
+                        &do_not_launch_chrome);
           if (!system_level && !do_not_launch_chrome)
             installer::LaunchChrome(system_level);
         } else if ((install_status == installer_util::NEW_VERSION_UPDATED) ||
                    (install_status == installer_util::IN_USE_UPDATED)) {
           installer_setup::RemoveLegacyRegistryKeys();
         }
       }
     }
     // There might be an experiment (for upgrade usually) that needs to happen.
     // An experiment's outcome can include chrome's uninstallation. If that is
@@ skipping 270 matching lines @@
         WideToASCII(installer_util::switches::kDoNotCreateShortcuts));
     mutable_command_line->AppendSwitch(
         WideToASCII(installer_util::switches::kDoNotLaunchChrome));
     mutable_command_line->AppendSwitch(
         WideToASCII(installer_util::switches::kDoNotRegisterForUpdateLaunch));
   }
 
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
 
   installer::InitInstallerLogging(parsed_command_line);
-  scoped_ptr<DictionaryValue> prefs(installer_util::GetInstallPreferences(
-      parsed_command_line));
+  const installer_util::MasterPreferences& prefs =
+      InstallUtil::GetMasterPreferencesForCurrentProcess();
   bool value = false;
-  if (installer_util::GetDistroBooleanPreference(prefs.get(),
-          installer_util::master_preferences::kVerboseLogging, &value) &&
-      value)
+  if (prefs.GetBool(installer_util::master_preferences::kVerboseLogging,
+                    &value) && value) {
     logging::SetMinLogLevel(logging::LOG_INFO);
+  }
 
   VLOG(1) << "Command Line: " << parsed_command_line.command_line_string();
 
   bool system_install = false;
-  installer_util::GetDistroBooleanPreference(prefs.get(),
-      installer_util::master_preferences::kSystemLevel, &system_install);
+  prefs.GetBool(installer_util::master_preferences::kSystemLevel,
+                &system_install);
   VLOG(1) << "system install is " << system_install;
 
   // Check to make sure current system is WinXP or later. If not, log
   // error message and get out.
   if (!InstallUtil::IsOSSupported()) {
     LOG(ERROR) << "Chrome only supports Windows XP or later.";
     InstallUtil::WriteInstallerResult(system_install,
                                       installer_util::OS_NOT_SUPPORTED,
                                       IDS_INSTALL_OS_NOT_SUPPORTED_BASE, NULL);
     return installer_util::OS_NOT_SUPPORTED;
@@ skipping 59 matching lines @@
 
   installer_util::InstallStatus install_status = installer_util::UNKNOWN_STATUS;
   // If --uninstall option is given, uninstall chrome
   if (parsed_command_line.HasSwitch(installer_util::switches::kUninstall)) {
     install_status = UninstallChrome(parsed_command_line,
                                      command_line,
                                      installed_version.get(),
                                      system_install);
   // If --uninstall option is not specified, we assume it is install case.
   } else {
-    install_status = InstallChrome(parsed_command_line,
-                                   installed_version.get(),
-                                   prefs.get());
+    install_status = InstallChrome(parsed_command_line, installed_version.get(),
+                                   prefs);
   }
 
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 
   if (InstallUtil::IsChromeFrameProcess() &&
       !parsed_command_line.HasSwitch(
           installer_util::switches::kForceUninstall)) {
     if (install_status == installer_util::UNINSTALL_REQUIRES_REBOOT) {
       ShowRebootDialog();
     } else if (parsed_command_line.HasSwitch(
@@ skipping 14 matching lines @@
         parsed_command_line.HasSwitch(installer_util::switches::kUninstall))) {
     // Note that we allow the status installer_util::UNINSTALL_REQUIRES_REBOOT
     // to pass through, since this is only returned on uninstall which is never
     // invoked directly by Google Update.
     return_code = dist->GetInstallReturnCode(install_status);
   }
 
   VLOG(1) << "Installation complete, returning: " << return_code;
   return return_code;
 }