src/chrome/installer/util/auto_launch_util.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/auto_launch_util.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/files/file_path.h"
   9 #include "base/logging.h"
  10 #include "base/path_service.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "base/win/win_util.h"
  14 #include "chrome/common/chrome_constants.h"
  15 #include "chrome/common/chrome_switches.h"
  16 #include "chrome/common/chrome_version_info.h"
  17 #include "chrome/installer/util/browser_distribution.h"
  18 #include "chrome/installer/util/product.h"
  19 #include "chrome/installer/util/util_constants.h"
  20 #include "crypto/sha2.h"
  21
  22 namespace auto_launch_util {
  23
  24 // The prefix of the Chrome Auto-launch key under the Run key.
  25 const wchar_t kAutolaunchKeyValue[] = L"GoogleChromeAutoLaunch";
  26
  27 // We use one Run key with flags specifying which feature we want to start up.
  28 // When we change our Run key we need to specify what we want to do with each
  29 // flag. This lists the possible actions we can take with the flags.
  30 enum FlagSetting {
  31   FLAG_DISABLE,   // Disable the flag.
  32   FLAG_ENABLE,    // Enable the flag.
  33   FLAG_PRESERVE,  // Preserve the value that the flag has currently.
  34 };
  35
  36 // A helper function that takes a |profile_path| and builds a registry key
  37 // name to use when deciding where to read/write the auto-launch value
  38 // to/from. It takes into account the name of the profile (so that different
  39 // installations of Chrome don't conflict, and so the in the future different
  40 // profiles can be auto-launched (or not) separately).
  41 string16 ProfileToKeyName(const string16& profile_directory) {
  42   base::FilePath path;
  43   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
  44   if (command_line.HasSwitch(switches::kUserDataDir)) {
  45     path = command_line.GetSwitchValuePath(switches::kUserDataDir);
  46   } else {
  47     // Get the path from the same source as the installer, to make sure there
  48     // are no differences.
  49     BrowserDistribution* distribution =
  50         BrowserDistribution::GetSpecificDistribution(
  51             BrowserDistribution::CHROME_BROWSER);
  52     installer::Product product(distribution);
  53     std::vector<base::FilePath> data_dir_paths;
  54     product.GetUserDataPaths(&data_dir_paths);
  55     if (!data_dir_paths.empty())
  56       path = data_dir_paths[0];
  57   }
  58   path = path.Append(profile_directory);
  59
  60   std::string input(path.AsUTF8Unsafe());
  61   uint8 hash[16];
  62   crypto::SHA256HashString(input, hash, sizeof(hash));
  63   std::string hash_string = base::HexEncode(hash, sizeof(hash));
  64   return string16(kAutolaunchKeyValue) +
  65       ASCIIToWide("_") + ASCIIToWide(hash_string);
  66 }
  67
  68 // Returns whether the Chrome executable specified in |application_path| is set
  69 // to auto-launch at computer startup with a given |command_line_switch|.
  70 // NOTE: |application_path| is optional and should be blank in most cases (as
  71 // it will default to the application path of the current executable).
  72 // |profile_directory| is the name of the directory (leaf, not the full path)
  73 // that contains the profile that should be opened at computer startup.
  74 // |command_line_switch| is the switch we are optionally interested in and, if
  75 // not blank, must be present for the function to return true. If blank, it acts
  76 // like a wildcard.
  77 bool WillLaunchAtLoginWithSwitch(const base::FilePath& application_path,
  78                                  const string16& profile_directory,
  79                                  const std::string& command_line_switch) {
  80   string16 key_name(ProfileToKeyName(profile_directory));
  81   string16 autolaunch;
  82   if (!base::win::ReadCommandFromAutoRun(
  83       HKEY_CURRENT_USER, key_name, &autolaunch)) {
  84     return false;
  85   }
  86
  87   base::FilePath chrome_exe(application_path);
  88   if (chrome_exe.empty()) {
  89     if (!PathService::Get(base::DIR_EXE, &chrome_exe)) {
  90       NOTREACHED();
  91       return false;
  92     }
  93   }
  94   chrome_exe = chrome_exe.Append(installer::kChromeExe);
  95
  96   if (autolaunch.find(chrome_exe.value()) == string16::npos)
  97     return false;
  98
  99   return command_line_switch.empty() ||
 100          autolaunch.find(ASCIIToUTF16(command_line_switch)) != string16::npos;
 101 }
 102
 103 bool AutoStartRequested(const string16& profile_directory,
 104                         bool window_requested,
 105                         const base::FilePath& application_path) {
 106   if (window_requested) {
 107     return WillLaunchAtLoginWithSwitch(application_path,
 108                                        profile_directory,
 109                                        switches::kAutoLaunchAtStartup);
 110   } else {
 111     // Background mode isn't profile specific, but is attached to the Run key
 112     // for the Default profile.
 113     return WillLaunchAtLoginWithSwitch(application_path,
 114                                        ASCIIToUTF16(chrome::kInitialProfile),
 115                                        switches::kNoStartupWindow);
 116   }
 117 }
 118
 119 bool CheckAndRemoveDeprecatedBackgroundModeSwitch() {
 120   // For backwards compatibility we need to provide a migration path from the
 121   // previously used key "chromium" that the BackgroundMode used to set, as it
 122   // is incompatible with the new key (can't have two Run keys with
 123   // conflicting switches).
 124   string16 chromium = ASCIIToUTF16("chromium");
 125   string16 value;
 126   if (base::win::ReadCommandFromAutoRun(HKEY_CURRENT_USER, chromium, &value)) {
 127     if (value.find(ASCIIToUTF16(switches::kNoStartupWindow)) !=
 128         string16::npos) {
 129       base::win::RemoveCommandFromAutoRun(HKEY_CURRENT_USER, chromium);
 130       return true;
 131     }
 132   }
 133
 134   return false;
 135 }
 136
 137 void SetWillLaunchAtLogin(const base::FilePath& application_path,
 138                           const string16& profile_directory,
 139                           FlagSetting foreground_mode,
 140                           FlagSetting background_mode) {
 141   if (CheckAndRemoveDeprecatedBackgroundModeSwitch()) {
 142     // We've found the deprecated switch, we must migrate it (unless background
 143     // mode is being turned off).
 144     if (profile_directory == ASCIIToUTF16(chrome::kInitialProfile) &&
 145         background_mode == FLAG_PRESERVE) {
 146       // Preserve in this case also covers the deprecated value, so we must
 147       // explicitly turn the flag on and the rest will be taken care of below.
 148       background_mode = FLAG_ENABLE;
 149     } else {
 150       // When we add support for multiple profiles for foreground mode we need
 151       // to think about where to store the background mode switch. I think we
 152       // need to store it with the Default profile (call SetWillLaunchAtLogin
 153       // again specifying the Default profile), but concerns were raised in
 154       // review.
 155       NOTREACHED();
 156     }
 157   }
 158   string16 key_name(ProfileToKeyName(profile_directory));
 159
 160   // Check which feature should be enabled.
 161   bool in_foreground =
 162       foreground_mode == FLAG_ENABLE ||
 163       (foreground_mode == FLAG_PRESERVE &&
 164           WillLaunchAtLoginWithSwitch(application_path,
 165                                       profile_directory,
 166                                       switches::kAutoLaunchAtStartup));
 167   bool in_background =
 168       background_mode == FLAG_ENABLE ||
 169       (background_mode == FLAG_PRESERVE &&
 170           WillLaunchAtLoginWithSwitch(application_path,
 171                                       profile_directory,
 172                                       switches::kNoStartupWindow));
 173
 174   // TODO(finnur): Convert this into a shortcut, instead of using the Run key.
 175   if (in_foreground || in_background) {
 176     base::FilePath path(application_path);
 177     if (path.empty()) {
 178       if (!PathService::Get(base::DIR_EXE, &path)) {
 179         NOTREACHED();
 180         return;
 181       }
 182     }
 183     string16 cmd_line = ASCIIToUTF16("\"");
 184     cmd_line += path.value();
 185     cmd_line += ASCIIToUTF16("\\");
 186     cmd_line += installer::kChromeExe;
 187     cmd_line += ASCIIToUTF16("\"");
 188
 189     if (in_background) {
 190       cmd_line += ASCIIToUTF16(" --");
 191       cmd_line += ASCIIToUTF16(switches::kNoStartupWindow);
 192     }
 193     if (in_foreground) {
 194       cmd_line += ASCIIToUTF16(" --");
 195       cmd_line += ASCIIToUTF16(switches::kAutoLaunchAtStartup);
 196
 197       const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 198       if (command_line.HasSwitch(switches::kUserDataDir)) {
 199         cmd_line += ASCIIToUTF16(" --");
 200         cmd_line += ASCIIToUTF16(switches::kUserDataDir);
 201         cmd_line += ASCIIToUTF16("=\"");
 202         cmd_line +=
 203             command_line.GetSwitchValuePath(switches::kUserDataDir).value();
 204         cmd_line += ASCIIToUTF16("\"");
 205       }
 206
 207       cmd_line += ASCIIToUTF16(" --");
 208       cmd_line += ASCIIToUTF16(switches::kProfileDirectory);
 209       cmd_line += ASCIIToUTF16("=\"");
 210       cmd_line += profile_directory;
 211       cmd_line += ASCIIToUTF16("\"");
 212     }
 213
 214     base::win::AddCommandToAutoRun(
 215         HKEY_CURRENT_USER, key_name, cmd_line);
 216   } else {
 217     base::win::RemoveCommandFromAutoRun(HKEY_CURRENT_USER, key_name);
 218   }
 219 }
 220
 221 void DisableAllAutoStartFeatures(const string16& profile_directory) {
 222   DisableForegroundStartAtLogin(profile_directory);
 223   DisableBackgroundStartAtLogin();
 224 }
 225
 226 void EnableForegroundStartAtLogin(const string16& profile_directory,
 227                                   const base::FilePath& application_path) {
 228   SetWillLaunchAtLogin(
 229       application_path, profile_directory, FLAG_ENABLE, FLAG_PRESERVE);
 230 }
 231
 232 void DisableForegroundStartAtLogin(const string16& profile_directory) {
 233   SetWillLaunchAtLogin(
 234       base::FilePath(), profile_directory, FLAG_DISABLE, FLAG_PRESERVE);
 235 }
 236
 237 void EnableBackgroundStartAtLogin() {
 238   // Background mode isn't profile specific, but we specify the Default profile
 239   // just to have a unique Run key to attach it to. FilePath is blank because
 240   // this function is not called from the installer (see comments for
 241   // EnableAutoStartAtLogin).
 242   SetWillLaunchAtLogin(base::FilePath(),
 243                        ASCIIToUTF16(chrome::kInitialProfile),
 244                        FLAG_PRESERVE,
 245                        FLAG_ENABLE);
 246 }
 247
 248 void DisableBackgroundStartAtLogin() {
 249   SetWillLaunchAtLogin(base::FilePath(),
 250                        ASCIIToUTF16(chrome::kInitialProfile),
 251                        FLAG_PRESERVE,
 252                        FLAG_DISABLE);
 253 }
 254
 255 }  // namespace auto_launch_util