Reposition and/or resize window if it becomes off-screen....

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"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 // An implementation of WindowSizer::StateProvider that gets the last active
 // and persistent state from the browser window and the user's profile.
 class DefaultStateProvider : public WindowSizer::StateProvider {
  public:
   explicit DefaultStateProvider(const std::wstring& app_name, Browser* browser)
       : app_name_(app_name),
         browser_(browser) {
   }
 
   // Overridden from WindowSizer::StateProvider:
-  virtual bool GetPersistentState(gfx::Rect* bounds, bool* maximized) const {
+  virtual bool GetPersistentState(gfx::Rect* bounds,
+                                  bool* maximized,
+                                  gfx::Rect* work_area) const {
     DCHECK(bounds && maximized);
 
     std::wstring key(prefs::kBrowserWindowPlacement);
     if (!app_name_.empty()) {
       key.append(L"_");
       key.append(app_name_);
     }
 
     if (!g_browser_process->local_state())
       return false;
 
     const DictionaryValue* wp_pref =
         g_browser_process->local_state()->GetDictionary(key.c_str());
     int top = 0, left = 0, bottom = 0, right = 0;
     bool has_prefs =
         wp_pref &&
         wp_pref->GetInteger(L"top", &top) &&
         wp_pref->GetInteger(L"left", &left) &&
         wp_pref->GetInteger(L"bottom", &bottom) &&
         wp_pref->GetInteger(L"right", &right) &&
         wp_pref->GetBoolean(L"maximized", maximized);
     bounds->SetRect(left, top, std::max(0, right - left),
                     std::max(0, bottom - top));
+
+    int work_area_top = 0;
+    int work_area_left = 0;
+    int work_area_bottom = 0;
+    int work_area_right = 0;
+    if (wp_pref) {
+      wp_pref->GetInteger(L"work_area_top", &work_area_top);
+      wp_pref->GetInteger(L"work_area_left", &work_area_left);
+      wp_pref->GetInteger(L"work_area_bottom", &work_area_bottom);
+      wp_pref->GetInteger(L"work_area_right", &work_area_right);
+    }
+    work_area->SetRect(work_area_left, work_area_top,
+                      std::max(0, work_area_right - work_area_left),
+                      std::max(0, work_area_bottom - work_area_top));
+
     return has_prefs;
   }
 
   virtual bool GetLastActiveWindowState(gfx::Rect* bounds) const {
     // Applications are always restored with the same position.
     if (!app_name_.empty())
       return false;
 
     // If a reference browser is set, use its window. Otherwise find last
     // active.
@@ skipping 86 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(kWindowTilePixels, kWindowTilePixels);
-  AdjustBoundsToBeVisibleOnMonitorContaining(last_window_bounds, bounds);
+  AdjustBoundsToBeVisibleOnMonitorContaining(last_window_bounds,
+                                             gfx::Rect(),
+                                             bounds);
   return true;
 }
 
 bool WindowSizer::GetSavedWindowBounds(gfx::Rect* bounds,
                                        bool* maximized) const {
   DCHECK(bounds && maximized);
+  gfx::Rect saved_work_area;
   if (!state_provider_ ||
-      !state_provider_->GetPersistentState(bounds, maximized))
+      !state_provider_->GetPersistentState(bounds, maximized, &saved_work_area))
     return false;
-  AdjustBoundsToBeVisibleOnMonitorContaining(*bounds, bounds);
+  AdjustBoundsToBeVisibleOnMonitorContaining(*bounds, saved_work_area, 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();
 
   // The default size is either some reasonably wide width, or if the work
@@ skipping 50 matching lines @@
 }
 
 namespace {
   // Minimum height of the visible part of a window.
   static const int kMinVisibleHeight = 30;
   // Minimum width of the visible part of a window.
   static const int kMinVisibleWidth = 30;
 }
 
 void WindowSizer::AdjustBoundsToBeVisibleOnMonitorContaining(
-    const gfx::Rect& other_bounds, gfx::Rect* bounds) const {
+    const gfx::Rect& other_bounds,
+    const gfx::Rect& saved_work_area,
+    gfx::Rect* bounds) const {
   DCHECK(bounds);
   DCHECK(monitor_info_provider_);
 
   // Find the size of the work area of the monitor that intersects the bounds
   // of the anchor window.
   gfx::Rect work_area =
       monitor_info_provider_->GetMonitorWorkAreaMatching(other_bounds);
 
   // If height or width are 0, reset to the default size.
   gfx::Rect default_bounds;
   GetDefaultWindowBounds(&default_bounds);
   if (bounds->height() <= 0)
     bounds->set_height(default_bounds.height());
   if (bounds->width() <= 0)
     bounds->set_width(default_bounds.width());
 
   // Ensure the minimum height and width.
   bounds->set_height(std::max(kMinVisibleHeight, bounds->height()));
   bounds->set_width(std::max(kMinVisibleWidth, bounds->width()));
 
+  // Ensure that the title bar is not above the work area.
+  if (bounds->y() < work_area.y())
+    bounds->set_y(work_area.y());
+
+  // Reposition and resize the bounds if the saved_work_area is different from
+  // the current work area and the current work area doesn't completely contain
+  // the bounds.
+  if (!saved_work_area.IsEmpty() &&
+      saved_work_area != work_area &&
+      !work_area.Contains(*bounds)) {
+    bounds->set_width(std::min(bounds->width(), work_area.width()));
+    bounds->set_height(std::min(bounds->height(), work_area.height()));
+    bounds->set_x(
+        std::max(work_area.x(),
+                 std::min(bounds->x(), work_area.right() - bounds->width())));
+    bounds->set_y(
+        std::max(work_area.y(),
+                 std::min(bounds->y(), work_area.bottom() - bounds->height())));
+  }
+
 #if defined(OS_MACOSX)
   // Limit the maximum height.  On the Mac the sizer is on the
   // bottom-right of the window, and a window cannot be moved "up"
   // past the menubar.  If the window is too tall you'll never be able
   // to shrink it again.  Windows does not have this limitation
   // (e.g. can be resized from the top).
   bounds->set_height(std::min(work_area.height(), bounds->height()));
 #endif  // defined(OS_MACOSX)
 
   // 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())));
 }