Fix: New window appears to the left/up if the taskbar is on left/top....

chrome/browser/window_sizer.cc

 // Copyright (c) 2009 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/window_sizer.h"
 
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_window.h"
@@ skipping 133 matching lines @@
       }
     }
   }
 }
 
 bool WindowSizer::GetLastWindowBounds(gfx::Rect* bounds) const {
   DCHECK(bounds);
   if (!state_provider_ || !state_provider_->GetLastActiveWindowState(bounds))
     return false;
   gfx::Rect last_window_bounds = *bounds;
+  bounds->Offset(monitor_info_provider_->GetBoundsOffsetMatching(*bounds));

[Peter Kasting, 2009/06/19 06:21:14]

So wait a minute.  I'm thinking about these more and they feel weird.

Why are we offsetting by the (work area - monitor rect) difference anyway?  Are
the previous bounds we retrieve offset opposite to this and we have to correct
for it?  I assume so... but then the values you get in your unittests kinda
scare me since we go from e.g. (10, 10) to (127, 10).  The only way this can be
right is if the first coordinate is relative to the work area and the second
relative to the screen.  Is that the case?

   bounds->Offset(kWindowTilePixels, kWindowTilePixels);
   AdjustBoundsToBeVisibleOnMonitorContaining(last_window_bounds, bounds);
   return true;
 }
 
 bool WindowSizer::GetSavedWindowBounds(gfx::Rect* bounds,
                                        bool* maximized) const {
   DCHECK(bounds && maximized);
   if (!state_provider_ ||
       !state_provider_->GetPersistentState(bounds, maximized))
     return false;
-  const gfx::Point& taskbar_offset =
-      monitor_info_provider_->GetBoundsOffsetMatching(*bounds);
-  bounds->Offset(taskbar_offset.x(), taskbar_offset.y());
+  bounds->Offset(monitor_info_provider_->GetBoundsOffsetMatching(*bounds));
   AdjustBoundsToBeVisibleOnMonitorContaining(*bounds, bounds);
   return true;
 }
 
 void WindowSizer::GetDefaultWindowBounds(gfx::Rect* default_bounds) const {
   DCHECK(default_bounds);
   DCHECK(monitor_info_provider_);
 
   gfx::Rect work_area = monitor_info_provider_->GetPrimaryMonitorWorkArea();
 
@@ skipping 80 matching lines @@
   bounds->set_width(std::max(kMinVisibleWidth, bounds->width()));
 
   // Ensure at least kMinVisibleWidth * kMinVisibleHeight is visible.
   const int min_y = work_area.y() + kMinVisibleHeight - bounds->height();
   const int min_x = work_area.x() + kMinVisibleWidth - bounds->width();
   const int max_y = work_area.bottom() - kMinVisibleHeight;
   const int max_x = work_area.right() - kMinVisibleWidth;
   bounds->set_y(std::max(min_y, std::min(max_y, bounds->y())));
   bounds->set_x(std::max(min_x, std::min(max_x, bounds->x())));
 }