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

chrome/browser/views/frame/browser_view.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 "base/command_line.h"
 
 #include "chrome/browser/views/frame/browser_view.h"
 
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/app/theme/theme_resources.h"
@@ skipping 105 matching lines @@
 }
 
 BrowserView::~BrowserView() {
   browser_->tabstrip_model()->RemoveObserver(this);
 
   // Stop hung plugin monitoring.
   ticker_.Stop();
   ticker_.UnregisterTickHandler(&hung_window_detector_);
 }
 
+int BrowserView::GetShowState() const {
+  STARTUPINFO si = {0};
+  si.cb = sizeof(si);
+  si.dwFlags = STARTF_USESHOWWINDOW;
+  GetStartupInfo(&si);
+  return si.wShowWindow;
+}
+
 void BrowserView::WindowMoved() {
   // Cancel any tabstrip animations, some of them may be invalidated by the
   // window being repositioned.
   // Comment out for one cycle to see if this fixes dist tests.
   //tabstrip_->DestroyDragController();
 
   status_bubble_->Reposition();
 
   // Close the omnibox popup, if any.
   if (GetLocationBarView())
@@ skipping 177 matching lines @@
   EnablePersonalization(CommandLine().HasSwitch(switches::kEnableP13n));
   if (IsPersonalizationEnabled()) {
     personalization_ = Personalization::CreateFramePersonalization(
         browser_->profile(), this);
   }
 #endif
 
   InitSystemMenu();
 }
 
-void BrowserView::Show(int command, bool adjust_to_fit) {
-  frame_->GetWindow()->Show(command);
+void BrowserView::Show() {
+  // If the window is already visible, just activate it.
+  if (frame_->GetWindow()->IsVisible()) {
+    frame_->GetWindow()->Activate();
+    return;
+  }
+
+  // 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 un-hide 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();
+
+  frame_->GetWindow()->Show();
+  int show_state = frame_->GetWindow()->GetShowState();
+  if (show_state == SW_SHOWNORMAL || show_state == SW_SHOWMAXIMIZED)
+    frame_->GetWindow()->Activate();
 }
 
 void BrowserView::Close() {
   frame_->GetWindow()->Close();
 }
 
 void BrowserView::Activate() {
   frame_->GetWindow()->Activate();
 }
 
@@ skipping 36 matching lines @@
     frame_->GetWindow()->UpdateWindowIcon();
 }
 
 void BrowserView::ValidateThrobber() {
   if (ShouldShowWindowIcon()) {
     TabContents* tab_contents = browser_->GetSelectedTabContents();
     frame_->UpdateThrobber(tab_contents ? tab_contents->is_loading() : false);
   }
 }
 
-gfx::Rect BrowserView::GetNormalBounds() {
+gfx::Rect BrowserView::GetNormalBounds() const {
   WINDOWPLACEMENT wp;
   wp.length = sizeof(wp);
   const bool ret = !!GetWindowPlacement(frame_->GetWindow()->GetHWND(), &wp);
   DCHECK(ret);
   return gfx::Rect(wp.rcNormalPosition);
 }
 
 bool BrowserView::IsMaximized() {
   return frame_->GetWindow()->IsMaximized();
 }
@@ skipping 163 matching lines @@
     command_id = command_id_from_app_command;
 
   if (browser_->SupportsCommand(command_id)) {
     if (browser_->IsCommandEnabled(command_id))
       browser_->ExecuteCommand(command_id);
     return true;
   }
   return false;
 }
 
-void BrowserView::SaveWindowPosition(const CRect& bounds,
-                                     bool maximized,
-                                     bool always_on_top) {
-  browser_->SaveWindowPosition(gfx::Rect(bounds), maximized);
+void BrowserView::SaveWindowPlacement(const gfx::Rect& bounds,
+                                      bool maximized,
+                                      bool always_on_top) {
+  browser_->SaveWindowPlacement(bounds, maximized);
 }
 
-bool BrowserView::RestoreWindowPosition(CRect* bounds,
-                                        bool* maximized,
-                                        bool* always_on_top) {
-  DCHECK(bounds && maximized && always_on_top);
-  *always_on_top = false;
-
+bool BrowserView::GetSavedWindowBounds(gfx::Rect* bounds) const {
   if (browser_->type() == BrowserType::BROWSER) {
     // We are a popup window. The value passed in |bounds| represents two
     // pieces of information:
     // - the position of the window, in screen coordinates (outer position).
     // - the size of the content area (inner size).
     // We need to use these values to determine the appropriate size and
     // position of the resulting window.
     if (SupportsWindowFeature(FEATURE_TOOLBAR) ||
         SupportsWindowFeature(FEATURE_LOCATIONBAR)) {
       // If we're showing the toolbar, we need to adjust |*bounds| to include
       // its desired height, since the toolbar is considered part of the
       // window's client area as far as GetWindowBoundsForClientBounds is
       // concerned...
-      bounds->bottom += toolbar_->GetPreferredSize().height();
+      bounds->set_height(
+          bounds->height() + toolbar_->GetPreferredSize().height());
     }
 
-    gfx::Rect window_rect =
-        frame_->GetWindowBoundsForClientBounds(gfx::Rect(*bounds));
-    window_rect.set_origin(gfx::Point(bounds->left, bounds->top));
+    gfx::Rect window_rect = frame_->GetWindowBoundsForClientBounds(*bounds);
+    window_rect.set_origin(gfx::Point(bounds->x(), bounds->y()));
 
     // When we are given x/y coordinates of 0 on a created popup window,
     // assume none were given by the window.open() command.
     if (window_rect.x() == 0 && window_rect.y() == 0) {
       gfx::Point origin = GetNormalBounds().origin();
       origin.set_x(origin.x() + kWindowTilePixels);
       origin.set_y(origin.y() + kWindowTilePixels);
       window_rect.set_origin(origin);
     }
 
-    *bounds = window_rect.ToRECT();
-    *maximized = false;
+    *bounds = window_rect;
   } else {
-    // TODO(beng): (http://b/1317622) Make these functions take gfx::Rects.
-    gfx::Rect b(*bounds);
-    browser_->RestoreWindowPosition(&b, maximized);
-    *bounds = b.ToRECT();
+    *bounds = browser_->GetSavedWindowBounds();
   }
 
   // We return true because we can _always_ locate reasonable bounds using the
   // WindowSizer, and we don't want to trigger the Window's built-in "size to
   // default" handling because the browser window has no default preferred
   // size.
   return true;
 }
 
+bool BrowserView::GetSavedMaximizedState(bool* maximized) const {
+  *maximized = browser_->GetSavedMaximizedState();
+  return true;
+}
+
 void BrowserView::WindowClosing() {
 }
 
 views::View* BrowserView::GetContentsView() {
   return contents_container_;
 }
 
 views::ClientView* BrowserView::CreateClientView(views::Window* window) {
   set_window(window);
   return this;
@@ skipping 537 matching lines @@
 
 // static
 void BrowserView::InitClass() {
   static bool initialized = false;
   if (!initialized) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_favicon_ = *rb.GetBitmapNamed(IDR_DEFAULT_FAVICON);
     initialized = true;
   }
 }