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

chrome/browser/ui/browser_init.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/browser/ui/browser_init.h"
 
 #include <algorithm>   // For max().
 #include <set>
 
 #include "base/bind.h"
@@ skipping 239 matching lines @@
 
   // Track infobar reponse.
   auto_launch_trial::UpdateInfobarResponseMetric(
       auto_launch_trial::INFOBAR_CUT_IT_OUT);
   // Also make sure we keep track of how many disable and how many enable.
   const bool auto_launch = false;
   auto_launch_trial::UpdateToggleAutoLaunchMetric(auto_launch);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&auto_launch_util::SetWillLaunchAtLogin,
-                 auto_launch,
-                 FilePath(),
-                 profile_->GetPath().BaseName().value()));
+      base::Bind(&auto_launch_util::DisableAutoStartAtLogin,
+                 profile_->GetPath().BaseName().value()));  // Background mode.

[Finnur, 2012/04/16 18:09:07]

Comment removed locally.

   return true;
 }
 
 // Metro driver export, this is how metro passes the initial navigated url
 // back to us.
 extern "C" {
 typedef const wchar_t* (*GetInitialUrl)();
 }
 
 
@@ skipping 95 matching lines @@
 
 bool DefaultBrowserInfoBarDelegate::Cancel() {
   action_taken_ = true;
   UMA_HISTOGRAM_COUNTS("DefaultBrowserWarning.DontSetAsDefault", 1);
   // User clicked "Don't ask me again", remember that.
   prefs_->SetBoolean(prefs::kCheckDefaultBrowser, false);
   return true;
 }
 
 #if defined(OS_WIN)
-void CheckAutoLaunchCallback() {
+void CheckAutoLaunchCallback(Profile* profile) {
   if (!auto_launch_trial::IsInAutoLaunchGroup())
     return;
 
-  Browser* browser = BrowserList::GetLastActive();
+  // We must not use GetLastActive here because this is at Chrome startup and
+  // no window might have been made active yet. We'll settle for any window.
+  Browser* browser = BrowserList::FindAnyBrowser(profile, true);

[grt (UTC plus 2), 2012/04/16 19:43:58]

Looks like this could potentially return NULL.  Will that never happen in this
case for some reason?

[Andrew T Wilson (Slow), 2012/04/16 22:57:33]

Agreed. Do we know this is never called with no window open (i.e. while chrome
is in bg mode)?

[Finnur, 2012/04/17 12:27:45]

Yes, this codepath doesn't execute when in background mode. That's actually what
triggered the investigation of this issue. I don't think |browser| can be NULL
here because we have a valid profile from that browser that we look up. Having
said that, I'm OK with adding a NULL check if you feel that's the right thing to
do.

On 2012/04/16 22:57:33, Andrew T Wilson wrote:

   TabContentsWrapper* tab = browser->GetSelectedTabContentsWrapper();
 
   // Don't show the info-bar if there are already info-bars showing.
   InfoBarTabHelper* infobar_helper = tab->infobar_tab_helper();
   if (infobar_helper->infobar_count() > 0)
     return;
 
   infobar_helper->AddInfoBar(
       new AutolaunchInfoBarDelegate(infobar_helper,
       tab->profile()->GetPrefs(), tab->profile()));
@@ skipping 672 matching lines @@
       return (app_tab != NULL);
     }
   }
   return false;
 }
 
 void BrowserInit::LaunchWithProfile::ProcessLaunchURLs(
     bool process_startup,
     const std::vector<GURL>& urls_to_open) {
   // If we're starting up in "background mode" (no open browser window) then
-  // don't open any browser windows.
-  if (process_startup && command_line_.HasSwitch(switches::kNoStartupWindow))
+  // don't open any browser windows, unless kAutoLaunchAtStartup is also
+  // specified.
+  if (process_startup &&
+      command_line_.HasSwitch(switches::kNoStartupWindow) &&
+      !command_line_.HasSwitch(switches::kAutoLaunchAtStartup)) {
     return;
+  }
 
   if (process_startup && ProcessStartupURLs(urls_to_open)) {
     // ProcessStartupURLs processed the urls, nothing else to do.
     return;
   }
 
   IsProcessStartup is_process_startup = process_startup ?
       IS_PROCESS_STARTUP : IS_NOT_PROCESS_STARTUP;
   if (!process_startup) {
     // Even if we're not starting a new process, this may conceptually be
@@ skipping 474 matching lines @@
   if (infobar_shown >= kMaxInfobarShown)
     return false;
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kChromeFrame))
     return false;
 
   if (command_line.HasSwitch(switches::kAutoLaunchAtStartup) ||
       first_run::IsChromeFirstRun()) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                            base::Bind(&CheckAutoLaunchCallback));
+                            base::Bind(&CheckAutoLaunchCallback, profile));
     return true;
   }
 #endif
   return false;
 }
 
 void BrowserInit::LaunchWithProfile::CheckPreferencesBackup(Profile* profile) {
   ProtectorService* protector_service =
       ProtectorServiceFactory::GetForProfile(profile);
   ProtectedPrefsWatcher* prefs_watcher = protector_service->GetPrefsWatcher();
@@ skipping 130 matching lines @@
   // Look for the testing channel ID ONLY during process startup
   if (process_startup &&
       command_line.HasSwitch(switches::kTestingChannelID)) {
     std::string testing_channel_id = command_line.GetSwitchValueASCII(
         switches::kTestingChannelID);
     // TODO(sanjeevr) Check if we need to make this a singleton for
     // compatibility with the old testing code
     // If there are any extra parameters, we expect each one to generate a
     // new tab; if there are none then we get one homepage tab.
     int expected_tab_count = 1;
-    if (command_line.HasSwitch(switches::kNoStartupWindow)) {
+    if (command_line.HasSwitch(switches::kNoStartupWindow) &&
+        !command_line.HasSwitch(switches::kAutoLaunchAtStartup)) {
       expected_tab_count = 0;
 #if defined(OS_CHROMEOS)
     // kLoginManager will cause Chrome to start up with the ChromeOS login
     // screen instead of a browser window, so it won't load any tabs.
     } else if (command_line.HasSwitch(switches::kLoginManager)) {
       expected_tab_count = 0;
 #endif
     } else if (command_line.HasSwitch(switches::kRestoreLastSession)) {
       std::string restore_session_value(
           command_line.GetSwitchValueASCII(switches::kRestoreLastSession));
@@ skipping 197 matching lines @@
 
   Profile* profile = ProfileManager::GetLastUsedProfile();
   if (!profile) {
     // We should only be able to get here if the profile already exists and
     // has been created.
     NOTREACHED();
     return;
   }
   ProcessCmdLineImpl(cmd_line, cur_dir, false, profile, Profiles(), NULL, NULL);
 }