Refactoring of master preferences parsing before adding a new preference.

chrome/installer/setup/install.cc

 // Copyright (c) 2009 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 <shlobj.h>
 #include <time.h>
 
 #include "chrome/installer/setup/install.h"
 
-#include "base/command_line.h"
 #include "base/file_util.h"
+#include "base/logging.h"
 #include "base/path_service.h"
 #include "base/registry.h"
 #include "base/scoped_ptr.h"
-#include "base/string_util.h"
-#include "chrome/common/chrome_constants.h"
 #include "chrome/installer/setup/setup_constants.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
+#include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/set_reg_value_work_item.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
-#include "chrome/installer/util/work_item.h"
-#include "chrome/installer/util/version.h"
 #include "chrome/installer/util/work_item_list.h"
 
 // Build-time generated include file.
 #include "installer_util_strings.h"
 #include "registered_dlls.h"
 
 namespace {
 
 std::wstring AppendPath(const std::wstring& parent_path,
                         const std::wstring& path) {
@@ skipping 115 matching lines @@
 // uninstalling chrome.
 // If first_install is false, the function only updates the shortcut for
 // uninstalling chrome. According to
 // http://blogs.msdn.com/oldnewthing/archive/2005/11/24/496690.aspx,
 // updating uninstall shortcut should not trigger Windows "new application
 // installed" notification.
 //
 // If the shortcuts do not exist, the function does not recreate them during
 // update.
 bool CreateOrUpdateChromeShortcuts(const std::wstring& exe_path,
-                                   int options,
+                                   const std::wstring& install_path,
+                                   const std::wstring& new_version,
                                    installer_util::InstallStatus install_status,
-                                   const std::wstring& install_path,
-                                   const std::wstring& new_version) {
-  bool system_install = (options & installer_util::SYSTEM_LEVEL) != 0;
+                                   bool system_install,
+                                   bool create_all_shortcut,
+                                   bool alt_shortcut) {
   FilePath shortcut_path;
   int dir_enum = (system_install) ? base::DIR_COMMON_START_MENU :
                                     base::DIR_START_MENU;
   if (!PathService::Get(dir_enum, &shortcut_path)) {
     LOG(ERROR) << "Failed to get location for shortcut.";
     return false;
   }
 
   // The location of Start->Programs->Google Chrome folder
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
@@ skipping 57 matching lines @@
     ret = ret && file_util::CreateShortcutLink(setup_exe.c_str(),
                                                uninstall_link.value().c_str(),
                                                NULL,
                                                arguments.c_str(),
                                                NULL, setup_exe.c_str(), 0);
   }
 
   // Update Desktop and Quick Launch shortcuts. If --create-new-shortcuts
   // is specified we want to create them, otherwise we update them only if
   // they exist.
-  bool create = (options & installer_util::CREATE_ALL_SHORTCUTS) != 0;
-  // In some cases the main desktop shortcut has an alternate name.
-  bool alt_shortcut = (options & installer_util::ALT_DESKTOP_SHORTCUT) != 0;
-
   if (system_install) {
     ret = ret && ShellUtil::CreateChromeDesktopShortcut(chrome_exe,
-        product_desc, ShellUtil::SYSTEM_LEVEL, alt_shortcut, create);
+        product_desc, ShellUtil::SYSTEM_LEVEL, alt_shortcut,
+        create_all_shortcut);
     ret = ret && ShellUtil::CreateChromeQuickLaunchShortcut(chrome_exe,
-        ShellUtil::CURRENT_USER | ShellUtil::SYSTEM_LEVEL, create);
+        ShellUtil::CURRENT_USER | ShellUtil::SYSTEM_LEVEL, create_all_shortcut);
   } else {
     ret = ret && ShellUtil::CreateChromeDesktopShortcut(chrome_exe,
-        product_desc, ShellUtil::CURRENT_USER, alt_shortcut, create);
+        product_desc, ShellUtil::CURRENT_USER, alt_shortcut,
+        create_all_shortcut);
     ret = ret && ShellUtil::CreateChromeQuickLaunchShortcut(chrome_exe,
-        ShellUtil::CURRENT_USER, create);
+        ShellUtil::CURRENT_USER, create_all_shortcut);
   }
 
   return ret;
 }
 
 // This method tells if we are running on 64 bit platform so that we can copy
 // one extra exe. If the API call to determine 64 bit fails, we play it safe
 // and return true anyway so that the executable can be copied.
 bool Is64bit() {
   typedef BOOL (WINAPI *WOW_FUNC)(HANDLE, PBOOL);
   BOOL is64 = FALSE;
 
   HANDLE handle = GetCurrentProcess();
   HMODULE module = GetModuleHandle(L"kernel32.dll");
   WOW_FUNC p = reinterpret_cast<WOW_FUNC>(GetProcAddress(module,
                                                          "IsWow64Process"));
   if ((p != NULL) && (!(p)(handle, &is64) || (is64 != FALSE))) {
     return true;
   }
 
   return false;
 }
 
-void RegisterChromeOnMachine(const std::wstring& install_path, int options) {
-  bool system_level = (options & installer_util::SYSTEM_LEVEL) != 0;
+void RegisterChromeOnMachine(const std::wstring& install_path,
+                             bool system_level,
+                             bool make_chrome_default) {
   // Try to add Chrome to Media Player shim inclusion list. We don't do any
   // error checking here because this operation will fail if user doesn't
   // have admin rights and we want to ignore the error.
   AddChromeToMediaPlayerList();
 
   // Is --make-chrome-default option is given we make Chrome default browser
   // otherwise we only register it on the machine as a valid browser.
   std::wstring chrome_exe(install_path);
   file_util::AppendToPath(&chrome_exe, installer_util::kChromeExe);
   LOG(INFO) << "Registering Chrome as browser";
-  if (options & installer_util::MAKE_CHROME_DEFAULT) {
+  if (make_chrome_default) {
     int level = ShellUtil::CURRENT_USER;
     if (system_level)
       level = level | ShellUtil::SYSTEM_LEVEL;
     ShellUtil::MakeChromeDefault(level, chrome_exe, true);
   } else {
     ShellUtil::RegisterChromeBrowser(chrome_exe, L"", false);
   }
 }
 }  // namespace
 
@@ skipping 171 matching lines @@
   if (!success) {
     LOG(ERROR) << "Install failed, rolling back... ";
     install_list->Rollback();
     LOG(ERROR) << "Rollback complete. ";
   }
   return success;
 }
 
 installer_util::InstallStatus installer::InstallOrUpdateChrome(
     const std::wstring& exe_path, const std::wstring& archive_path,
-    const std::wstring& install_temp_path, int options,
+    const std::wstring& install_temp_path, const DictionaryValue* prefs,
     const Version& new_version, const Version* installed_version) {
-  bool system_install = (options & installer_util::SYSTEM_LEVEL) != 0;
+  bool system_install = installer_util::GetDistroBooleanPreference(prefs,
+      installer_util::master_preferences::kSystemLevel);
   std::wstring install_path(GetChromeInstallPath(system_install));
   if (install_path.empty()) {
     LOG(ERROR) << "Could not get installation destination path.";
     return installer_util::INSTALL_FAILED;
   } else {
     LOG(INFO) << "install destination path: " << install_path;
   }
 
   std::wstring src_path(install_temp_path);
   file_util::AppendToPath(&src_path, std::wstring(kInstallSourceDir));
@@ skipping 20 matching lines @@
     } else {
       LOG(ERROR) << "Not sure how we got here."
                  << " New version: " << new_version.GetString()
                  << ", installed version: " << installed_version->GetString();
       // This should never happen but we are seeing some inconsistent exit
       // code reports in Omaha logs. We will treat this case as update to
       // see if the inconsistency goes away.
       result = installer_util::NEW_VERSION_UPDATED;
     }
 
-    if (!CreateOrUpdateChromeShortcuts(exe_path, options, result,
-                                       install_path, new_version.GetString()))
+    bool create_all_shortcut = installer_util::GetDistroBooleanPreference(prefs,
+        installer_util::master_preferences::kCreateAllShortcuts);
+    bool alt_shortcut = installer_util::GetDistroBooleanPreference(prefs,
+        installer_util::master_preferences::kAltShortcutText);
+    if (!CreateOrUpdateChromeShortcuts(exe_path, install_path,
+                                       new_version.GetString(), result,
+                                       system_install, create_all_shortcut,
+                                       alt_shortcut))
       LOG(WARNING) << "Failed to create/update start menu shortcut.";
 
     RemoveOldVersionDirs(install_path, new_version.GetString());
 
-    RegisterChromeOnMachine(install_path, options);
+    bool make_chrome_default = installer_util::GetDistroBooleanPreference(prefs,
+        installer_util::master_preferences::kMakeChromeDefault);
+    RegisterChromeOnMachine(install_path, system_install, make_chrome_default);
   }
 
   return result;
 }
 
 std::wstring installer::GetInstallerPathUnderChrome(
     const std::wstring& install_path, const std::wstring& new_version) {
   std::wstring installer_path(install_path);
   file_util::AppendToPath(&installer_path, new_version);
   file_util::AppendToPath(&installer_path, installer_util::kInstallerDir);
   return installer_path;
 }