startup: Put it in chrome namespace.

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
@@ skipping 211 matching lines @@
           extension_misc::APP_LAUNCH_AUTOLAUNCH);
     }
   }
 }
 
 }  // namespace
 
 StartupBrowserCreatorImpl::StartupBrowserCreatorImpl(
     const FilePath& cur_dir,
     const CommandLine& command_line,
-    browser::startup::IsFirstRun is_first_run)
-        : cur_dir_(cur_dir),
-          command_line_(command_line),
-          profile_(NULL),
-          browser_creator_(NULL),
-          is_first_run_(is_first_run == browser::startup::IS_FIRST_RUN) {
+    chrome::startup::IsFirstRun is_first_run)
+    : cur_dir_(cur_dir),
+      command_line_(command_line),
+      profile_(NULL),
+      browser_creator_(NULL),
+      is_first_run_(is_first_run == chrome::startup::IS_FIRST_RUN) {
 }
 
 StartupBrowserCreatorImpl::StartupBrowserCreatorImpl(
     const FilePath& cur_dir,
     const CommandLine& command_line,
     StartupBrowserCreator* browser_creator,
-    browser::startup::IsFirstRun is_first_run)
-        : cur_dir_(cur_dir),
-          command_line_(command_line),
-          profile_(NULL),
-          browser_creator_(browser_creator),
-          is_first_run_(is_first_run == browser::startup::IS_FIRST_RUN) {
+    chrome::startup::IsFirstRun is_first_run)
+    : cur_dir_(cur_dir),
+      command_line_(command_line),
+      profile_(NULL),
+      browser_creator_(browser_creator),
+      is_first_run_(is_first_run == chrome::startup::IS_FIRST_RUN) {
 }
 
 StartupBrowserCreatorImpl::~StartupBrowserCreatorImpl() {
 }
 
 bool StartupBrowserCreatorImpl::Launch(Profile* profile,
                                        const std::vector<GURL>& urls_to_open,
                                        bool process_startup) {
   DCHECK(profile);
   profile_ = profile;
@@ skipping 33 matching lines @@
   // 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;
   if (OpenApplicationWindow(profile, &app_contents) &&
       !browser_defaults::kAppRestoreSession) {
     RecordLaunchModeHistogram(LM_AS_WEBAPP);
   } else {
-    RecordLaunchModeHistogram(urls_to_open.empty()?
+    RecordLaunchModeHistogram(urls_to_open.empty() ?
                               LM_TO_BE_DECIDED : LM_WITH_URLS);
 
     // Notify user if the Preferences backup is invalid or changes to settings
     // affecting browser startup have been detected.
     CheckPreferencesBackup(profile);
 
     ProcessLaunchURLs(process_startup, urls_to_open);
 
     // If this is an app launch, but we didn't open an app window, it may
     // be an app tab.
     OpenApplicationTab(profile);
 
     // In case of app mode + session restore we want to focus that app.
     if (browser_defaults::kAppRestoreSession && app_contents)
       app_contents->GetView()->SetInitialFocus();
 
     if (process_startup) {
       if (browser_defaults::kOSSupportsOtherBrowsers &&
           !command_line_.HasSwitch(switches::kNoDefaultBrowserCheck)) {
-        if (!browser::ShowAutolaunchPrompt(profile))
-          browser::ShowDefaultBrowserPrompt(profile);
+        if (!chrome::ShowAutolaunchPrompt(profile))
+          chrome::ShowDefaultBrowserPrompt(profile);
       }
 #if defined(OS_MACOSX)
       // Check whether the auto-update system needs to be promoted from user
       // to system.
       KeystoneInfoBar::PromotionInfoBar(profile);
 #endif
     }
   }
 
   // If we're recording or playing back, startup the EventRecorder now
@@ skipping 147 matching lines @@
       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;
   }
 
-  browser::startup::IsProcessStartup is_process_startup = process_startup ?
-      browser::startup::IS_PROCESS_STARTUP :
-      browser::startup::IS_NOT_PROCESS_STARTUP;
+  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::GetForProfile(profile_);
     if (service && service->ShouldNewWindowStartSession()) {
       // Restore the last session if any.
       if (!HasPendingUncleanExit(profile_) &&
@@ skipping 57 matching lines @@
     if (base::mac::WasLaunchedAsLoginOrResumeItem()) {
       restore_behavior = restore_behavior &
                          ~SessionRestore::ALWAYS_CREATE_TABBED_BROWSER;
     }
 #endif
 
     Browser* browser = SessionRestore::RestoreSession(profile_,
                                                       NULL,
                                                       restore_behavior,
                                                       urls_to_open);
-    AddInfoBarsIfNecessary(browser, browser::startup::IS_PROCESS_STARTUP);
+    AddInfoBarsIfNecessary(browser, chrome::startup::IS_PROCESS_STARTUP);
     return true;
   }
 
   Browser* browser = ProcessSpecifiedURLs(urls_to_open);
   if (!browser)
     return false;
 
-  AddInfoBarsIfNecessary(browser, browser::startup::IS_PROCESS_STARTUP);
+  AddInfoBarsIfNecessary(browser, chrome::startup::IS_PROCESS_STARTUP);
   return true;
 }
 
 Browser* StartupBrowserCreatorImpl::ProcessSpecifiedURLs(
     const std::vector<GURL>& urls_to_open) {
   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 131 matching lines @@
   browser->window()->Show();
   // TODO(jcampan): http://crbug.com/8123 we should not need to set the initial
   //                focus explicitly.
   chrome::GetActiveWebContents(browser)->GetView()->SetInitialFocus();
 
   return browser;
 }
 
 void StartupBrowserCreatorImpl::AddInfoBarsIfNecessary(
     Browser* browser,
-    browser::startup::IsProcessStartup is_process_startup) {
+    chrome::startup::IsProcessStartup is_process_startup) {
   if (!browser || !profile_ || browser->tab_count() == 0)
     return;
 
   if (HasPendingUncleanExit(browser->profile()))
-    browser::ShowSessionCrashedPrompt(browser);
+    chrome::ShowSessionCrashedPrompt(browser);
 
   // The bad flags info bar and the obsolete system info bar are only added to
   // the first profile which is launched. Other profiles might be restoring the
   // browsing sessions asynchronously, so we cannot add the info bars to the
   // focused tabs here.
-  if (is_process_startup == browser::startup::IS_PROCESS_STARTUP) {
-    browser::ShowBadFlagsPrompt(browser);
-    browser::ShowObsoleteOSPrompt(browser);
+  if (is_process_startup == chrome::startup::IS_PROCESS_STARTUP) {
+    chrome::ShowBadFlagsPrompt(browser);
+    chrome::ShowObsoleteOSPrompt(browser);
   }
 }
 
 
 void StartupBrowserCreatorImpl::AddStartupURLs(
     std::vector<GURL>* startup_urls) const {
   // If we have urls specified by the first run master preferences use them
   // and nothing else.
   if (browser_creator_ && startup_urls->empty()) {
     if (!browser_creator_->first_run_tabs_.empty()) {
@@ skipping 105 matching lines @@
         // New:
         prefs->GetString(prefs::kHomePage),
         prefs->GetBoolean(prefs::kHomePageIsNewTabPage),
         prefs->GetBoolean(prefs::kShowHomeButton),
         // Backup:
         backup_homepage,
         backup_homepage_is_ntp,
         backup_show_home_button));
   }
 }