Re-do the way browser windows are shown:...

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 <shellapi.h>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 86 matching lines @@
                                 NULL,
                                 chrome::kMessageWindowClass,
                                 user_data_dir.c_str());
 }
 
 BrowserInit::MessageWindow::~MessageWindow() {
   if (window_)
     DestroyWindow(window_);
 }
 
-bool BrowserInit::MessageWindow::NotifyOtherProcess(int show_cmd) {
+bool BrowserInit::MessageWindow::NotifyOtherProcess() {
   if (!remote_window_)
     return false;
 
   // Found another window, send our command line to it
-  // format is "START\0<<<current directory>>>\0<<<commandline>>>\0show_cmd".
+  // format is "START\0<<<current directory>>>\0<<<commandline>>>".
   std::wstring to_send(L"START\0", 6);  // want the NULL in the string.
   std::wstring cur_dir;
   if (!PathService::Get(base::DIR_CURRENT, &cur_dir))
     return false;
   to_send.append(cur_dir);
   to_send.append(L"\0", 1);  // Null separator.
   to_send.append(GetCommandLineW());
   to_send.append(L"\0", 1);  // Null separator.
 
-  // Append the windows show_command flags.
-  if (show_cmd == SW_SHOWDEFAULT) {
-    // SW_SHOWDEFAULT makes no sense to the other process. We need to
-    // use the SW_ flag from OUR STARTUPUNFO;
-    STARTUPINFO startup_info = {0};
-    startup_info.cb = sizeof(startup_info);
-    GetStartupInfo(&startup_info);
-    show_cmd = startup_info.wShowWindow;
-    // In certain situations the window status above is returned as SW_HIDE.
-    // In such cases we need to fall back to a default case of SW_SHOWNORMAL
-    // so that user actually get to see the window.
-    if (show_cmd != SW_SHOWNORMAL && show_cmd != SW_SHOWMAXIMIZED)
-      show_cmd = SW_SHOWNORMAL;
-  }
-  StringAppendF(&to_send, L"%d", static_cast<uint8>(show_cmd));
-
   // Allow the current running browser window making itself the foreground
   // window (otherwise it will just flash in the taskbar).
   DWORD process_id = 0;
   DWORD thread_id = GetWindowThreadProcessId(remote_window_, &process_id);
   DCHECK(process_id);
   AllowSetForegroundWindow(process_id);
 
   // Gives 20 seconds timeout for the current browser process to respond.
   const int kTimeout = 20000;
   COPYDATASTRUCT cds;
@@ skipping 111 matching lines @@
     if (third_null == std::wstring::npos ||
         third_null == msg.length()) {
       LOG(WARNING) << "Invalid format for start command, we need a string in 4 "
         "parts separated by NULLs";
     }
 
     // Get command line.
     const std::wstring cmd_line =
       msg.substr(second_null + 1, third_null - second_null);
 
-    // The last component is probably null terminated but we don't require it
-    // because everything here is based on counts.
-    std::wstring show_cmd_str = msg.substr(third_null + 1);
-    if (!show_cmd_str.empty() &&
-        show_cmd_str[show_cmd_str.length() - 1] == L'\0')
-      show_cmd_str.resize(cmd_line.length() - 1);
-
-    int show_cmd = _wtoi(show_cmd_str.c_str());
-
     CommandLine parsed_command_line(cmd_line);
     PrefService* prefs = g_browser_process->local_state();
     DCHECK(prefs);
 
     std::wstring user_data_dir;
     PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
     ProfileManager* profile_manager = g_browser_process->profile_manager();
     Profile* profile = profile_manager->GetDefaultProfile(user_data_dir);
     if (!profile) {
       // We should only be able to get here if the profile already exists and
       // has been created.
       NOTREACHED();
       return TRUE;
     }
-    ProcessCommandLine(parsed_command_line, cur_dir, prefs, show_cmd, false,
-                       profile, NULL);
+    ProcessCommandLine(parsed_command_line, cur_dir, prefs, false, profile,
+                       NULL);
     return TRUE;
   }
   return TRUE;
 }
 
 LRESULT CALLBACK BrowserInit::MessageWindow::WndProc(HWND hwnd,
                                                      UINT message,
                                                      WPARAM wparam,
                                                      LPARAM lparam) {
   switch (message) {
@@ skipping 60 matching lines @@
   ZombieDetector zombie_detector;
   process_util::KillProcesses(L"chrome.exe",
                               ResultCodes::HUNG,
                               &zombie_detector);
 }
 
 
 // LaunchWithProfile ----------------------------------------------------------
 
 BrowserInit::LaunchWithProfile::LaunchWithProfile(const std::wstring& cur_dir,
-                                                  const std::wstring& cmd_line,
-                                                  int show_command)
+                                                  const std::wstring& cmd_line)
     : command_line_(cmd_line),
-      show_command_(show_command),
       cur_dir_(cur_dir) {
 }
 
 bool BrowserInit::LaunchWithProfile::Launch(Profile* profile,
                                             bool process_startup) {
   DCHECK(profile);
   profile_ = profile;
 
   CommandLine parsed_command_line(command_line_);
-  gfx::Rect start_position;
-
-  bool record_mode = parsed_command_line.HasSwitch(switches::kRecordMode);
-  bool playback_mode = parsed_command_line.HasSwitch(switches::kPlaybackMode);
-  if (record_mode || playback_mode) {
-    // In playback/record mode we always fix the size of the browser and
-    // move it to (0,0).  The reason for this is two reasons:  First we want
-    // resize/moves in the playback to still work, and Second we want
-    // playbacks to work (as much as possible) on machines w/ different
-    // screen sizes.
-    start_position_.set_height(800);
-    start_position_.set_width(600);
-    start_position_.set_x(0);
-    start_position_.set_y(0);
-  }
-
   if (parsed_command_line.HasSwitch(switches::kDnsLogDetails))
     chrome_browser_net::EnableDnsDetailedLog(true);
   if (parsed_command_line.HasSwitch(switches::kDnsPrefetchDisable))
     chrome_browser_net::EnableDnsPrefetch(false);
 
   if (parsed_command_line.HasSwitch(switches::kDumpHistogramsOnExit)) {
     StatisticsRecorder::set_dump_on_exit(true);
   }
 
   if (parsed_command_line.HasSwitch(switches::kRemoteShellPort)) {
@@ skipping 55 matching lines @@
 
   // It is possible to end here with a NULL 'browser'. For example if the user
   // has tweaked the startup session restore preferences.
 
   if (browser) {
     // If we're recording or playing back, startup the EventRecorder now
     // unless otherwise specified.
     if (!parsed_command_line.HasSwitch(switches::kNoEvents)) {
       std::wstring script_path;
       PathService::Get(chrome::FILE_RECORDED_SCRIPT, &script_path);
+
+      bool record_mode = parsed_command_line.HasSwitch(switches::kRecordMode);
+      bool playback_mode =
+          parsed_command_line.HasSwitch(switches::kPlaybackMode);
+
       if (record_mode && chrome::kRecordModeEnabled)
         base::EventRecorder::current()->StartRecording(script_path);
       if (playback_mode)
         base::EventRecorder::current()->StartPlayback(script_path);
     }
   }
   return true;
 }
 
-Browser* BrowserInit::LaunchWithProfile::CreateTabbedBrowser() {
-  return new Browser(start_position_, show_command_, profile_,
-                     BrowserType::TABBED_BROWSER, std::wstring());
-}
-
 bool BrowserInit::LaunchWithProfile::OpenStartupURLs(
     bool is_process_startup,
     const CommandLine& command_line,
     const std::vector<GURL>& urls_to_open) {
   SessionStartupPref pref = GetSessionStartupPref(profile_, command_line);
   switch (pref.type) {
     case SessionStartupPref::LAST:
       if (!is_process_startup)
         return false;
 
       if (!profile_->DidLastSessionExitCleanly() &&
           !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.
         return false;
       }
-      SessionRestore::RestoreSessionSynchronously(
-          profile_, false, show_command_, urls_to_open);
+      SessionRestore::RestoreSessionSynchronously(profile_, false,  
+                                                  urls_to_open);
       return true;
 
     case SessionStartupPref::URLS:
       // When the user launches the app only open the default set of URLs if
       // we aren't going to open any URLs on the command line.
       if (urls_to_open.empty()) {
         if (pref.urls.empty())
           return false;  // No URLs to open.
         OpenURLsInBrowser(NULL, is_process_startup, pref.urls);
         return true;
       }
       return false;
 
     default:
       return false;
   }
 }
 
 Browser* BrowserInit::LaunchWithProfile::OpenURLsInBrowser(
     Browser* browser,
     bool process_startup,
     const std::vector<GURL>& urls) {
   DCHECK(!urls.empty());
   if (!browser || browser->type() != BrowserType::TABBED_BROWSER)
-    browser = CreateTabbedBrowser();
+    browser = Browser::Create(profile_);
 
   for (size_t i = 0; i < urls.size(); ++i) {
     TabContents* tab = browser->AddTabWithURL(
         urls[i], GURL(), PageTransition::START_PAGE, (i == 0), NULL);
     if (i == 0 && process_startup)
       AddCrashedInfoBarIfNecessary(tab);
   }
-  browser->Show();
+  browser->window()->Show();
   return browser;
 }
 
 void BrowserInit::LaunchWithProfile::AddCrashedInfoBarIfNecessary(
     TabContents* tab) {
   WebContents* web_contents = tab->AsWebContents();
   if (!profile_->DidLastSessionExitCleanly() && web_contents) {
     // The last session didn't exit cleanly. Show an infobar to the user
     // so that they can restore if they want.
     // TODO(brettw) this should be done more cleanly, by adding a message to
@@ skipping 30 matching lines @@
       } else {
         // This will create a file URL or a regular URL.
         urls.push_back(GURL(URLFixerUpper::FixupRelativeFile(cur_dir_, value)));
       }
     }
   }
   return urls;
 }
 
 bool BrowserInit::ProcessCommandLine(const CommandLine& parsed_command_line,
-    const std::wstring& cur_dir, PrefService* prefs, int show_command,
-    bool process_startup, Profile* profile, int* return_code) {
+    const std::wstring& cur_dir, PrefService* prefs, bool process_startup,
+    Profile* profile, int* return_code) {
   DCHECK(profile);
   if (process_startup) {
     const std::wstring popup_count_string =
         parsed_command_line.GetSwitchValue(switches::kOmniBoxPopupCount);
     if (!popup_count_string.empty()) {
       const int popup_count = std::max(0, _wtoi(popup_count_string.c_str()));
       AutocompleteResult::set_max_matches(popup_count);
       AutocompleteProvider::set_max_matches(popup_count / 2);
     }
 
@@ skipping 41 matching lines @@
                  0);
     if (expected_tabs == 0) {
       silent_launch = true;
     }
     CreateAutomationProvider<AutomationProvider>(automation_channel_id,
                                                  profile, expected_tabs);
   }
   // If we don't want to launch a new browser window or tab (in the case
   // of an automation request), we are done here.
   if (!silent_launch) {
-    return LaunchBrowser(parsed_command_line, profile, show_command, cur_dir,
+    return LaunchBrowser(parsed_command_line, profile, cur_dir,
                          process_startup, return_code);
   }
   return true;
 }
 
 bool BrowserInit::LaunchBrowser(const CommandLine& parsed_command_line,
-                                Profile* profile,
-                                int show_command, const std::wstring& cur_dir,
+                                Profile* profile, const std::wstring& cur_dir,
                                 bool process_startup, int* return_code) {
   in_startup = process_startup;
-  bool result = LaunchBrowserImpl(parsed_command_line, profile, show_command,
-                                  cur_dir, process_startup, return_code);
+  bool result = LaunchBrowserImpl(parsed_command_line, profile, cur_dir,
+                                  process_startup, return_code);
   in_startup = false;
   return result;
 }
 
 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);
   list->AddProvider(automation);
 }
 
 bool BrowserInit::LaunchBrowserImpl(const CommandLine& parsed_command_line,
                                     Profile* profile,
-                                    int show_command,
                                     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 (parsed_command_line.HasSwitch(switches::kIncognito))
     profile = profile->GetOffTheRecordProfile();
 
   // Are we starting an application?
   std::wstring app_url = parsed_command_line.GetSwitchValue(switches::kApp);
   if (!app_url.empty()) {
     GURL url(app_url);
     // If the application is started for a mailto:url, this machine has some
     // old configuration that we should ignore. This hack saves us from some
     // infinite loops where we keep forwarding mailto: to the system, resulting
     // in the system asking us to open the mailto app.
     if (url.SchemeIs("mailto"))
       url = GURL("about:blank");
 
-    WebAppLauncher::Launch(profile, url, show_command);
+    WebAppLauncher::Launch(profile, url);
     return true;
   }
 
-  LaunchWithProfile lwp(cur_dir, parsed_command_line.command_line_string(),
-                        show_command);
+  LaunchWithProfile lwp(cur_dir, parsed_command_line.command_line_string());
   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;
 }