Product cleanups in the wake of multi-install removal.

chrome/installer/util/product.cc

 // Copyright (c) 2012 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/product.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/process/launch.h"
 #include "base/win/registry.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/chrome_browser_operations.h"
 #include "chrome/installer/util/chrome_browser_sxs_operations.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/install_util.h"
-#include "chrome/installer/util/master_preferences.h"
-#include "chrome/installer/util/master_preferences_constants.h"
 #include "chrome/installer/util/product_operations.h"
 
 using base::win::RegKey;
-using installer::MasterPreferences;
 
 namespace installer {
 
 Product::Product(BrowserDistribution* distribution)
     : distribution_(distribution),
       operations_(InstallUtil::IsChromeSxSProcess()
                       ? new ChromeBrowserSxSOperations()
                       : new ChromeBrowserOperations()) {}
 
 Product::~Product() {
 }
 
-void Product::InitializeFromPreferences(const MasterPreferences& prefs) {
-  operations_->ReadOptions(prefs, &options_);
-}
-
-void Product::InitializeFromUninstallCommand(
-    const base::CommandLine& uninstall_command) {
-  operations_->ReadOptions(uninstall_command, &options_);
-}
-
 bool Product::LaunchChrome(const base::FilePath& application_path) const {
   bool success = !application_path.empty();
   if (success) {
     base::CommandLine cmd(application_path.Append(installer::kChromeExe));
     success = base::LaunchProcess(cmd, base::LaunchOptions()).IsValid();
   }
   return success;
 }
 
 bool Product::LaunchChromeAndWait(const base::FilePath& application_path,
@@ skipping 50 matching lines @@
   if (result != ERROR_SUCCESS && result != ERROR_FILE_NOT_FOUND) {
     LOG(ERROR)
         << "Failed to Open or Write MSI value to client state key. error: "
         << result;
     return false;
   }
   return true;
 }
 
 void Product::AddKeyFiles(std::vector<base::FilePath>* key_files) const {
-  operations_->AddKeyFiles(options_, key_files);
+  operations_->AddKeyFiles(key_files);
 }
 
 void Product::AppendProductFlags(base::CommandLine* command_line) const {
-  operations_->AppendProductFlags(options_, command_line);
+  operations_->AppendProductFlags(command_line);
 }
 
 void Product::AppendRenameFlags(base::CommandLine* command_line) const {
-  operations_->AppendRenameFlags(options_, command_line);
-}
-
-bool Product::SetChannelFlags(bool set, ChannelInfo* channel_info) const {
-  return operations_->SetChannelFlags(options_, set, channel_info);
+  operations_->AppendRenameFlags(command_line);
 }
 
 void Product::AddDefaultShortcutProperties(
     const base::FilePath& target_exe,
     ShellUtil::ShortcutProperties* properties) const {
   return operations_->AddDefaultShortcutProperties(
       distribution_, target_exe, properties);
 }
 
 void Product::LaunchUserExperiment(const base::FilePath& setup_path,
                                    InstallStatus status,
                                    bool system_level) const {
   if (distribution_->HasUserExperiments()) {
     VLOG(1) << "LaunchUserExperiment status: " << status << " product: "
             << distribution_->GetDisplayName()
             << " system_level: " << system_level;
-    operations_->LaunchUserExperiment(
-        setup_path, options_, status, system_level);
+    operations_->LaunchUserExperiment(setup_path, status, system_level);
   }
 }
 
 }  // namespace installer