Merge the installer, installer_util and setup_util namespaces into a single i...

chrome/installer/util/install_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.
 //
 // See the corresponding header file for description of the functions in this
 // file.
 
 #include "chrome/installer/util/install_util.h"
 
 #include <shellapi.h>
@@ skipping 11 matching lines @@
 #include "base/win/windows_version.h"
 #include "chrome/common/json_value_serializer.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/l10n_string_util.h"
 #include "chrome/installer/util/master_preferences_constants.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item_list.h"
 
 using base::win::RegKey;
-using installer_util::MasterPreferences;
+using installer::MasterPreferences;
 
 bool InstallUtil::ExecuteExeAsAdmin(const CommandLine& cmd, DWORD* exit_code) {
   FilePath::StringType program(cmd.GetProgram().value());
   DCHECK(!program.empty());
   DCHECK(program[0] != '\"');
 
   CommandLine::StringType params(cmd.command_line_string());
   if (params[0] == '"') {
     DCHECK_EQ('"', params[program.length() + 1]);
     DCHECK_EQ(program, params.substr(1, program.length()));
@@ skipping 24 matching lines @@
     *exit_code = ret_val;
   return true;
 }
 
 std::wstring InstallUtil::GetChromeUninstallCmd(bool system_install,
                                                 BrowserDistribution* dist) {
   DCHECK(dist);
   HKEY root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   RegKey key(root, dist->GetUninstallRegPath().c_str(), KEY_READ);
   std::wstring uninstall_cmd;
-  key.ReadValue(installer_util::kUninstallStringField, &uninstall_cmd);
+  key.ReadValue(installer::kUninstallStringField, &uninstall_cmd);
   return uninstall_cmd;
 }
 
 installer::Version* InstallUtil::GetChromeVersion(BrowserDistribution* dist,
                                                   bool system_install) {
   DCHECK(dist);
   RegKey key;
   std::wstring version_str;
 
   HKEY reg_root = (system_install) ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
@@ skipping 26 matching lines @@
                                 SHGFP_TYPE_CURRENT, program_files_path))) {
     return !StartsWith(exe_path, program_files_path, false);
   } else {
     NOTREACHED();
   }
   return true;
 }
 
 bool InstallUtil::IsChromeFrameProcess() {
   const MasterPreferences& prefs =
-      installer_util::MasterPreferences::ForCurrentProcess();
+      installer::MasterPreferences::ForCurrentProcess();
   return prefs.install_chrome_frame();
 }
 
 bool CheckIsChromeSxSProcess() {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   CHECK(command_line);
 
-  if (command_line->HasSwitch(installer_util::switches::kChromeSxS))
+  if (command_line->HasSwitch(installer::switches::kChromeSxS))
     return true;
 
   // Also return true if we are running from Chrome SxS installed path.
   FilePath exe_dir;
   PathService::Get(base::DIR_EXE, &exe_dir);
-  std::wstring chrome_sxs_dir(installer_util::kGoogleChromeInstallSubDir2);
-  chrome_sxs_dir.append(installer_util::kSxSSuffix);
+  std::wstring chrome_sxs_dir(installer::kGoogleChromeInstallSubDir2);
+  chrome_sxs_dir.append(installer::kSxSSuffix);
   return FilePath::CompareEqualIgnoreCase(exe_dir.BaseName().value(),
-                                          installer_util::kInstallBinaryDir) &&
+                                          installer::kInstallBinaryDir) &&
          FilePath::CompareEqualIgnoreCase(exe_dir.DirName().BaseName().value(),
                                           chrome_sxs_dir);
 }
 
 bool InstallUtil::IsChromeSxSProcess() {
   static bool sxs = CheckIsChromeSxSProcess();
   return sxs;
 }
 
 bool InstallUtil::BuildDLLRegistrationList(const std::wstring& install_path,
@@ skipping 35 matching lines @@
                                       const std::wstring& value_name) {
   RegKey key(reg_root, key_path.c_str(), KEY_ALL_ACCESS);
   VLOG(1) << "Deleting registry value " << value_name;
   if (key.ValueExists(value_name.c_str()) &&
       !key.DeleteValue(value_name.c_str())) {
     LOG(ERROR) << "Failed to delete registry value: " << value_name;
     return false;
   }
   return true;
 }