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

chrome/browser/ui/window_sizer.cc

 // 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.
 
 #include "chrome/browser/ui/window_sizer.h"
 
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/pref_names.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:
   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,
-                                  bool* maximized,
                                   gfx::Rect* work_area) const {
-    DCHECK(bounds && maximized);
-
-    std::string key(prefs::kBrowserWindowPlacement);
-    if (!app_name_.empty()) {
-      key.append("_");
-      key.append(app_name_);
-    }
+    DCHECK(bounds);
 
     if (!browser_ || !browser_->profile()->GetPrefs())
       return false;
 
+    std::string window_name(browser_->GetWindowPlacementKey());
     const DictionaryValue* wp_pref =
-        browser_->profile()->GetPrefs()->GetDictionary(key.c_str());
+        browser_->profile()->GetPrefs()->GetDictionary(window_name.c_str());
     int top = 0, left = 0, bottom = 0, right = 0;
-    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->GetBoolean("maximized", maximized);
+    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);
     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);
@@ skipping 62 matching lines @@
   if (state_provider_)
     delete state_provider_;
   if (monitor_info_provider_)
     delete monitor_info_provider_;
 }
 
 // static
 void WindowSizer::GetBrowserWindowBounds(const std::string& app_name,
                                          const gfx::Rect& specified_bounds,
                                          const Browser* browser,
-                                         gfx::Rect* window_bounds,
-                                         bool* maximized) {
+                                         gfx::Rect* window_bounds) {
   const WindowSizer sizer(new DefaultStateProvider(app_name, browser),
                           CreateDefaultMonitorInfoProvider());
-  sizer.DetermineWindowBounds(specified_bounds, window_bounds, maximized);
+  sizer.DetermineWindowBounds(specified_bounds, window_bounds);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer, private:
 
 void WindowSizer::DetermineWindowBounds(const gfx::Rect& specified_bounds,
-                                        gfx::Rect* bounds,
-                                        bool* maximized) const {
+                                        gfx::Rect* bounds) const {
   *bounds = specified_bounds;
   if (bounds->IsEmpty()) {
     // See if there's saved placement information.
     if (!GetLastWindowBounds(bounds)) {
-      if (!GetSavedWindowBounds(bounds, maximized)) {
+      if (!GetSavedWindowBounds(bounds)) {
         // No saved placement, figure out some sensible default size based on
         // the user's screen size.
         GetDefaultWindowBounds(bounds);
       }
     }
   }
 }
 
 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,
                                              gfx::Rect(),
                                              bounds);
   return true;
 }
 
-bool WindowSizer::GetSavedWindowBounds(gfx::Rect* bounds,
-                                       bool* maximized) const {
-  DCHECK(bounds && maximized);
+bool WindowSizer::GetSavedWindowBounds(gfx::Rect* bounds) const {
+  DCHECK(bounds);
   gfx::Rect saved_work_area;
   if (!state_provider_ ||
-      !state_provider_->GetPersistentState(bounds, maximized, &saved_work_area))
+      !state_provider_->GetPersistentState(bounds, &saved_work_area))
     return false;
   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();
@@ skipping 126 matching lines @@
   // On non-Mac platforms, we are less aggressive about repositioning.  Simply
   // ensure that 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())));
 #endif  // defined(OS_MACOSX)
 }