Remove unused "maximized" parameter from WindowSizer::GetBrowserWindowBounds().

chrome/browser/ui/window_sizer.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_UI_WINDOW_SIZER_H_
 #define CHROME_BROWSER_UI_WINDOW_SIZER_H_
 #pragma once
 
 #include <vector>
 
@@ skipping 67 matching lines @@
 
   // An interface implemented by an object that can retrieve state from either a
   // persistent store or an existing window.
   class StateProvider {
    public:
     virtual ~StateProvider() {}
 
     // Retrieve the persisted bounds of the window. Returns true if there was
     // persisted data to retrieve state information, false otherwise.
     virtual bool GetPersistentState(gfx::Rect* bounds,
-                                    bool* maximized,
                                     gfx::Rect* work_area) const = 0;
 
     // Retrieve the bounds of the most recent window of the matching type.
     // Returns true if there was a last active window to retrieve state
     // information from, false otherwise.
     virtual bool GetLastActiveWindowState(gfx::Rect* bounds) const = 0;
   };
 
-  // Determines the position, size and maximized state for a window as it is
-  // created. This function uses several strategies to figure out optimal size
-  // and placement, first looking for an existing active window, then falling
-  // back to persisted data from a previous session, finally utilizing a default
+  // Determines the position and size for a window as it is created. This
+  // function uses several strategies to figure out optimal size and placement,
+  // first looking for an existing active window, then falling back to persisted
+  // data from a previous session, finally utilizing a default
   // algorithm. If |specified_bounds| are non-empty, this value is returned
   // instead. For use only in testing.
-  //
-  // NOTE: |maximized| is only set if we're restoring a saved maximized window.
-  // When creating a new window based on an existing active window, standard
-  // Windows behavior is to have it always be nonmaximized, even if the existing
-  // window is maximized.
   void DetermineWindowBounds(const gfx::Rect& specified_bounds,
-                             gfx::Rect* bounds,
-                             bool* maximized) const;
+                             gfx::Rect* bounds) const;
 
   // Determines the size, position and maximized state for the browser window.
   // See documentation for DetermineWindowBounds above. Normally,
   // |window_bounds| is calculated by calling GetLastActiveWindowState(). To
   // explicitly specify a particular window to base the bounds on, pass in a
   // non-NULL value for |browser|.
   static void GetBrowserWindowBounds(const std::string& app_name,
                                      const gfx::Rect& specified_bounds,
                                      const Browser* browser,
-                                     gfx::Rect* window_bounds,
-                                     bool* maximized);
+                                     gfx::Rect* window_bounds);
 
   // Returns the default origin for popups of the given size.
   static gfx::Point GetDefaultPopupOrigin(const gfx::Size& size);
 
   // How much horizontal and vertical offset there is between newly
   // opened windows.  This value may be different on each platform.
   static const int kWindowTilePixels;
 
  private:
   // The edge of the screen to check for out-of-bounds.
   enum Edge { TOP, LEFT, BOTTOM, RIGHT };
 
   // Gets the size and placement of the last window. Returns true if this data
   // is valid, false if there is no last window and the application should
   // restore saved state from preferences using RestoreWindowPosition.
   bool GetLastWindowBounds(gfx::Rect* bounds) const;
 
   // Gets the size and placement of the last window in the last session, saved
   // in local state preferences. Returns true if local state exists containing
   // this information, false if this information does not exist and a default
   // size should be used.
-  bool GetSavedWindowBounds(gfx::Rect* bounds, bool* maximized) const;
+  bool GetSavedWindowBounds(gfx::Rect* bounds) const;
 
   // Gets the default window position and size if there is no last window and
   // no saved window placement in prefs. This function determines the default
   // size based on monitor size, etc.
   void GetDefaultWindowBounds(gfx::Rect* default_bounds) const;
 
   // Returns true if the specified position is "offscreen" for the given edge,
   // meaning that it's outside all work areas in the direction of that edge.
   bool PositionIsOffscreen(int position, Edge edge) const;
 
@@ skipping 11 matching lines @@
       gfx::Rect* bounds) const;
 
   // Providers for persistent storage and monitor metrics.
   StateProvider* state_provider_;
   MonitorInfoProvider* monitor_info_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowSizer);
 };
 
 #endif  // CHROME_BROWSER_UI_WINDOW_SIZER_H_