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

chrome/browser/session_restore.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/session_restore.h"
 
 #include <vector>
 
 #include "base/scoped_ptr.h"
 #include "chrome/browser/browser.h"
@@ skipping 164 matching lines @@
 // SessionRestoreImpl ---------------------------------------------------------
 
 // SessionRestoreImpl is responsible for fetching the set of tabs to create
 // from SessionService. SessionRestoreImpl deletes itself when done.
 
 class SessionRestoreImpl : public NotificationObserver {
  public:
   SessionRestoreImpl(Profile* profile,
                      Browser* browser,
                      bool use_saved_session,
-                     int show_command,
                      bool synchronous,
                      bool clobber_existing_window,
                      bool always_create_tabbed_browser,
                      const std::vector<GURL>& urls_to_open)
       : profile_(profile),
         browser_(browser),
-        show_command_(show_command),
         use_saved_session_(use_saved_session),
         synchronous_(synchronous),
         clobber_existing_window_(clobber_existing_window),
         always_create_tabbed_browser_(always_create_tabbed_browser),
         urls_to_open_(urls_to_open) {
   }
 
   void SessionRestoreImpl::Restore() {
     SessionService* session_service = profile_->GetSessionService();
     DCHECK(session_service);
@@ skipping 30 matching lines @@
  private:
   // Invoked when done with creating all the tabs/browsers.
   //
   // |created_tabbed_browser| indicates whether a tabbed browser was created,
   // or we used an existing tabbed browser.
   //
   // If successful, this begins loading tabs and deletes itself when all tabs
   // have been loaded.
   void FinishedTabCreation(bool succeeded, bool created_tabbed_browser) {
     if (!created_tabbed_browser && always_create_tabbed_browser_) {
-      Browser* browser = new Browser(gfx::Rect(), show_command_, profile_,
-                                     BrowserType::TABBED_BROWSER,
-                                     std::wstring());
+      Browser* browser = Browser::Create(profile_);
       if (urls_to_open_.empty()) {
         // No tab browsers were created and no URLs were supplied on the command
         // line. Add an empty URL, which is treated as opening the users home
         // page.
         urls_to_open_.push_back(GURL());
       }
       AppendURLsToBrowser(browser, urls_to_open_);
-      browser->Show();
+      browser->window()->Show();
     }
 
     if (synchronous_)
       MessageLoop::current()->Quit();
 
     if (succeeded) {
       DCHECK(tab_loader_.get());
       // TabLoader delets itself when done loading.
       tab_loader_.release()->LoadTabs();
     }
@@ skipping 32 matching lines @@
           !clobber_existing_window_) {
         // If there is an open tabbed browser window, use it. Otherwise fall
         // through and create a new one.
         browser = current_browser;
         if (browser && (browser->type() != BrowserType::TABBED_BROWSER ||
                         browser->profile()->IsOffTheRecord())) {
           browser = NULL;
         }
       }
       if (!browser) {
-        const int show_command =
-            (*i)->is_maximized ? SW_SHOWMAXIMIZED : show_command_;
-        browser = new Browser((*i)->bounds, show_command, profile_, (*i)->type,
-                              std::wstring());
+        browser = new Browser((*i)->type, profile_);
+        browser->set_override_bounds((*i)->bounds);
+        browser->set_override_maximized((*i)->is_maximized);
+        browser->CreateBrowserWindow();
       }
       if ((*i)->type == BrowserType::TABBED_BROWSER)
         last_browser = browser;
       const int initial_tab_count = browser->tab_count();
       RestoreTabsToBrowser(*(*i), browser);
       ShowBrowser(browser, initial_tab_count, (*i)->selected_tab_index);
       NotifySessionServiceOfRestoredTabs(browser, initial_tab_count);
     }
 
     // If we're restoring a session as the result of a crash and the session
@@ skipping 36 matching lines @@
     if (browser_ == browser) {
       browser->SelectTabContentsAt(browser->tab_count() - 1, true);
       return;
     }
 
     DCHECK(browser);
     DCHECK(browser->tab_count());
     browser->SelectTabContentsAt(
         std::min(initial_tab_count + std::max(0, selected_session_index),
                  browser->tab_count() - 1), true);
-    browser->Show();
+    browser->window()->Show();
   }
 
   void AppendURLsToBrowser(Browser* browser, const std::vector<GURL>& urls) {
     for (size_t i = 0; i < urls.size(); ++i) {
       browser->AddTabWithURL(urls[i], GURL(), PageTransition::START_PAGE,
                             (i == 0), NULL);
     }
   }
 
   // Invokes TabRestored on the SessionService for all tabs in browser after
   // initial_count.
   void NotifySessionServiceOfRestoredTabs(Browser* browser, int initial_count) {
     SessionService* session_service = profile_->GetSessionService();
     for (int i = initial_count; i < browser->tab_count(); ++i)
       session_service->TabRestored(browser->GetTabContentsAt(i)->controller());
   }
 
   // The profile to create the sessions for.
   Profile* profile_;
 
   // The first browser to restore to, may be null.
   Browser* browser_;
 
-  // Used when creating windows. Passed to the window.
-  const int show_command_;
-
   // Whether we're restoring the saved session (true) or the last session
   // (false).
   const bool use_saved_session_;
 
   // Whether or not restore is synchronous.
   const bool synchronous_;
 
   // See description in RestoreSession (in .h).
   const bool clobber_existing_window_;
 
@@ skipping 17 matching lines @@
 }  // namespace
 
 // SessionRestore -------------------------------------------------------------
 
 // static
 size_t SessionRestore::num_tabs_to_load_ = 0;
 
 static void Restore(Profile* profile,
                     Browser* browser,
                     bool use_saved_session,
-                    int show_command,
                     bool synchronous,
                     bool clobber_existing_window,
                     bool always_create_tabbed_browser,
                     const std::vector<GURL>& urls_to_open) {
   DCHECK(profile);
   if (!profile->GetSessionService())
     return;
   // SessionRestoreImpl takes care of deleting itself when done.
   SessionRestoreImpl* restorer =
-      new SessionRestoreImpl(profile, browser, use_saved_session, show_command,
+      new SessionRestoreImpl(profile, browser, use_saved_session,
                              synchronous, clobber_existing_window,
                              always_create_tabbed_browser,
                              urls_to_open);
   restorer->Restore();
 }
 
 // static
 void SessionRestore::RestoreSession(Profile* profile,
                                     Browser* browser,
                                     bool use_saved_session,
                                     bool clobber_existing_window,
                                     bool always_create_tabbed_browser,
                                     const std::vector<GURL>& urls_to_open) {
-  Restore(profile, browser, use_saved_session, SW_SHOW, false,
-          clobber_existing_window, always_create_tabbed_browser, urls_to_open);
+  Restore(profile, browser, use_saved_session, false, clobber_existing_window,
+          always_create_tabbed_browser, urls_to_open);
 }
 
 // static
 void SessionRestore::RestoreSessionSynchronously(
     Profile* profile,
     bool use_saved_session,
-    int show_command,
     const std::vector<GURL>& urls_to_open) {
-  Restore(profile, NULL, use_saved_session, SW_SHOW, true, false, true,
-          urls_to_open);
+  Restore(profile, NULL, use_saved_session, true, false, true, urls_to_open);
 }