More installer refactoring in the interest of fixing some bugs and cleaning t...

chrome/installer/util/browser_distribution.cc

 // Copyright (c) 2011 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"
 
 #include "base/atomicops.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/path_service.h"
 #include "base/logging.h"
 #include "base/win/registry.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/installer/util/chrome_frame_distribution.h"
+#include "chrome/installer/util/chromium_binaries_distribution.h"
 #include "chrome/installer/util/google_chrome_distribution.h"
+#include "chrome/installer/util/google_chrome_binaries_distribution.h"
 #include "chrome/installer/util/google_chrome_sxs_distribution.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/l10n_string_util.h"
 #include "chrome/installer/util/master_preferences.h"
 
 #include "installer_util_strings.h"  // NOLINT
 
 using installer::MasterPreferences;
 
 namespace {
 // The BrowserDistribution objects are never freed.
 BrowserDistribution* g_browser_distribution = NULL;
 BrowserDistribution* g_chrome_frame_distribution = NULL;
+BrowserDistribution* g_binaries_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::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::kCeeeBrokerExe);
 }
 
 BrowserDistribution::Type GetCurrentDistributionType() {
   static BrowserDistribution::Type type =
       (MasterPreferences::ForCurrentProcess().install_chrome_frame() ||
        IsChromeFrameModule()) ?
           BrowserDistribution::CHROME_FRAME :
           BrowserDistribution::CHROME_BROWSER;
   return type;
 }
 
 }  // end namespace
 
-BrowserDistribution::BrowserDistribution(
-    const installer::MasterPreferences& prefs)
-    : type_(BrowserDistribution::CHROME_BROWSER) {
+BrowserDistribution::BrowserDistribution()
+    : type_(CHROME_BROWSER) {
+}
+
+BrowserDistribution::BrowserDistribution(Type type)
+    : type_(type) {
 }
 
 template<class DistributionClass>
 BrowserDistribution* BrowserDistribution::GetOrCreateBrowserDistribution(
-    const installer::MasterPreferences& prefs,
     BrowserDistribution** dist) {
   if (!*dist) {
-    DistributionClass* temp = new DistributionClass(prefs);
+    DistributionClass* temp = new DistributionClass();
     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::MasterPreferences& prefs =
-      installer::MasterPreferences::ForCurrentProcess();
-  return GetSpecificDistribution(GetCurrentDistributionType(), prefs);
+  return GetSpecificDistribution(GetCurrentDistributionType());
 }
 
 // static
 BrowserDistribution* BrowserDistribution::GetSpecificDistribution(
-    BrowserDistribution::Type type,
-    const installer::MasterPreferences& prefs) {
+    BrowserDistribution::Type type) {
   BrowserDistribution* dist = NULL;
 
-  if (type == CHROME_FRAME) {
-    dist = GetOrCreateBrowserDistribution<ChromeFrameDistribution>(
-        prefs, &g_chrome_frame_distribution);
-  } else {
-    DCHECK_EQ(CHROME_BROWSER, type);
+  switch (type) {
+    case CHROME_BROWSER:
 #if defined(GOOGLE_CHROME_BUILD)
-    if (InstallUtil::IsChromeSxSProcess()) {
-      dist = GetOrCreateBrowserDistribution<GoogleChromeSxSDistribution>(
-          prefs, &g_browser_distribution);
-    } else {
-      dist = GetOrCreateBrowserDistribution<GoogleChromeDistribution>(
-          prefs, &g_browser_distribution);
-    }
+      if (InstallUtil::IsChromeSxSProcess()) {
+        dist = GetOrCreateBrowserDistribution<GoogleChromeSxSDistribution>(
+            &g_browser_distribution);
+      } else {
+        dist = GetOrCreateBrowserDistribution<GoogleChromeDistribution>(
+            &g_browser_distribution);
+      }
 #else
-    dist = GetOrCreateBrowserDistribution<BrowserDistribution>(
-        prefs, &g_browser_distribution);
+      dist = GetOrCreateBrowserDistribution<BrowserDistribution>(
+          &g_browser_distribution);
+#endif
+      break;
+
+    case CHROME_FRAME:
+      dist = GetOrCreateBrowserDistribution<ChromeFrameDistribution>(
+          &g_chrome_frame_distribution);
+      break;
+
+    default:
+      DCHECK_EQ(CHROME_BINARIES, type);
+#if defined(GOOGLE_CHROME_BUILD)
+      dist = GetOrCreateBrowserDistribution<GoogleChromeBinariesDistribution>(
+          &g_binaries_distribution);
+#else
+      dist = GetOrCreateBrowserDistribution<ChromiumBinariesDistribution>(
+          &g_binaries_distribution);
 #endif
   }
 
   return dist;
 }
 
 void BrowserDistribution::DoPostUninstallOperations(
     const Version& version, const FilePath& local_data_path,
     const std::wstring& distribution_data) {
 }
@@ skipping 85 matching lines @@
     installer::InstallStatus install_status) {
 }
 
 void BrowserDistribution::LaunchUserExperiment(
     installer::InstallStatus status, const Version& version,
     const installer::Product& installation, bool system_level) {
 }
 
 
 void BrowserDistribution::InactiveUserToastExperiment(int flavor,
-    const installer::Product& installation) {
+    const installer::Product& installation,
+    const FilePath& application_path) {
 }
-
-std::vector<FilePath> BrowserDistribution::GetKeyFiles() {
-  std::vector<FilePath> key_files;
-  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::switches::kChrome);
-}
-
-bool BrowserDistribution::ShouldCreateUninstallEntry() {
-  return true;
-}
-
-bool BrowserDistribution::SetChannelFlags(
-    bool set,
-    installer::ChannelInfo* channel_info) {
-  return false;
-}