Resolve the conflict that auto-launch has with the background mode feature (part 1).

chrome/installer/util/auto_launch_util.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/auto_launch_util.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/win_util.h"
+#include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/product.h"
 #include "chrome/installer/util/util_constants.h"
 #include "crypto/sha2.h"
 
 namespace auto_launch_util {
 
 // The prefix of the Chrome Auto-launch key under the Run key.
 const wchar_t kAutolaunchKeyValue[] = L"GoogleChromeAutoLaunch";
 
+// We use one Run key with flags specifying which feature we want to start up.
+// When we change our Run key we need to specify what we want to do with each
+// flag. This lists the possible actions we can take with the flags.
+enum FlagSetting {
+  FLAG_DISABLE,   // Disable the flag.
+  FLAG_ENABLE,    // Enable the flag.
+  FLAG_PRESERVE,  // Preserve the value that the flag has currently.
+};
+
 // A helper function that takes a |profile_path| and builds a registry key
 // name to use when deciding where to read/write the auto-launch value
 // to/from. It takes into account the name of the profile (so that different
 // installations of Chrome don't conflict, and so the in the future different
 // profiles can be auto-launched (or not) separately).
 string16 ProfileToKeyName(const string16& profile_directory) {
   FilePath path;
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kUserDataDir)) {
     path = command_line.GetSwitchValuePath(switches::kUserDataDir);
   } else {
     // Get the path from the same source as the installer, to make sure there
     // are no differences.
     BrowserDistribution* distribution =
         BrowserDistribution::GetSpecificDistribution(
             BrowserDistribution::CHROME_BROWSER);
     installer::Product product(distribution);
     path = product.GetUserDataPath();
   }
   path = path.Append(profile_directory);
 
   std::string input(path.AsUTF8Unsafe());
   uint8 hash[16];
   crypto::SHA256HashString(input, hash, sizeof(hash));
   std::string hash_string = base::HexEncode(hash, sizeof(hash));
   return string16(kAutolaunchKeyValue) +
       ASCIIToWide("_") + ASCIIToWide(hash_string);
 }
 
-bool WillLaunchAtLogin(const FilePath& application_path,
-                       const string16& profile_directory) {
+// Returns whether the Chrome executable specified in |application_path| is set
+// to auto-launch at computer startup with a given |command_line_switch|.
+// NOTE: |application_path| is optional and should be blank in most cases (as
+// it will default to the application path of the current executable).
+// |profile_directory| is the name of the directory (leaf, not the full path)
+// that contains the profile that should be opened at computer startup.
+// |command_line_switch| is the switch we are optionally interested in and, if
+// not blank, must be present for the function to return true. If blank, it acts
+// like a wildcard.
+bool WillLaunchAtLoginWithSwitch(const FilePath& application_path,
+                                 const string16& profile_directory,
+                                 const std::string& command_line_switch) {
   string16 key_name(ProfileToKeyName(profile_directory));
   string16 autolaunch;
   if (!base::win::ReadCommandFromAutoRun(
       HKEY_CURRENT_USER, key_name, &autolaunch)) {
     return false;
   }
 
   FilePath chrome_exe(application_path);
   if (chrome_exe.empty()) {
     if (!PathService::Get(base::DIR_EXE, &chrome_exe)) {
       NOTREACHED();
       return false;
     }
   }
   chrome_exe = chrome_exe.Append(installer::kChromeExe);
 
-  return autolaunch.find(chrome_exe.value()) != string16::npos;
+  if (autolaunch.find(chrome_exe.value()) == string16::npos)
+    return false;
+
+  return command_line_switch.empty() ||
+         autolaunch.find(ASCIIToUTF16(command_line_switch)) != string16::npos;
 }
 
-void SetWillLaunchAtLogin(bool auto_launch,
-                          const FilePath& application_path,
-                          const string16& profile_directory) {
+bool AutoStartRequested(const string16& profile_directory,
+                        bool window_requested,
+                        const FilePath& application_path) {
+  if (window_requested) {
+    return WillLaunchAtLoginWithSwitch(application_path,
+                                       profile_directory,
+                                       switches::kAutoLaunchAtStartup);
+  } else {
+    // Background mode isn't profile specific, but is attached to the Run key
+    // for the Default profile.
+    return WillLaunchAtLoginWithSwitch(application_path,
+                                       ASCIIToUTF16(chrome::kInitialProfile),
+                                       switches::kNoStartupWindow);
+  }
+}
+
+bool HasDeprecatedBackgroundModeSwitch() {

[Andrew T Wilson (Slow), 2012/04/18 23:07:51]

I think this should probably be called RemoveDeprecated... since it has the side
effect of removing the switch.

[Finnur, 2012/04/19 17:53:51]

Good idea.

How about: CheckAndRemoveDeprecatedBackgroundModeSwitch?

On 2012/04/18 23:07:51, Andrew T Wilson wrote:

+  // For backwards compatibility we need to provide a migration path from the
+  // previously used key "chromium" that the BackgroundMode used to set, as it
+  // is incompatible with the new key (can't have two Run keys with
+  // conflicting switches).
+  string16 chromium = ASCIIToUTF16("chromium");
+  string16 value;
+  if (base::win::ReadCommandFromAutoRun(HKEY_CURRENT_USER, chromium, &value)) {
+    if (value.find(ASCIIToUTF16(switches::kNoStartupWindow)) !=
+        string16::npos) {
+      base::win::RemoveCommandFromAutoRun(HKEY_CURRENT_USER, chromium);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void SetWillLaunchAtLogin(const FilePath& application_path,
+                          const string16& profile_directory,
+                          FlagSetting foreground_mode,
+                          FlagSetting background_mode) {
+  if (HasDeprecatedBackgroundModeSwitch()) {
+    // We've found the deprecated switch, we must migrate it (unless background
+    // mode is being turned off).
+    if (profile_directory == ASCIIToUTF16(chrome::kInitialProfile) &&
+        background_mode == FLAG_PRESERVE) {
+      // Preserve in this case also covers the deprecated value, so we must
+      // explicitly turn the flag on and the rest will be taken care of below.
+      background_mode = FLAG_ENABLE;
+    } else {
+      // Since the background mode is stored with the Default profile Run key
+      // we need to make an extra call to SetWillLaunchAtLogin.

[Andrew T Wilson (Slow), 2012/04/18 23:07:51]

What case does this cover? So, if someone passes in a profile_directory !=
kInitialProfile, then we write a key, then overwrite it below? Why is this
necessary?

[Finnur, 2012/04/19 17:53:51]

Yes, this is the "profile_directory != kInitialProfile" case. Note that we are
calling SetWillLaunchAtLogin with kInitialProfile because we always store the
background mode setting with the Default profile.

Once that completes we continue below, but note that we are not overwriting the
key below since we're dealing with a different Run key (for another profile,
since profile_directory != kInitialProfile).

On 2012/04/18 23:07:51, Andrew T Wilson wrote:

[Andrew T Wilson (Slow), 2012/04/20 00:30:13]

Let's put a NOTREACHED here since I don't think this is doing the right thing
(we don't want to have two instances of chrome being launched and we need to
figure out what the right UX would be if we ever want to support multi-profiles
with auto-launch).

+      SetWillLaunchAtLogin(application_path,
+                           ASCIIToUTF16(chrome::kInitialProfile),
+                           FLAG_PRESERVE,  // Foreground mode.
+                           FLAG_ENABLE);   // Background mode.
+    }
+  }
   string16 key_name(ProfileToKeyName(profile_directory));
 
+  // Check which feature should be enabled.
+  bool in_foreground =
+      foreground_mode == FLAG_ENABLE ||
+      (foreground_mode == FLAG_PRESERVE &&
+          WillLaunchAtLoginWithSwitch(application_path,
+                                      profile_directory,
+                                      switches::kAutoLaunchAtStartup));
+  bool in_background =
+      background_mode == FLAG_ENABLE ||
+      (background_mode == FLAG_PRESERVE &&
+          WillLaunchAtLoginWithSwitch(application_path,
+                                      profile_directory,
+                                      switches::kNoStartupWindow));
+
   // TODO(finnur): Convert this into a shortcut, instead of using the Run key.
-  if (auto_launch) {
+  if (in_foreground || in_background) {
     FilePath path(application_path);
     if (path.empty()) {
       if (!PathService::Get(base::DIR_EXE, &path)) {
         NOTREACHED();
         return;
       }
     }
     string16 cmd_line = ASCIIToUTF16("\"");
     cmd_line += path.value();
     cmd_line += ASCIIToUTF16("\\");
     cmd_line += installer::kChromeExe;
-    cmd_line += ASCIIToUTF16("\" --");
-    cmd_line += ASCIIToUTF16(switches::kAutoLaunchAtStartup);
+    cmd_line += ASCIIToUTF16("\"");
 
-    const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-    if (command_line.HasSwitch(switches::kUserDataDir)) {
+    if (in_background) {
       cmd_line += ASCIIToUTF16(" --");
-      cmd_line += ASCIIToUTF16(switches::kUserDataDir);
+      cmd_line += ASCIIToUTF16(switches::kNoStartupWindow);
+    }
+    if (in_foreground) {
+      cmd_line += ASCIIToUTF16(" --");
+      cmd_line += ASCIIToUTF16(switches::kAutoLaunchAtStartup);
+
+      const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+      if (command_line.HasSwitch(switches::kUserDataDir)) {
+        cmd_line += ASCIIToUTF16(" --");
+        cmd_line += ASCIIToUTF16(switches::kUserDataDir);
+        cmd_line += ASCIIToUTF16("=\"");
+        cmd_line +=
+            command_line.GetSwitchValuePath(switches::kUserDataDir).value();
+        cmd_line += ASCIIToUTF16("\"");
+      }
+
+      cmd_line += ASCIIToUTF16(" --");
+      cmd_line += ASCIIToUTF16(switches::kProfileDirectory);
       cmd_line += ASCIIToUTF16("=\"");
-      cmd_line +=
-          command_line.GetSwitchValuePath(switches::kUserDataDir).value();
+      cmd_line += profile_directory;
       cmd_line += ASCIIToUTF16("\"");
     }
 
-    cmd_line += ASCIIToUTF16(" --");
-    cmd_line += ASCIIToUTF16(switches::kProfileDirectory);
-    cmd_line += ASCIIToUTF16("=\"");
-    cmd_line += profile_directory;
-    cmd_line += ASCIIToUTF16("\"");
-
     base::win::AddCommandToAutoRun(
         HKEY_CURRENT_USER, key_name, cmd_line);
   } else {
     base::win::RemoveCommandFromAutoRun(HKEY_CURRENT_USER, key_name);
   }
 }
 
+void DisableAllAutoStartFeatures(const string16& profile_directory) {
+  DisableForegroundStartAtLogin(profile_directory);
+  DisableBackgroundStartAtLogin();
+}
+
+void EnableForegroundStartAtLogin(const string16& profile_directory,
+                                  const FilePath& application_path) {
+  SetWillLaunchAtLogin(
+      application_path, profile_directory, FLAG_ENABLE, FLAG_PRESERVE);
+}
+
+void DisableForegroundStartAtLogin(const string16& profile_directory) {
+  SetWillLaunchAtLogin(
+      FilePath(), profile_directory, FLAG_DISABLE, FLAG_PRESERVE);
+}
+
+void EnableBackgroundStartAtLogin() {
+  // Background mode isn't profile specific, but we specify the Default profile
+  // just to have a unique Run key to attach it to. FilePath is blank because
+  // this function is not called from the installer (see comments for
+  // EnableAutoStartAtLogin).
+  SetWillLaunchAtLogin(FilePath(),
+                       ASCIIToUTF16(chrome::kInitialProfile),
+                       FLAG_PRESERVE,
+                       FLAG_ENABLE);
+}
+
+void DisableBackgroundStartAtLogin() {
+  SetWillLaunchAtLogin(FilePath(),
+                       ASCIIToUTF16(chrome::kInitialProfile),
+                       FLAG_PRESERVE,
+                       FLAG_DISABLE);
+}
+
 }  // namespace auto_launch_util