Combined window positioning and show state determiniation in the WindowSizer

chrome/browser/ui/window_sizer/window_sizer.cc

 // Copyright (c) 2012 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/ui/window_sizer/window_sizer.h"
 
 #include "base/compiler_specific.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/ash/ash_init.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/browser_window_state.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/common/chrome_switches.cc"
 #include "ui/gfx/screen.h"
+#include "ui/views/widget/widget.h"

[sky, 2012/10/05 22:54:03]

This is cross platform code, don't use views

[Mr4D (OOO till 08-26), 2012/10/06 01:10:10]

When I checked for minimize that was the only way I was able to come up with
(after a looong search). Really odd.

 
 // Minimum height of the visible part of a window.
 const int kMinVisibleHeight = 30;
 // Minimum width of the visible part of a window.
 const int kMinVisibleWidth = 30;
 
 class DefaultMonitorInfoProvider : public MonitorInfoProvider {
  public:
   // Overridden from MonitorInfoProvider:
   virtual gfx::Rect GetPrimaryDisplayWorkArea() const OVERRIDE {
@@ skipping 12 matching lines @@
 // 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:
   DefaultStateProvider(const std::string& app_name, const Browser* browser)
       : app_name_(app_name), browser_(browser) {
   }
 
   // Overridden from WindowSizer::StateProvider:
   virtual bool GetPersistentState(gfx::Rect* bounds,
-                                  gfx::Rect* work_area) const {
+                                  gfx::Rect* work_area,
+                                  ui::WindowShowState& show_state) const {
     DCHECK(bounds);
 
     if (!browser_ || !browser_->profile()->GetPrefs())
       return false;
 
     std::string window_name(chrome::GetWindowPlacementKey(browser_));
     const DictionaryValue* wp_pref =
         browser_->profile()->GetPrefs()->GetDictionary(window_name.c_str());
     int top = 0, left = 0, bottom = 0, right = 0;
+    bool maximized = false;
     bool has_prefs = wp_pref &&
                      wp_pref->GetInteger("top", &top) &&
                      wp_pref->GetInteger("left", &left) &&
                      wp_pref->GetInteger("bottom", &bottom) &&
-                     wp_pref->GetInteger("right", &right);
+                     wp_pref->GetInteger("right", &right) &&
+                     wp_pref->GetBoolean("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("work_area_top", &work_area_top);
       wp_pref->GetInteger("work_area_left", &work_area_left);
       wp_pref->GetInteger("work_area_bottom", &work_area_bottom);
       wp_pref->GetInteger("work_area_right", &work_area_right);
+      if (show_state == ui::SHOW_STATE_DEFAULT && maximized)
+        show_state = ui::SHOW_STATE_MAXIMIZED;
     }
     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 {
+  virtual bool GetLastActiveWindowState(gfx::Rect* bounds,
+      ui::WindowShowState& show_state) 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. Panels are never used as reference browsers as panels are
     // specially positioned.
     BrowserWindow* window = NULL;
     // Window may be null if browser is just starting up.
     if (browser_ && browser_->window() && !browser_->window()->IsPanel()) {
       window = browser_->window();
     } else {
       BrowserList::const_reverse_iterator it = BrowserList::begin_last_active();
       BrowserList::const_reverse_iterator end = BrowserList::end_last_active();
       for (; (it != end); ++it) {
         Browser* last_active = *it;
         if (last_active && last_active->is_type_tabbed()) {
           window = last_active->window();
           DCHECK(window);
           break;
         }
       }
     }
 
     if (window) {
       *bounds = window->GetRestoredBounds();
+      bool maximized = views::Widget::GetWidgetForNativeWindow(

[sky, 2012/10/05 22:54:03]

You want window->IsMaximized(), which works on all platforms.

[Mr4D (OOO till 08-26), 2012/10/06 01:10:10]

This is now funny. I was looking all over the system for a way to do this [..]
and have found then this - awkward - way. Why did I miss this? I suppose this is
not only on one location. Done.

+          window->GetNativeWindow())->IsMaximized();
+      if (show_state == ui::SHOW_STATE_DEFAULT && maximized)
+        show_state = ui::SHOW_STATE_MAXIMIZED;
       return true;
     }
 
     return false;
   }
 
  private:
   std::string app_name_;
 
   // If set, is used as the reference browser for GetLastActiveWindowState.
@@ skipping 24 matching lines @@
                          const Browser* browser)
     : state_provider_(state_provider),
       monitor_info_provider_(monitor_info_provider),
       browser_(browser) {
 }
 
 WindowSizer::~WindowSizer() {
 }
 
 // static
+void WindowSizer::GetBrowserWindowBoundsAndShowState(
+    const std::string& app_name,
+    const gfx::Rect& specified_bounds,
+    const Browser* browser,
+    gfx::Rect* window_bounds,
+    ui::WindowShowState& show_state) {
+  const WindowSizer sizer(new DefaultStateProvider(app_name, browser), browser);
+  sizer.DetermineWindowBoundsAndShowState(specified_bounds,
+                                          window_bounds,
+                                          show_state);
+}
+
+// static
 void WindowSizer::GetBrowserWindowBounds(const std::string& app_name,
                                          const gfx::Rect& specified_bounds,
                                          const Browser* browser,
                                          gfx::Rect* window_bounds) {
   const WindowSizer sizer(new DefaultStateProvider(app_name, browser), browser);
-  sizer.DetermineWindowBounds(specified_bounds, window_bounds);
+  ui::WindowShowState show_state;
+  sizer.DetermineWindowBoundsAndShowState(specified_bounds,
+                                          window_bounds,
+                                          show_state);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer, private:
 
-void WindowSizer::DetermineWindowBounds(const gfx::Rect& specified_bounds,
-                                        gfx::Rect* bounds) const {
+void WindowSizer::DetermineWindowBoundsAndShowState(
+    const gfx::Rect& specified_bounds,
+    gfx::Rect* bounds,
+    ui::WindowShowState& show_state) const {
+  // Pre-populate the window state with our default.
+  show_state = GetWindowDefaultShowState();
   *bounds = specified_bounds;
   if (bounds->IsEmpty()) {
-    if (GetBoundsOverride(specified_bounds, bounds))
+    if (GetBoundsOverride(specified_bounds, bounds, show_state))
       return;
     // See if there's saved placement information.
-    if (!GetLastWindowBounds(bounds)) {
-      if (!GetSavedWindowBounds(bounds)) {
+    if (!GetLastWindowBounds(bounds, show_state)) {
+      if (!GetSavedWindowBounds(bounds, show_state)) {
         // No saved placement, figure out some sensible default size based on
         // the user's screen size.
         GetDefaultWindowBounds(bounds);
       }
     }
   } else {
     // In case that there was a bound given we need to make sure that it is
     // visible and fits on the screen.
     // Find the size of the work area of the monitor that intersects the bounds
     // of the anchor window. Note: AdjustBoundsToBeVisibleOnMonitorContaining
     // does not exactly what we want: It makes only sure that "a minimal part"
     // is visible on the screen.
     gfx::Rect work_area =
         monitor_info_provider_->GetMonitorWorkAreaMatching(*bounds);
     // Resize so that it fits.
     *bounds = bounds->AdjustToFit(work_area);
   }
 }
 
-bool WindowSizer::GetLastWindowBounds(gfx::Rect* bounds) const {
+bool WindowSizer::GetLastWindowBounds(gfx::Rect* bounds,
+                                      ui::WindowShowState& show_state) const {
   DCHECK(bounds);
   if (!state_provider_.get() ||
-      !state_provider_->GetLastActiveWindowState(bounds))
+      !state_provider_->GetLastActiveWindowState(bounds, show_state))
     return false;
   gfx::Rect last_window_bounds = *bounds;
   bounds->Offset(kWindowTilePixels, kWindowTilePixels);
   AdjustBoundsToBeVisibleOnMonitorContaining(last_window_bounds,
                                              gfx::Rect(),
                                              bounds);
   return true;
 }
 
-bool WindowSizer::GetSavedWindowBounds(gfx::Rect* bounds) const {
+bool WindowSizer::GetSavedWindowBounds(gfx::Rect* bounds,
+                                       ui::WindowShowState& show_state) const {
   DCHECK(bounds);
   gfx::Rect saved_work_area;
   if (!state_provider_.get() ||
-      !state_provider_->GetPersistentState(bounds, &saved_work_area))
+      !state_provider_->GetPersistentState(bounds,
+                                           &saved_work_area,
+                                           show_state))
     return false;
   AdjustBoundsToBeVisibleOnMonitorContaining(*bounds, saved_work_area, bounds);
   return true;
 }
 
 void WindowSizer::GetDefaultWindowBounds(gfx::Rect* default_bounds) const {
 #if defined(USE_ASH)
   // TODO(beng): insufficient but currently necessary. http://crbug.com/133312
   if (chrome::ShouldOpenAshOnStartup()) {
     GetDefaultWindowBoundsAsh(default_bounds);
@@ skipping 102 matching lines @@
   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())));
 #endif  // defined(OS_MACOSX)
 }
 
 bool WindowSizer::GetBoundsOverride(
     const gfx::Rect& specified_bounds,
-    gfx::Rect* bounds) const {
+    gfx::Rect* bounds,
+    ui::WindowShowState& show_state) const {
 #if defined(USE_ASH)
   // TODO(beng): insufficient but currently necessary. http://crbug.com/133312
   if (chrome::ShouldOpenAshOnStartup())
-    return GetBoundsOverrideAsh(specified_bounds, bounds);
+    return GetBoundsOverrideAsh(specified_bounds, bounds, show_state);
 #endif
   return false;
 }
+
+ui::WindowShowState WindowSizer::GetWindowDefaultShowState() const {
+  if (!browser_)
+    return ui::SHOW_STATE_DEFAULT;
+
+  // Only tabbed browsers use the command line or preference state, with the
+  // exception of devtools.
+  bool show_state = !browser_->is_type_tabbed() && !browser_->is_devtools();
+
+#if defined(USE_AURA)
+  // We use the apps save state on aura.
+  show_state &= !browser_->is_app();
+#endif
+
+  if (show_state)
+    return browser_->initial_show_state();
+
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kStartMaximized))
+    return ui::SHOW_STATE_MAXIMIZED;
+
+  if (browser_->initial_show_state() != ui::SHOW_STATE_DEFAULT)
+    return browser_->initial_show_state();
+
+  // Otherwise we use the default which can be overridden later on.
+  return ui::SHOW_STATE_DEFAULT;
+}