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

chrome/installer/util/master_preferences.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 "chrome/installer/util/master_preferences.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/singleton.h"
@@ skipping 54 matching lines @@
   if (!root->IsType(Value::TYPE_DICTIONARY)) {
     LOG(WARNING) << "Failed to parse master prefs file: "
                  << "Root item must be a dictionary.";
     return NULL;
   }
   return static_cast<DictionaryValue*>(root.release());
 }
 
 }  // namespace
 
-namespace installer_util {
+namespace installer {
 
 MasterPreferences::MasterPreferences() : distribution_(NULL),
                                          preferences_read_from_file_(false),
                                          ceee_(false),
                                          chrome_(true),
                                          chrome_frame_(false),
                                          multi_install_(false) {
   InitializeFromCommandLine(*CommandLine::ForCurrentProcess());
 }
 
@@ skipping 21 matching lines @@
   }
 
   InitializeProductFlags();
 }
 
 MasterPreferences::~MasterPreferences() {
 }
 
 void MasterPreferences::InitializeFromCommandLine(const CommandLine& cmd_line) {
 #if defined(OS_WIN)
-  if (cmd_line.HasSwitch(installer_util::switches::kInstallerData)) {

[tommi (sloooow) - chröme, 2010/12/13 20:28:06]

nit: I guess there are several places where this is now true, but the
installer:: prefix isn't necessary anymore since this code is already in the
installer namespace.

[robertshield, 2010/12/13 21:43:53]

Yes, I'd rather keep this a search and replace type CL. I can clean up the
redundant namespaces in a new CL.

+  if (cmd_line.HasSwitch(installer::switches::kInstallerData)) {
     FilePath prefs_path(cmd_line.GetSwitchValuePath(
-        installer_util::switches::kInstallerData));
+        installer::switches::kInstallerData));
     this->MasterPreferences::MasterPreferences(prefs_path);
   } else {
     master_dictionary_.reset(new DictionaryValue());
   }
 
   DCHECK(master_dictionary_.get());
 
   // A simple map from command line switches to equivalent switches in the
   // distribution dictionary.  Currently all switches added will be set to
   // 'true'.
   static const struct CmdLineSwitchToDistributionSwitch {
     const char* cmd_line_switch;
     const char* distribution_switch;
   } translate_switches[] = {
-    { installer_util::switches::kCeee,
-      installer_util::master_preferences::kCeee },
-    { installer_util::switches::kChrome,
-      installer_util::master_preferences::kChrome },
-    { installer_util::switches::kChromeFrame,
-      installer_util::master_preferences::kChromeFrame },
-    { installer_util::switches::kCreateAllShortcuts,
-      installer_util::master_preferences::kCreateAllShortcuts },
-    { installer_util::switches::kDisableLogging,
-      installer_util::master_preferences::kDisableLogging },
-    { installer_util::switches::kDoNotCreateShortcuts,
-      installer_util::master_preferences::kDoNotCreateShortcuts },
-    { installer_util::switches::kMsi,
-      installer_util::master_preferences::kMsi },
-    { installer_util::switches::kMultiInstall,
-      installer_util::master_preferences::kMultiInstall },
-    { installer_util::switches::kDoNotRegisterForUpdateLaunch,
-      installer_util::master_preferences::kDoNotRegisterForUpdateLaunch },
-    { installer_util::switches::kDoNotLaunchChrome,
-      installer_util::master_preferences::kDoNotLaunchChrome },
-    { installer_util::switches::kMakeChromeDefault,
-      installer_util::master_preferences::kMakeChromeDefault },
-    { installer_util::switches::kSystemLevel,
-      installer_util::master_preferences::kSystemLevel },
-    { installer_util::switches::kVerboseLogging,
-      installer_util::master_preferences::kVerboseLogging },
-    { installer_util::switches::kAltDesktopShortcut,
-      installer_util::master_preferences::kAltShortcutText },
+    { installer::switches::kCeee,
+      installer::master_preferences::kCeee },
+    { installer::switches::kChrome,
+      installer::master_preferences::kChrome },
+    { installer::switches::kChromeFrame,
+      installer::master_preferences::kChromeFrame },
+    { installer::switches::kCreateAllShortcuts,
+      installer::master_preferences::kCreateAllShortcuts },
+    { installer::switches::kDisableLogging,
+      installer::master_preferences::kDisableLogging },
+    { installer::switches::kDoNotCreateShortcuts,
+      installer::master_preferences::kDoNotCreateShortcuts },
+    { installer::switches::kMsi,
+      installer::master_preferences::kMsi },
+    { installer::switches::kMultiInstall,
+      installer::master_preferences::kMultiInstall },
+    { installer::switches::kDoNotRegisterForUpdateLaunch,
+      installer::master_preferences::kDoNotRegisterForUpdateLaunch },
+    { installer::switches::kDoNotLaunchChrome,
+      installer::master_preferences::kDoNotLaunchChrome },
+    { installer::switches::kMakeChromeDefault,
+      installer::master_preferences::kMakeChromeDefault },
+    { installer::switches::kSystemLevel,
+      installer::master_preferences::kSystemLevel },
+    { installer::switches::kVerboseLogging,
+      installer::master_preferences::kVerboseLogging },
+    { installer::switches::kAltDesktopShortcut,
+      installer::master_preferences::kAltShortcutText },
   };
 
   std::string name(kDistroDict);
   for (int i = 0; i < arraysize(translate_switches); ++i) {
     if (cmd_line.HasSwitch(translate_switches[i].cmd_line_switch)) {
       name.resize(arraysize(kDistroDict) - 1);
       name.append(".").append(translate_switches[i].distribution_switch);
       master_dictionary_->SetBoolean(name, true);
     }
   }
 
   // See if the log file path was specified on the command line.
   std::wstring str_value(cmd_line.GetSwitchValueNative(
-      installer_util::switches::kLogFile));
+      installer::switches::kLogFile));
   if (!str_value.empty()) {
     name.resize(arraysize(kDistroDict) - 1);
-    name.append(".").append(installer_util::master_preferences::kLogFile);
+    name.append(".").append(installer::master_preferences::kLogFile);
     master_dictionary_->SetString(name, str_value);
   }
 
   // Cache a pointer to the distribution dictionary. Ignore errors if any.
   master_dictionary_->GetDictionary(kDistroDict, &distribution_);
 
   InitializeProductFlags();
 #endif
 }
 
 void MasterPreferences::InitializeProductFlags() {
   // Make sure we start out with the correct defaults.
   multi_install_ = false;
   chrome_frame_ = false;
   ceee_ = false;
   chrome_ = true;
 
-  GetBool(installer_util::master_preferences::kMultiInstall, &multi_install_);
-  GetBool(installer_util::master_preferences::kChromeFrame, &chrome_frame_);
-  GetBool(installer_util::master_preferences::kCeee, &ceee_);
+  GetBool(installer::master_preferences::kMultiInstall, &multi_install_);
+  GetBool(installer::master_preferences::kChromeFrame, &chrome_frame_);
+  GetBool(installer::master_preferences::kCeee, &ceee_);
 
   // When multi-install is specified, the checks are pretty simple (in theory):
   // In order to be installed/uninstalled, each product must have its switch
   // present on the command line.
   // Before multi-install was introduced however, we only supported installing
   // two products, Chrome and Chrome Frame.  For the time being we need to
   // continue to support this mode where multi-install is not set.
   // So, when multi-install is not set, we continue to support mutually
   // exclusive installation of Chrome and Chrome Frame in addition to supporting
   // installation of CEEE with Chrome Frame.
 
   // Regardless of multi install being present, CEEE always needs CF to
   // be installed.
   if (ceee_)
     chrome_frame_ = true;
 
   if (multi_install_) {
-    if (!GetBool(installer_util::master_preferences::kChrome, &chrome_))
+    if (!GetBool(installer::master_preferences::kChrome, &chrome_))
       chrome_ = false;
   } else {
     // If chrome-frame is on the command line however, we only install CF.
     chrome_ = !chrome_frame_;
   }
 }
 
 bool MasterPreferences::GetBool(const std::string& name, bool* value) const {
   bool ret = false;
   if (distribution_)
@@ skipping 23 matching lines @@
 bool MasterPreferences::GetExtensionsBlock(DictionaryValue** extensions) const {
   return master_dictionary_->GetDictionary(
       master_preferences::kExtensionsBlock, extensions);
 }
 
 // static
 const MasterPreferences& MasterPreferences::ForCurrentProcess() {
   return *Singleton<MasterPreferences>::get();
 }
 }  // installer_util