chrome/installer/util/chrome_frame_operations.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/installer/util/chrome_frame_operations.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/files/file_path.h"
   9 #include "base/logging.h"
  10 #include "chrome/installer/util/channel_info.h"
  11 #include "chrome/installer/util/helper.h"
  12 #include "chrome/installer/util/master_preferences.h"
  13 #include "chrome/installer/util/master_preferences_constants.h"
  14 #include "chrome/installer/util/util_constants.h"
  15
  16 namespace installer {
  17
  18 void ChromeFrameOperations::ReadOptions(const MasterPreferences& prefs,
  19                                         std::set<base::string16>* options)
  20     const {
  21   DCHECK(options);
  22
  23   static const struct PrefToOption {
  24     const char* pref_name;
  25     const wchar_t* option_name;
  26   } map[] = {
  27     { master_preferences::kMultiInstall, kOptionMultiInstall }
  28   };
  29
  30   bool pref_value;
  31
  32   for (const PrefToOption* scan = &map[0], *end = &map[arraysize(map)];
  33        scan != end; ++scan) {
  34     if (prefs.GetBool(scan->pref_name, &pref_value) && pref_value)
  35       options->insert(scan->option_name);
  36   }
  37 }
  38
  39 void ChromeFrameOperations::ReadOptions(const CommandLine& uninstall_command,
  40                                         std::set<base::string16>* options)
  41     const {
  42   DCHECK(options);
  43
  44   static const struct FlagToOption {
  45     const char* flag_name;
  46     const wchar_t* option_name;
  47   } map[] = {
  48     { switches::kMultiInstall, kOptionMultiInstall }
  49   };
  50
  51   for (const FlagToOption* scan = &map[0], *end = &map[arraysize(map)];
  52        scan != end; ++scan) {
  53     if (uninstall_command.HasSwitch(scan->flag_name))
  54       options->insert(scan->option_name);
  55   }
  56 }
  57
  58 void ChromeFrameOperations::AddKeyFiles(
  59     const std::set<base::string16>& options,
  60     std::vector<base::FilePath>* key_files) const {
  61   DCHECK(key_files);
  62   key_files->push_back(base::FilePath(installer::kChromeFrameDll));
  63   key_files->push_back(base::FilePath(installer::kChromeFrameHelperExe));
  64 }
  65
  66 void ChromeFrameOperations::AddComDllList(
  67     const std::set<base::string16>& options,
  68     std::vector<base::FilePath>* com_dll_list) const {
  69   DCHECK(com_dll_list);
  70   com_dll_list->push_back(base::FilePath(installer::kChromeFrameDll));
  71 }
  72
  73 void ChromeFrameOperations::AppendProductFlags(
  74     const std::set<base::string16>& options,
  75     CommandLine* cmd_line) const {
  76   DCHECK(cmd_line);
  77   bool is_multi_install = options.find(kOptionMultiInstall) != options.end();
  78
  79   // Add --multi-install if it isn't already there.
  80   if (is_multi_install && !cmd_line->HasSwitch(switches::kMultiInstall))
  81     cmd_line->AppendSwitch(switches::kMultiInstall);
  82
  83   // --chrome-frame is always needed.
  84   cmd_line->AppendSwitch(switches::kChromeFrame);
  85 }
  86
  87 void ChromeFrameOperations::AppendRenameFlags(
  88     const std::set<base::string16>& options,
  89     CommandLine* cmd_line) const {
  90   DCHECK(cmd_line);
  91   bool is_multi_install = options.find(kOptionMultiInstall) != options.end();
  92
  93   // Add --multi-install if it isn't already there.
  94   if (is_multi_install && !cmd_line->HasSwitch(switches::kMultiInstall))
  95     cmd_line->AppendSwitch(switches::kMultiInstall);
  96
  97   // --chrome-frame is needed for single installs.
  98   if (!is_multi_install)
  99     cmd_line->AppendSwitch(switches::kChromeFrame);
 100 }
 101
 102 bool ChromeFrameOperations::SetChannelFlags(
 103     const std::set<base::string16>& options,
 104     bool set,
 105     ChannelInfo* channel_info) const {
 106 #if defined(GOOGLE_CHROME_BUILD)
 107   DCHECK(channel_info);
 108   bool modified = channel_info->SetChromeFrame(set);
 109
 110   // Unconditionally remove the legacy -readymode flag.
 111   modified |= channel_info->SetReadyMode(false);
 112
 113   return modified;
 114 #else
 115   return false;
 116 #endif
 117 }
 118
 119 bool ChromeFrameOperations::ShouldCreateUninstallEntry(
 120     const std::set<base::string16>& options) const {
 121   return true;
 122 }
 123
 124 void ChromeFrameOperations::AddDefaultShortcutProperties(
 125     BrowserDistribution* dist,
 126     const base::FilePath& target_exe,
 127     ShellUtil::ShortcutProperties* properties) const {
 128   NOTREACHED() << "Chrome Frame does not create shortcuts.";
 129 }
 130
 131 void ChromeFrameOperations::LaunchUserExperiment(
 132     const base::FilePath& setup_path,
 133     const std::set<base::string16>& options,
 134     InstallStatus status,
 135     bool system_level) const {
 136   // No experiments yet.  If adding some in the future, need to have
 137   // ChromeFrameDistribution::HasUserExperiments() return true.
 138   NOTREACHED();
 139 }
 140
 141 }  // namespace installer