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

chrome/installer/util/browser_distribution.cc

 // Copyright (c) 2006-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.
 //
 // This file defines a class that contains various method related to branding.
 // It provides only default implementations of these methods. Usually to add
 // specific branding, we will need to extend this class with a custom
 // implementation.
 
 #include "chrome/installer/util/browser_distribution.h"
@@ skipping 19 matching lines @@
 // The BrowserDistribution objects are never freed.
 BrowserDistribution* g_browser_distribution = NULL;
 BrowserDistribution* g_chrome_frame_distribution = NULL;
 BrowserDistribution* g_ceee_distribution = NULL;
 
 // Returns true if currently running in npchrome_frame.dll
 bool IsChromeFrameModule() {
   FilePath module_path;
   PathService::Get(base::FILE_MODULE, &module_path);
   return FilePath::CompareEqualIgnoreCase(module_path.BaseName().value(),
-                                          installer_util::kChromeFrameDll);
+                                          installer::kChromeFrameDll);
 }
 
 // Returns true if currently running in ceee_broker.exe
 bool IsCeeeBrokerProcess() {
   FilePath exe_path;
   PathService::Get(base::FILE_EXE, &exe_path);
   return FilePath::CompareEqualIgnoreCase(exe_path.BaseName().value(),
-                                          installer_util::kCeeeBrokerExe);
+                                          installer::kCeeeBrokerExe);
 }
 
 BrowserDistribution::Type GetCurrentDistributionType() {
   static BrowserDistribution::Type type =
       (InstallUtil::IsChromeFrameProcess() || IsChromeFrameModule()) ?
           BrowserDistribution::CHROME_FRAME :
           BrowserDistribution::CHROME_BROWSER;
   return type;
 }
 
 }  // end namespace
 
 BrowserDistribution::BrowserDistribution(
-    const installer_util::MasterPreferences& prefs)
+    const installer::MasterPreferences& prefs)
     : type_(BrowserDistribution::CHROME_BROWSER) {
 }
 
 template<class DistributionClass>
 BrowserDistribution* BrowserDistribution::GetOrCreateBrowserDistribution(
-    const installer_util::MasterPreferences& prefs,
+    const installer::MasterPreferences& prefs,
     BrowserDistribution** dist) {
   if (!*dist) {
     DistributionClass* temp = new DistributionClass(prefs);
     if (base::subtle::NoBarrier_CompareAndSwap(
             reinterpret_cast<base::subtle::AtomicWord*>(dist), NULL,
             reinterpret_cast<base::subtle::AtomicWord>(temp)) != NULL)
       delete temp;
   }
 
   return *dist;
 }
 
 BrowserDistribution* BrowserDistribution::GetDistribution() {
-  const installer_util::MasterPreferences& prefs =
-      installer_util::MasterPreferences::ForCurrentProcess();
+  const installer::MasterPreferences& prefs =
+      installer::MasterPreferences::ForCurrentProcess();
   return GetSpecificDistribution(GetCurrentDistributionType(), prefs);
 }
 
 // static
 BrowserDistribution* BrowserDistribution::GetSpecificDistribution(
     BrowserDistribution::Type type,
-    const installer_util::MasterPreferences& prefs) {
+    const installer::MasterPreferences& prefs) {
   BrowserDistribution* dist = NULL;
 
   if (type == CHROME_FRAME) {
     dist = GetOrCreateBrowserDistribution<ChromeFrameDistribution>(
         prefs, &g_chrome_frame_distribution);
   } else {
     DCHECK_EQ(CHROME_BROWSER, type);
 #if defined(GOOGLE_CHROME_BUILD)
     if (InstallUtil::IsChromeSxSProcess()) {
       dist = GetOrCreateBrowserDistribution<GoogleChromeSxSDistribution>(
@@ skipping 43 matching lines @@
 std::wstring BrowserDistribution::GetPublisherName() {
   return L"Chromium";
 }
 
 std::wstring BrowserDistribution::GetAppDescription() {
   return L"Browse the web";
 }
 
 std::wstring BrowserDistribution::GetLongAppDescription() {
   const std::wstring& app_description =
-      installer_util::GetLocalizedString(IDS_PRODUCT_DESCRIPTION_BASE);
+      installer::GetLocalizedString(IDS_PRODUCT_DESCRIPTION_BASE);
   return app_description;
 }
 
 // static
 int BrowserDistribution::GetInstallReturnCode(
-    installer_util::InstallStatus status) {
+    installer::InstallStatus status) {
   switch (status) {
-    case installer_util::FIRST_INSTALL_SUCCESS:
-    case installer_util::INSTALL_REPAIRED:
-    case installer_util::NEW_VERSION_UPDATED:
-    case installer_util::IN_USE_UPDATED:
+    case installer::FIRST_INSTALL_SUCCESS:
+    case installer::INSTALL_REPAIRED:
+    case installer::NEW_VERSION_UPDATED:
+    case installer::IN_USE_UPDATED:
       return 0;
     default:
       return status;
   }
 }
 
 std::string BrowserDistribution::GetSafeBrowsingName() {
   return "chromium";
 }
 
@@ skipping 31 matching lines @@
 
 int BrowserDistribution::GetIconIndex() {
   return 0;
 }
 
 bool BrowserDistribution::GetChromeChannel(std::wstring* channel) {
   return false;
 }
 
 void BrowserDistribution::UpdateDiffInstallStatus(bool system_install,
-    bool incremental_install, installer_util::InstallStatus install_status) {
+    bool incremental_install, installer::InstallStatus install_status) {
 }
 
 void BrowserDistribution::LaunchUserExperiment(
-    installer_util::InstallStatus status, const installer::Version& version,
+    installer::InstallStatus status, const installer::Version& version,
     const installer::Product& installation, bool system_level) {
 }
 
 
 void BrowserDistribution::InactiveUserToastExperiment(int flavor,
     const installer::Product& installation) {
 }
 
 std::vector<FilePath> BrowserDistribution::GetKeyFiles() {
   std::vector<FilePath> key_files;
-  key_files.push_back(FilePath(installer_util::kChromeDll));
+  key_files.push_back(FilePath(installer::kChromeDll));
   return key_files;
 }
 
 std::vector<FilePath> BrowserDistribution::GetComDllList() {
   return std::vector<FilePath>();
 }
 
 void BrowserDistribution::AppendUninstallCommandLineFlags(
     CommandLine* cmd_line) {
   DCHECK(cmd_line);
-  cmd_line->AppendSwitch(installer_util::switches::kChrome);
+  cmd_line->AppendSwitch(installer::switches::kChrome);
 }