Make startup_tests build and run on Linux (except reference tests).

chrome/browser/browser_init.cc

 // Copyright (c) 2006-2008 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/browser_init.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/event_recorder.h"
 #include "base/histogram.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
+#include "chrome/browser/automation/automation_provider.h"
+#include "chrome/browser/automation/automation_provider_list.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/net/dns_global.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/session_startup_pref.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/tab_contents/infobar_delegate.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/result_codes.h"
 #include "net/base/cookie_monster.h"
 #include "webkit/glue/webkit_glue.h"
 
 #if defined(OS_WIN)
 
 #include "base/win_util.h"
-#include "chrome/browser/automation/automation_provider.h"
-#include "chrome/browser/automation/automation_provider_list.h"
 #include "chrome/common/resource_bundle.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 
 #endif
 
 namespace {
 
@@ skipping 386 matching lines @@
     const std::wstring tab_count_string =
         command_line.GetSwitchValue(switches::kTabCountToLoadOnSessionRestore);
     if (!tab_count_string.empty()) {
       int count = 0;
       if (StringToInt(WideToUTF16Hack(tab_count_string), &count)) {
         const int tab_count = std::max(0, count);
         SessionRestore::num_tabs_to_load_ = static_cast<size_t>(tab_count);
       }
     }
 
-#if defined(OS_WIN)
     // Look for the testing channel ID ONLY during process startup
     if (command_line.HasSwitch(switches::kTestingChannelID)) {
       std::wstring testing_channel_id =
           command_line.GetSwitchValue(switches::kTestingChannelID);
       // TODO(sanjeevr) Check if we need to make this a singleton for
       // compatibility with the old testing code
       // If there are any loose 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::kRestoreLastSession)) {
-        StringToInt(command_line.GetSwitchValue(switches::kRestoreLastSession),
+        std::wstring restore_session_value(
+            command_line.GetSwitchValue(switches::kRestoreLastSession));
+        StringToInt(WideToUTF16Hack(restore_session_value),
                     &expected_tab_count);
       } else {
         expected_tab_count =
             std::max(1, static_cast<int>(command_line.GetLooseValues().size()));
       }
       CreateAutomationProvider<TestingAutomationProvider>(
           testing_channel_id,
           profile,
           static_cast<size_t>(expected_tab_count));
     }
-#endif
   }
 
   // Allow the command line to override the persisted setting of home page.
   SetOverrideHomePage(command_line, profile->GetPrefs());
 
   if (command_line.HasSwitch(switches::kBrowserStartRenderersManually))
     prefs->transient()->SetBoolean(prefs::kStartRenderersManually, true);
 
   bool silent_launch = false;
-#if defined(OS_WIN)
   if (command_line.HasSwitch(switches::kAutomationClientChannelID)) {
     std::wstring automation_channel_id =
         command_line.GetSwitchValue(switches::kAutomationClientChannelID);
     // If there are any loose parameters, we expect each one to generate a
     // new tab; if there are none then we have no tabs
     size_t expected_tabs =
         std::max(static_cast<int>(command_line.GetLooseValues().size()),
                  0);
     if (expected_tabs == 0)
       silent_launch = true;
     CreateAutomationProvider<AutomationProvider>(automation_channel_id,
                                                  profile, expected_tabs);
   }
-#endif
 
   if (command_line.HasSwitch(switches::kLoadExtension)) {
     std::wstring path_string =
         command_line.GetSwitchValue(switches::kLoadExtension);
     FilePath path = FilePath::FromWStringHack(path_string);
     profile->GetExtensionsService()->LoadExtension(path);
     profile->GetUserScriptMaster()->AddWatchedPath(path);
   }
 
   if (command_line.HasSwitch(switches::kInstallExtension)) {
@@ skipping 19 matching lines @@
 bool BrowserInit::LaunchBrowser(const CommandLine& command_line,
                                 Profile* profile, const std::wstring& cur_dir,
                                 bool process_startup, int* return_code) {
   in_startup = process_startup;
   bool result = LaunchBrowserImpl(command_line, profile, cur_dir,
                                   process_startup, return_code);
   in_startup = false;
   return result;
 }
 
-#if defined(OS_WIN)
 template <class AutomationProviderClass>
 void BrowserInit::CreateAutomationProvider(const std::wstring& channel_id,
                                            Profile* profile,
                                            size_t expected_tabs) {
   scoped_refptr<AutomationProviderClass> automation =
       new AutomationProviderClass(profile);
   automation->ConnectToChannel(channel_id);
   automation->SetExpectedTabCount(expected_tabs);
 
   AutomationProviderList* list =
-      g_browser_process->InitAutomationProviderList();  DCHECK(list);
+      g_browser_process->InitAutomationProviderList();
+  DCHECK(list);
   list->AddProvider(automation);
 }
-#endif
 
 bool BrowserInit::LaunchBrowserImpl(const CommandLine& command_line,
                                     Profile* profile,
                                     const std::wstring& cur_dir,
                                     bool process_startup,
                                     int* return_code) {
   DCHECK(profile);
 
   // Continue with the off-the-record profile from here on if --incognito
   if (command_line.HasSwitch(switches::kIncognito))
     profile = profile->GetOffTheRecordProfile();
 
   LaunchWithProfile lwp(cur_dir, command_line);
   bool launched = lwp.Launch(profile, process_startup);
   if (!launched) {
     LOG(ERROR) << "launch error";
     if (return_code != NULL)
       *return_code = ResultCodes::INVALID_CMDLINE_URL;
     return false;
   }
 
   return true;
 }