Linux: Fix regression with --kiosk.

chrome/browser/ui/startup/startup_browser_creator_impl.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/startup/startup_browser_creator_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "apps/app_restore_service.h"
@@ skipping 337 matching lines @@
     }
   }
 
   // Open the required browser windows and tabs. First, see if
   // we're being run as an application window. If so, the user
   // opened an app shortcut.  Don't restore tabs or open initial
   // URLs in that case. The user should see the window as an app,
   // not as chrome.
   // Special case is when app switches are passed but we do want to restore
   // session. In that case open app window + focus it after session is restored.
-  content::WebContents* app_contents = NULL;
+  content::WebContents* app_contents = nullptr;
+  Browser* browser = nullptr;
   if (OpenApplicationWindow(profile, &app_contents)) {
     RecordLaunchModeHistogram(LM_AS_WEBAPP);
   } else {
     RecordLaunchModeHistogram(urls_to_open.empty() ?
                               LM_TO_BE_DECIDED : LM_WITH_URLS);
 
-    ProcessLaunchURLs(process_startup, urls_to_open, desktop_type);
+    browser = ProcessLaunchURLs(process_startup, urls_to_open, desktop_type);
 
     if (command_line_.HasSwitch(switches::kInstallChromeApp)) {
       install_chrome_app::InstallChromeApp(
           command_line_.GetSwitchValueASCII(switches::kInstallChromeApp));
     }
 
     // If this is an app launch, but we didn't open an app window, it may
     // be an app tab.
     OpenApplicationTab(profile);
 
 #if defined(OS_MACOSX)
     if (process_startup) {
       // Check whether the auto-update system needs to be promoted from user
       // to system.
       KeystoneInfoBar::PromotionInfoBar(profile);
     }
 #endif
   }
 
   // In kiosk mode, we want to always be fullscreen, so switch to that now.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kKioskMode) ||
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kStartFullscreen)) {
     // It's possible for there to be no browser window, e.g. if someone
     // specified a non-sensical combination of options
     // ("--kiosk --no_startup_window"); do nothing in that case.
-    Browser* browser = BrowserList::GetInstance(desktop_type)->GetLastActive();
     if (browser)
       chrome::ToggleFullscreenMode(browser);
   }
 
 #if defined(OS_WIN)
   if (process_startup)
     ShellIntegration::MigrateChromiumShortcuts();
 #endif  // defined(OS_WIN)
 
   return true;
@@ skipping 112 matching lines @@
 
       if (out_app_contents)
         *out_app_contents = app_tab;
 
       return (app_tab != NULL);
     }
   }
   return false;
 }
 
-void StartupBrowserCreatorImpl::ProcessLaunchURLs(
+Browser* StartupBrowserCreatorImpl::ProcessLaunchURLs(
     bool process_startup,
     const std::vector<GURL>& urls_to_open,
     chrome::HostDesktopType desktop_type) {
   // If we're starting up in "background mode" (no open browser window) then
   // 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;
+    return nullptr;
   }
 
 // TODO(tapted): Move this to startup_browser_creator_win.cc after refactor.
 #if defined(OS_WIN)
   if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
     // See if there are apps for this profile that should be launched on startup
     // due to a switch from Metro mode.
     app_metro_launch::HandleAppLaunchForMetroRestart(profile_);
   }
 #endif
 
-  if (process_startup && ProcessStartupURLs(urls_to_open, desktop_type)) {
-    // ProcessStartupURLs processed the urls, nothing else to do.
-    return;
+  if (process_startup) {
+    Browser* browser = ProcessStartupURLs(urls_to_open, desktop_type);
+    if (browser) {
+      // ProcessStartupURLs processed the urls, nothing else to do.
+      return browser;
+    }
   }
 
   chrome::startup::IsProcessStartup is_process_startup = process_startup ?
       chrome::startup::IS_PROCESS_STARTUP :
       chrome::startup::IS_NOT_PROCESS_STARTUP;
   if (!process_startup) {
     // Even if we're not starting a new process, this may conceptually be
     // "startup" for the user and so should be handled in a similar way.  Eg.,
     // Chrome may have been running in the background due to an app with a
     // background page being installed, or running with only an app window
     // displayed.
     SessionService* service =
         SessionServiceFactory::GetForProfileForSessionRestore(profile_);
     if (service && service->ShouldNewWindowStartSession()) {
       // Restore the last session if any.
       if (!HasPendingUncleanExit(profile_) &&
           service->RestoreIfNecessary(urls_to_open)) {
-        return;
+        return nullptr;
       }
       // Open user-specified URLs like pinned tabs and startup tabs.
       Browser* browser = ProcessSpecifiedURLs(urls_to_open, desktop_type);
       if (browser) {
         AddInfoBarsIfNecessary(browser, is_process_startup);
-        return;
+        return browser;
       }
     }
   }
 
   // Session startup didn't occur, open the urls.
-  Browser* browser = NULL;
+  Browser* browser = nullptr;
   std::vector<GURL> adjust_urls = urls_to_open;
   if (adjust_urls.empty()) {
     AddStartupURLs(&adjust_urls);
   } else if (!command_line_.HasSwitch(switches::kOpenInNewWindow)) {
     // Always open a list of urls in a window on the native desktop.
     browser = chrome::FindTabbedBrowser(profile_, false,
                                         chrome::HOST_DESKTOP_TYPE_NATIVE);
   }
   // This will launch a browser; prevent session restore.
   StartupBrowserCreator::in_synchronous_profile_launch_ = true;
   browser = OpenURLsInBrowser(browser, process_startup, adjust_urls,
                               desktop_type);
   StartupBrowserCreator::in_synchronous_profile_launch_ = false;
   AddInfoBarsIfNecessary(browser, is_process_startup);
+  return browser;
 }
 
-bool StartupBrowserCreatorImpl::ProcessStartupURLs(
+Browser* StartupBrowserCreatorImpl::ProcessStartupURLs(
     const std::vector<GURL>& urls_to_open,
     chrome::HostDesktopType desktop_type) {
   VLOG(1) << "StartupBrowserCreatorImpl::ProcessStartupURLs";
   SessionStartupPref pref =
       StartupBrowserCreator::GetSessionStartupPref(command_line_, profile_);
   if (pref.type == SessionStartupPref::LAST)
     VLOG(1) << "Pref: last";
   else if (pref.type == SessionStartupPref::URLS)
     VLOG(1) << "Pref: urls";
   else if (pref.type == SessionStartupPref::DEFAULT)
     VLOG(1) << "Pref: default";
 
   apps::AppRestoreService* restore_service =
       apps::AppRestoreServiceFactory::GetForProfile(profile_);
   // NULL in incognito mode.
   if (restore_service) {
     restore_service->HandleStartup(apps::AppRestoreService::ShouldRestoreApps(
         StartupBrowserCreator::WasRestarted()));
   }
 
   if (pref.type == SessionStartupPref::LAST) {
     if (profile_->GetLastSessionExitType() == Profile::EXIT_CRASHED &&
         !command_line_.HasSwitch(switches::kRestoreLastSession)) {
       // The last session crashed. It's possible automatically loading the
       // page will trigger another crash, locking the user out of chrome.
       // To avoid this, don't restore on startup but instead show the crashed
       // infobar.
       VLOG(1) << "Unclean exit; not processing";
-      return false;
+      return nullptr;
     }
 
     uint32 restore_behavior = SessionRestore::SYNCHRONOUS;
     if (browser_defaults::kAlwaysCreateTabbedBrowserOnSessionRestore ||
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kCreateBrowserOnStartupForTests)) {
       restore_behavior |= SessionRestore::ALWAYS_CREATE_TABBED_BROWSER;
     }
 
 #if defined(OS_MACOSX)
     // On Mac, when restoring a session with no windows, suppress the creation
     // of a new window in the case where the system is launching Chrome via a
     // login item or Lion's resume feature.
     if (base::mac::WasLaunchedAsLoginOrResumeItem()) {
       restore_behavior = restore_behavior &
                          ~SessionRestore::ALWAYS_CREATE_TABBED_BROWSER;
     }
 #endif
 
     // The startup code only executes for browsers launched in desktop mode.
     // i.e. HOST_DESKTOP_TYPE_NATIVE. Ash should never get here.
     Browser* browser = SessionRestore::RestoreSession(
         profile_, NULL, desktop_type, restore_behavior,
         urls_to_open);
 
     AddInfoBarsIfNecessary(browser, chrome::startup::IS_PROCESS_STARTUP);
-    return true;
+    return browser;
   }
 
   Browser* browser = ProcessSpecifiedURLs(urls_to_open, desktop_type);
   if (!browser)
-    return false;
+    return nullptr;
 
   AddInfoBarsIfNecessary(browser, chrome::startup::IS_PROCESS_STARTUP);
 
   // Session restore may occur if the startup preference is "last" or if the
   // crash infobar is displayed. Otherwise, it's safe for the DOM storage system
   // to start deleting leftover data.
   if (pref.type != SessionStartupPref::LAST &&
       !HasPendingUncleanExit(profile_)) {
     content::BrowserContext::GetDefaultStoragePartition(profile_)->
         GetDOMStorageContext()->StartScavengingUnusedSessionStorage();
   }
 
-  return true;
+  return browser;
 }
 
 Browser* StartupBrowserCreatorImpl::ProcessSpecifiedURLs(
     const std::vector<GURL>& urls_to_open,
     chrome::HostDesktopType desktop_type) {
   SessionStartupPref pref =
       StartupBrowserCreator::GetSessionStartupPref(command_line_, profile_);
   StartupTabs tabs;
   // Pinned tabs should not be displayed when chrome is launched in incognito
   // mode. Also, no pages should be opened automatically if the session
@@ skipping 230 matching lines @@
       // behavior is desired because completing or skipping the sync promo
       // causes a redirect to the NTP.
       if (!startup_urls->empty() &&
           startup_urls->at(0) == GURL(chrome::kChromeUINewTabURL))
         startup_urls->at(0) = sync_promo_url;
       else
         startup_urls->insert(startup_urls->begin(), sync_promo_url);
     }
   }
 }