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

chrome/browser/browser.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.h"
-
 #include <windows.h>
 #include <shellapi.h>
 
+#include "chrome/browser/browser.h"
+
 #include "base/command_line.h"
 #include "base/file_version_info.h"
 #include "base/idle_timer.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/app/locales/locale_settings.h"
 #include "chrome/browser/automation/ui_controls.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 125 matching lines @@
   // The source of the update.
   const TabContents* source;
 
   // What changed in the UI.
   unsigned changed_flags;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Constructors, Creation, Showing:
 
-Browser::Browser(const gfx::Rect& initial_bounds,
-                 int show_command,
-                 Profile* profile,
-                 BrowserType::Type type,
-                 const std::wstring& app_name)
-    : profile_(profile),
+Browser::Browser(BrowserType::Type type, Profile* profile)
+    : type_(type),
+      profile_(profile),
       window_(NULL),
-      initial_show_command_(show_command),
+      tabstrip_model_(this, profile),
+      controller_(this),
+      toolbar_model_(this),
+      chrome_updater_factory_(this),
       is_attempting_to_close_browser_(false),
-      controller_(this),
-      chrome_updater_factory_(this),
+      override_maximized_(false),
       method_factory_(this),
-      tabstrip_model_(this, profile),
-      toolbar_model_(this),
-      type_(type),
-      app_name_(app_name),
-      idle_task_(new BrowserIdleTimer()) {
+      idle_task_(new BrowserIdleTimer) {
   tabstrip_model_.AddObserver(this);
 
-  CommandLine parsed_command_line;
-
-  gfx::Rect create_bounds;
-  bool maximized = false;
-  WindowSizer::GetBrowserWindowBounds(app_name_, initial_bounds,
-                                      &create_bounds, &maximized);
-  if (parsed_command_line.HasSwitch(switches::kStartMaximized))
-    maximized = true;
-  if (maximized)
-    initial_show_command_ = SW_SHOWMAXIMIZED;
-  window_ = BrowserWindow::CreateBrowserWindow(this, create_bounds,
-                                               show_command);
-
   NotificationService::current()->AddObserver(
       this, NOTIFY_SSL_STATE_CHANGED, NotificationService::AllSources());
 
   InitCommandState();
   BrowserList::AddBrowser(this);
 
   encoding_auto_detect_.Init(prefs::kWebKitUsesUniversalDetector,
                              profile_->GetPrefs(), NULL);
 
   // Trim browser memory on idle for low & medium memory models.
   if (g_browser_process->memory_model() < BrowserProcess::HIGH_MEMORY_MODEL)
     idle_task_->Start();
-
-  // Show the First Run information bubble if we've been told to.
-  PrefService* local_state = g_browser_process->local_state();
-  if (local_state->IsPrefRegistered(prefs::kShouldShowFirstRunBubble) &&
-      local_state->GetBoolean(prefs::kShouldShowFirstRunBubble)) {
-    // Reset the preference so we don't show the bubble for subsequent windows.
-    local_state->ClearPref(prefs::kShouldShowFirstRunBubble);
-    GetLocationBarView()->ShowFirstRunBubble();
-  }
 }
 
 Browser::~Browser() {
   // The tab strip should be empty at this point.
   DCHECK(tabstrip_model_.empty());
   tabstrip_model_.RemoveObserver(this);
 
   BrowserList::RemoveBrowser(this);
 
   if (!BrowserList::HasBrowserWithProfile(profile_)) {
@@ skipping 23 matching lines @@
     // can just delete all of the cookies in the store.
     profile_->GetRequestContext()->cookie_store()->DeleteAll(false);
   }
 
   // There may be pending file dialogs, we need to tell them that we've gone
   // away so they don't try and call back to us.
   if (select_file_dialog_.get())
     select_file_dialog_->ListenerDestroyed();
 }
 
-void Browser::Show() {
-  // TODO(beng): this entire function should move to BrowserWindow.
+// static
+Browser* Browser::Create(Profile* profile) {
+  Browser* browser = new Browser(BrowserType::TABBED_BROWSER, profile);
+  browser->CreateBrowserWindow();
+  return browser;
+}
 
-  // Only allow one call after the browser is created.
-  if (initial_show_command_ < 0) {
-    // The frame is already visible, we're being invoked again either by the
-    // user clicking a link in another app or from a desktop shortcut.
-    window_->Activate();
-    return;
+// static
+Browser* Browser::CreateForPopup(Profile* profile) {
+  Browser* browser = new Browser(BrowserType::BROWSER, profile);
+  browser->CreateBrowserWindow();
+  return browser;
+}
+
+// static
+Browser* Browser::CreateForApp(const std::wstring& app_name,
+                               Profile* profile) {
+  Browser* browser = new Browser(BrowserType::APPLICATION, profile);
+  browser->app_name_ = app_name;
+  browser->CreateBrowserWindow();
+  return browser;
+}
+
+void Browser::CreateBrowserWindow() {
+  DCHECK(!window_);
+  window_ = BrowserWindow::CreateBrowserWindow(this);
+
+  // Show the First Run information bubble if we've been told to.
+  PrefService* local_state = g_browser_process->local_state();
+  if (local_state->IsPrefRegistered(prefs::kShouldShowFirstRunBubble) &&
+      local_state->GetBoolean(prefs::kShouldShowFirstRunBubble)) {
+    // Reset the preference so we don't show the bubble for subsequent windows.
+    local_state->ClearPref(prefs::kShouldShowFirstRunBubble);
+    GetLocationBarView()->ShowFirstRunBubble();
   }
-  window_->Show(initial_show_command_, false);
-  if ((initial_show_command_ == SW_SHOWNORMAL) ||
-      (initial_show_command_ == SW_SHOWMAXIMIZED))
-    window_->Activate();
-  initial_show_command_ = -1;
-
-  // Setting the focus doesn't work when the window is invisible, so any focus
-  // initialization that happened before this will be lost.
-  //
-  // We really "should" restore the focus whenever the window becomes unhidden,
-  // but I think initializing is the only time where this can happen where there
-  // is some focus change we need to pick up, and this is easier than plumbing
-  // through an unhide message all the way from the frame.
-  //
-  // If we do find there are cases where we need to restore the focus on show,
-  // that should be added and this should be removed.
-  TabContents* selected_tab_contents = GetSelectedTabContents();
-  if (selected_tab_contents)
-    selected_tab_contents->RestoreFocus();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Creation Helpers:
 
 // static
-void Browser::OpenNewBrowserWindow(Profile* profile, int show_command) {
-  Browser* browser = new Browser(gfx::Rect(), show_command, profile,
-    BrowserType::TABBED_BROWSER, L"");
+void Browser::OpenEmptyWindow(Profile* profile) {
+  Browser* browser = Browser::Create(profile);
   browser->AddBlankTab(true);
-  browser->Show();
+  browser->window()->Show();
 }
 
 // static
 void Browser::OpenURLOffTheRecord(Profile* profile, const GURL& url) {
   Profile* off_the_record_profile = profile->GetOffTheRecordProfile();
   Browser* browser = BrowserList::FindBrowserWithType(
-    off_the_record_profile, BrowserType::TABBED_BROWSER);
-  if (browser == NULL) {
-    browser = new Browser(gfx::Rect(), SW_SHOWNORMAL, off_the_record_profile,
-      BrowserType::TABBED_BROWSER, L"");
-  }
+      off_the_record_profile,
+      BrowserType::TABBED_BROWSER);
+  if (!browser)
+    browser = Browser::Create(off_the_record_profile);
   // TODO(eroman): should we have referrer here?
   browser->AddTabWithURL(url, GURL(), PageTransition::LINK, true, NULL);
-  browser->Show();
-  browser->window()->Activate();
+  browser->window()->Show();
 }
 
 // static
-void Browser::OpenWebApplication(Profile* profile,
-                                 WebApp* app,
-                                 int show_command) {
+void Browser::OpenWebApplication(Profile* profile, WebApp* app) {
   const std::wstring& app_name =
       app->name().empty() ? ComputeApplicationNameFromURL(app->url()) :
                             app->name();
+  RegisterAppPrefs(app_name);
 
-  RegisterAppPrefs(app_name);
-  Browser* browser = new Browser(gfx::Rect(), show_command, profile,
-                                 BrowserType::APPLICATION, app_name);
+  Browser* browser = Browser::CreateForApp(app_name, profile);
   browser->AddWebApplicationTab(profile, app, false);
-  browser->Show();
+  browser->window()->Show();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Command API:
 
 bool Browser::SupportsCommand(int id) const {
   return controller_.SupportsCommand(id);
 }
 
 bool Browser::IsCommandEnabled(int id) const {
@@ skipping 18 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, DEPRECATED DEPRECATED DEPRECATED:
 
 HWND Browser::GetTopLevelHWND() const {
   return window_ ? reinterpret_cast<HWND>(window_->GetNativeHandle()) : NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, State Storage and Retrieval for UI:
 
-void Browser::SaveWindowPosition(const gfx::Rect& bounds, bool maximized) {
+void Browser::SaveWindowPlacement(const gfx::Rect& bounds, bool maximized) {
   // We don't save window position for popups.
   if (type() == BrowserType::BROWSER)
     return;
 
   // First save to local state, this is for remembering on subsequent starts.
   PrefService* prefs = g_browser_process->local_state();
   DCHECK(prefs);
   std::wstring name(prefs::kBrowserWindowPlacement);
   if (!app_name_.empty()) {
     name.append(L"_");
@@ skipping 13 matching lines @@
   // initialization of the session service. This function gets called during
   // initial window showing, and we don't want to bring in the session service
   // this early.
   if (profile()->HasSessionService()) {
     SessionService* session_service = profile()->GetSessionService();
     if (session_service)
       session_service->SetWindowBounds(session_id_, bounds, maximized);
   }
 }
 
-void Browser::RestoreWindowPosition(gfx::Rect* bounds, bool* maximized) {
-  DCHECK(bounds && maximized);
-  WindowSizer::GetBrowserWindowBounds(app_name_, *bounds, bounds, maximized);
+gfx::Rect Browser::GetSavedWindowBounds() const {
+  CommandLine parsed_command_line;
+  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.
+    return gfx::Rect(0, 0, 800, 600);
+  }
+
+  gfx::Rect restored_bounds = override_bounds_;
+  bool maximized;
+  WindowSizer::GetBrowserWindowBounds(app_name_, restored_bounds,
+                                      &restored_bounds, &maximized);
+  return restored_bounds;
+}
+
+// TODO(beng): obtain maximized state some other way so we don't need to go
+//             through all this hassle.
+bool Browser::GetSavedMaximizedState() const {
+  if (CommandLine().HasSwitch(switches::kStartMaximized))
+    return true;
+
+  gfx::Rect restored_bounds;
+  bool maximized = override_maximized_;
+  WindowSizer::GetBrowserWindowBounds(app_name_, restored_bounds,
+                                      &restored_bounds, &maximized);
+  return maximized;
 }
 
 SkBitmap Browser::GetCurrentPageIcon() const {
   TabContents* contents = tabstrip_model_.GetSelectedTabContents();
   return contents ? contents->GetFavIcon() : SkBitmap();
 }
 
 std::wstring Browser::GetCurrentPageTitle() const {
   TabContents* contents = tabstrip_model_.GetSelectedTabContents();
   std::wstring title;
@@ skipping 248 matching lines @@
     OpenURL(GURL(), GURL(), CURRENT_TAB, PageTransition::TYPED);
   }
 }
 
 void Browser::NewTab() {
   UserMetrics::RecordAction(L"NewTab", profile_);
   if (type() == BrowserType::TABBED_BROWSER) {
     AddBlankTab(true);
   } else {
     Browser* b = GetOrCreateTabbedBrowser();
-    DCHECK(b);
-    b->Show();
-    b->window()->Activate();
     b->AddBlankTab(true);
+    b->window()->Show();
   }
 }
 
 void Browser::CloseTab() {
   UserMetrics::RecordAction(L"CloseTab_Accelerator", profile_);
   tabstrip_model_.CloseTabContentsAt(tabstrip_model_.selected_index());
 }
 
 void Browser::CloseApp() {
   UserMetrics::RecordAction(L"CloseWebApp", profile_);
   tabstrip_model_.CloseTabContentsAt(tabstrip_model_.selected_index());
 }
 
 void Browser::NewWindow() {
   UserMetrics::RecordAction(L"NewWindow", profile_);
-  Browser::OpenNewBrowserWindow(profile_->GetOriginalProfile(),
-                                SW_SHOWNORMAL);
+  Browser::OpenEmptyWindow(profile_->GetOriginalProfile());
 }
 
 void Browser::NewIncognitoWindow() {
   UserMetrics::RecordAction(L"NewIncognitoWindow", profile_);
-  Browser::OpenNewBrowserWindow(profile_->GetOffTheRecordProfile(),
-                                SW_SHOWNORMAL);
+  Browser::OpenEmptyWindow(profile_->GetOffTheRecordProfile());
 }
 
 void Browser::CloseWindow() {
   UserMetrics::RecordAction(L"CloseWindow", profile_);
   window_->Close();
 }
 
 void Browser::SelectNextTab() {
   UserMetrics::RecordAction(L"SelectNextTab", profile_);
   tabstrip_model_.SelectNextTab();
@@ skipping 40 matching lines @@
 void Browser::ConvertPopupToTabbedBrowser() {
   UserMetrics::RecordAction(L"ShowAsTab", profile_);
 
   if (type() != BrowserType::BROWSER) {
     NOTREACHED();
     return;
   }
 
   int tab_strip_index = tabstrip_model_.selected_index();
   TabContents* contents = tabstrip_model_.DetachTabContentsAt(tab_strip_index);
-  Browser* browser = new Browser(gfx::Rect(), SW_SHOWNORMAL, profile_,
-                                 BrowserType::TABBED_BROWSER, L"");
-  browser->AddNewContents(NULL, contents, NEW_FOREGROUND_TAB, gfx::Rect(),
-                          true);
-  browser->Show();
+  Browser* browser = Browser::Create(profile_);
+  browser->tabstrip_model()->AppendTabContents(contents, true);
+  browser->window()->Show();
 }
 
 void Browser::Exit() {
   UserMetrics::RecordAction(L"Exit", profile_);
   BrowserList::CloseAllBrowsers(true);
 }
 
 // TODO(devint): http://b/issue?id=1117225 Cut, Copy, and Paste are always
 // enabled in the page menu regardless of whether the command will do
 // anything. When someone selects the menu item, we just act as if they hit
@@ skipping 513 matching lines @@
 
     default:
       LOG(WARNING) << "Received Unimplemented Command: " << id;
       break;
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabStripModelDelegate implementation:
 
+GURL Browser::GetBlankTabURL() const {
+  return NewTabUIURL();
+}
+
 void Browser::CreateNewStripWithContents(TabContents* detached_contents,
                                          const gfx::Point& drop_point) {
   DCHECK(type_ == BrowserType::TABBED_BROWSER);
 
   // Create an empty new browser window the same size as the old one.
   // TODO(beng): move elsewhere
   CRect browser_rect;
   GetWindowRect(reinterpret_cast<HWND>(window_->GetNativeHandle()),
                 &browser_rect);
   gfx::Rect rect(0, 0);
   if (drop_point.x() != 0 || drop_point.y() != 0) {
     rect.SetRect(drop_point.x(), drop_point.y(), browser_rect.Width(),
                  browser_rect.Height());
   }
-  Browser* new_window =
-      new Browser(rect, SW_SHOWNORMAL, profile_, BrowserType::TABBED_BROWSER,
-                  std::wstring());
-  // Append the TabContents before showing it so the window doesn't flash
-  // black.
-  new_window->tabstrip_model()->AppendTabContents(detached_contents, true);
-  new_window->Show();
+  Browser* browser = new Browser(BrowserType::TABBED_BROWSER, profile_);
+  browser->set_override_bounds(rect);
+  browser->CreateBrowserWindow();
+  browser->tabstrip_model()->AppendTabContents(detached_contents, true);
+  browser->window()->Show();
 
   // When we detach a tab we need to make sure any associated Find window moves
   // along with it to its new home (basically we just make new_window the parent
   // of the Find window).
   // TODO(brettw) this could probably be improved, see
   // WebContentsView::ReparentFindWindow for more.
   if (detached_contents->AsWebContents())
-    detached_contents->AsWebContents()->view()->ReparentFindWindow(new_window);
+    detached_contents->AsWebContents()->view()->ReparentFindWindow(browser);
 }
 
 int Browser::GetDragActions() const {
   int result = 0;
   if (BrowserList::GetBrowserCountForType(profile_,
                                           BrowserType::TABBED_BROWSER) > 1 ||
       tab_count() > 1)
     result |= TAB_TEAROFF_ACTION;
   if (tab_count() > 1)
     result |= TAB_MOVE_ACTION;
@@ skipping 42 matching lines @@
         GetTopLevelHWND())->active_contents();
     // If you duplicate a tab that is not selected, we need to make sure to
     // select the tab being duplicated so that DetermineInsertionIndex returns
     // the right index (if tab 5 is selected and we right-click tab 1 we want
     // the new tab to appear in index position 2, not 6).
     if (tabstrip_model_.selected_index() != index)
       tabstrip_model_.SelectTabContentsAt(index, true);
     tabstrip_model_.AddTabContents(new_contents, index + 1,
                                    PageTransition::LINK, true);
   } else {
-    Browser* new_browser = new Browser(gfx::Rect(), SW_SHOWNORMAL, profile(),
-                                       BrowserType::APPLICATION, app_name_);
+    Browser* browser = NULL;
+    if (type_ == BrowserType::APPLICATION) {
+      browser = Browser::CreateForApp(app_name_, profile_);
+    } else if (type_ == BrowserType::BROWSER) {
+      browser = Browser::CreateForPopup(profile_);
+    }
 
     // We need to show the browser now. Otherwise ContainerWin assumes the
     // TabContents is invisible and won't size it.
-    new_browser->Show();
+    browser->window()->Show();
 
     // The page transition below is only for the purpose of inserting the tab.
-    new_contents = new_browser->AddTabWithNavigationController(
-        contents->controller()->Clone(new_browser->GetTopLevelHWND()),
+    new_contents = browser->AddTabWithNavigationController(
+        contents->controller()->Clone(browser->GetTopLevelHWND()),
         PageTransition::LINK);
-
-    new_browser->window()->Activate();
   }
 
   if (profile_->HasSessionService()) {
     SessionService* session_service = profile_->GetSessionService();
     if (session_service)
       session_service->TabRestored(new_contents->controller());
   }
 }
 
 void Browser::ValidateLoadingAnimations() {
@@ skipping 178 matching lines @@
 
     Browser* b = GetOrCreateTabbedBrowser();
     DCHECK(b);
 
     // If we have just created a new browser window, make sure we select the
     // tab.
     if (b->tab_count() == 0 && disposition == NEW_BACKGROUND_TAB)
       disposition = NEW_FOREGROUND_TAB;
 
     b->OpenURL(url, referrer, disposition, transition);
-    b->Show();
-    b->window()->Activate();
+    b->window()->Show();
     return;
   }
 
   if (profile_->IsOffTheRecord() && disposition == OFF_THE_RECORD)
     disposition = NEW_FOREGROUND_TAB;
 
   if (disposition == NEW_WINDOW) {
-    Browser* new_browser = new Browser(gfx::Rect(), SW_SHOWNORMAL, profile_,
-                                       BrowserType::TABBED_BROWSER, L"");
-    new_contents = new_browser->AddTabWithURL(url, referrer, transition, true,
-                                              instance);
-    new_browser->Show();
+    Browser* browser = Browser::Create(profile_);
+    new_contents = browser->AddTabWithURL(url, referrer, transition, true,
+                                          instance);
+    browser->window()->Show();
   } else if ((disposition == CURRENT_TAB) && current_tab) {
     if (transition == PageTransition::TYPED ||
         transition == PageTransition::AUTO_BOOKMARK ||
         transition == PageTransition::GENERATED ||
         transition == PageTransition::START_PAGE) {
       // Don't forget the openers if this tab is a New Tab page opened at the
       // end of the TabStrip (e.g. by pressing Ctrl+T). Give the user one
       // navigation of one of these transition types before resetting the
       // opener relationships (this allows for the use case of opening a new
       // tab to do a quick look-up of something while viewing a tab earlier in
@@ skipping 24 matching lines @@
     GetStatusBubble()->Hide();
 
     // Synchronously update the location bar. This allows us to immediately
     // have the URL bar update when the user types something, rather than
     // going through the normal system of ScheduleUIUpdate which has a delay.
     UpdateToolbar(false);
   } else if (disposition == OFF_THE_RECORD) {
     OpenURLOffTheRecord(profile_, url);
     return;
   } else if (disposition != SUPPRESS_OPEN) {
-    new_contents =
-        AddTabWithURL(url, referrer, transition,
-                      disposition != NEW_BACKGROUND_TAB, instance);
+    new_contents = AddTabWithURL(url, referrer, transition,
+                                 disposition != NEW_BACKGROUND_TAB, instance);
   }
 
   if (disposition != NEW_BACKGROUND_TAB && source_tab_was_frontmost) {
     // Give the focus to the newly navigated tab, if the source tab was
     // front-most.
     new_contents->Focus();
   }
 }
 
 void Browser::NavigationStateChanged(const TabContents* source,
@@ skipping 58 matching lines @@
     DCHECK(b);
     PageTransition::Type transition = PageTransition::LINK;
     // If we were called from an "installed webapp" we want to emulate the code
     // that is run from browser_init.cc for links from external applications.
     // This means we need to open the tab with the START PAGE transition.
     // AddNewContents doesn't support this but the TabStripModel's
     // AddTabContents method does.
     if (type_ == BrowserType::APPLICATION)
       transition = PageTransition::START_PAGE;
     b->tabstrip_model()->AddTabContents(new_contents, -1, transition, true);
-    b->Show();
-    b->window()->Activate();
+    b->window()->Show();
     return;
   }
 
   if (disposition == NEW_POPUP) {
     BuildPopupWindow(source, new_contents, initial_pos);
   } else if (disposition == NEW_WINDOW) {
-    Browser* new_browser = new Browser(gfx::Rect(), SW_SHOWNORMAL, profile_,
-                                       BrowserType::TABBED_BROWSER, L"");
-    new_browser->AddNewContents(source, new_contents, NEW_FOREGROUND_TAB,
-                                initial_pos, user_gesture);
-    new_browser->Show();
+    Browser* browser = Browser::Create(profile_);
+    browser->AddNewContents(source, new_contents, NEW_FOREGROUND_TAB,
+                            initial_pos, user_gesture);
+    browser->window()->Show();
   } else if (disposition == CURRENT_TAB) {
     ReplaceContents(source, new_contents);
   } else if (disposition != SUPPRESS_OPEN) {
     tabstrip_model_.AddTabContents(new_contents, -1, PageTransition::LINK,
                                    disposition == NEW_FOREGROUND_TAB);
   }
 }
 
 void Browser::ActivateContents(TabContents* contents) {
   tabstrip_model_.SelectTabContentsAt(
@@ skipping 96 matching lines @@
   if (index < 0)
     return;
 
   WebApp* app = contents->AsWebContents()->web_app();
   const std::wstring& app_name =
       app->name().empty() ? ComputeApplicationNameFromURL(app->url()) :
                             app->name();
   RegisterAppPrefs(app_name);
 
   tabstrip_model_.DetachTabContentsAt(index);
-  Browser* browser = new Browser(gfx::Rect(), SW_SHOWNORMAL, profile_,
-                                 BrowserType::APPLICATION, app_name);
-  browser->AddNewContents(
-    NULL, contents, NEW_FOREGROUND_TAB, gfx::Rect(), true);
-  browser->Show();
+  Browser* browser = Browser::CreateForApp(app_name, profile_);
+  browser->tabstrip_model()->AppendTabContents(contents, true);
+  browser->window()->Show();
 }
 
 void Browser::ContentsStateChanged(TabContents* source) {
   int index = tabstrip_model_.GetIndexOfTabContents(source);
   if (index != TabStripModel::kNoTab)
     tabstrip_model_.UpdateTabContentsStateAt(index);
 }
 
 bool Browser::ShouldDisplayURLField() {
   return !IsApplication();
@@ skipping 525 matching lines @@
   RemoveFromVector(&tabs_needing_unload_fired_, tab);
   ProcessPendingTabs();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, Assorted utility functions (private):
 
 Browser* Browser::GetOrCreateTabbedBrowser() {
   Browser* browser = BrowserList::FindBrowserWithType(
       profile_, BrowserType::TABBED_BROWSER);
-  if (!browser) {
-    browser = new Browser(gfx::Rect(), SW_SHOWNORMAL, profile_,
-                          BrowserType::TABBED_BROWSER, std::wstring());
-  }
+  if (!browser)
+    browser = Browser::Create(profile_);
   return browser;
 }
 
 void Browser::BuildPopupWindow(TabContents* source,
                                TabContents* new_contents,
                                const gfx::Rect& initial_pos) {
   BrowserType::Type type =
       type_ == BrowserType::APPLICATION ? type_ : BrowserType::BROWSER;
-  Browser* browser = new Browser(initial_pos, SW_SHOWNORMAL, profile_, type,
-                                 std::wstring());
-  browser->AddNewContents(source, new_contents,
-                          NEW_FOREGROUND_TAB, gfx::Rect(), true);
-  browser->Show();
+  Browser* browser = new Browser(type, profile_);
+  browser->set_override_bounds(initial_pos);
+  browser->CreateBrowserWindow();
+  // TODO(beng): See if this can be made to use
+  //             TabStripModel::AppendTabContents.
+  browser->AddNewContents(source, new_contents, NEW_FOREGROUND_TAB,
+                          gfx::Rect(), true);
+  browser->window()->Show();
 }
 
 GURL Browser::GetHomePage() {
-  if (profile_->GetPrefs()->GetBoolean(prefs::kHomePageIsNewTabPage)) {
+  if (profile_->GetPrefs()->GetBoolean(prefs::kHomePageIsNewTabPage))
     return NewTabUIURL();
-  } else {
-    GURL home_page = GURL(URLFixerUpper::FixupURL(
-        profile_->GetPrefs()->GetString(prefs::kHomePage),
-        std::wstring()));
-    if (!home_page.is_valid())
-      return NewTabUIURL();
-
-    return home_page;
-  }
+  GURL home_page = GURL(URLFixerUpper::FixupURL(
+      profile_->GetPrefs()->GetString(prefs::kHomePage),
+      std::wstring()));
+  if (!home_page.is_valid())
+    return NewTabUIURL();
+  return home_page;
 }
 
 void Browser::AdvanceFindSelection(bool forward_direction) {
   GetSelectedTabContents()->AsWebContents()->view()->FindInPage(
       *this, true, forward_direction);
 }
 
 void Browser::CloseFrame() {
   window_->Close();
 }
@@ skipping 22 matching lines @@
 
   // We need to register the window position pref.
   std::wstring window_pref(prefs::kBrowserWindowPlacement);
   window_pref.append(L"_");
   window_pref.append(app_name);
   PrefService* prefs = g_browser_process->local_state();
   DCHECK(prefs);
 
   prefs->RegisterDictionaryPref(window_pref.c_str());
 }