Add context to gfx::Screen calls in support of simultaneous desktop+ash

chrome/browser/ui/window_sizer/window_sizer.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_WINDOW_SIZER_WINDOW_SIZER_H_
 #define CHROME_BROWSER_UI_WINDOW_SIZER_WINDOW_SIZER_H_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/ui/host_desktop.h"
@@ skipping 63 matching lines @@
     virtual bool GetLastActiveWindowState(gfx::Rect* bounds) const = 0;
   };
 
   // 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.
   void DetermineWindowBounds(const gfx::Rect& specified_bounds,
-                             gfx::Rect* bounds) const;
+                             gfx::Rect* bounds,
+                             const Browser* browser) 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);
@@ skipping 13 matching lines @@
   // 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;
+  bool GetLastWindowBounds(gfx::Rect* bounds, const Browser* browser) 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) const;
+  bool GetSavedWindowBounds(gfx::Rect* bounds, const Browser* browser) 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;
+  void GetDefaultWindowBounds(gfx::Rect* default_bounds,
+                              const Browser* browser) const;
 #if defined(USE_ASH)
   void GetDefaultWindowBoundsAsh(gfx::Rect* default_bounds) const;
 #endif
 
   // Adjusts |bounds| to be visible on-screen, biased toward the work area of
   // the monitor containing |other_bounds|.  Despite the name, this doesn't
   // guarantee the bounds are fully contained within this monitor's work rect;
   // it just tried to ensure the edges are visible on _some_ work rect.
   // If |saved_work_area| is non-empty, it is used to determine whether the
   // monitor configuration has changed. If it has, bounds are repositioned and
   // resized if necessary to make them completely contained in the current work
   // area.
   void AdjustBoundsToBeVisibleOnMonitorContaining(
       const gfx::Rect& other_bounds,
       const gfx::Rect& saved_work_area,
-      gfx::Rect* bounds) const;
+      gfx::Rect* bounds,
+      const Browser* browser) const;
 
   // Determines the position and size for a window as it gets created. This
   // will be called before DetermineWindowBounds. It will return true when the
   // function was setting the bounds structure to the desired size. Otherwise
   // another algorithm should get used to determine the correct bounds.
   bool GetBoundsOverride(const gfx::Rect& specified_bounds,
-                         gfx::Rect* bounds) const;
+                         gfx::Rect* bounds,
+                         const Browser* browser) const;
 #if defined(USE_ASH)
   bool GetBoundsOverrideAsh(const gfx::Rect& specified_bounds,
-                            gfx::Rect* bounds_in_screen) const;
+                            gfx::Rect* bounds_in_screen,
+                            const Browser* browser) const;
 #endif
 
   // Providers for persistent storage and monitor metrics.
   scoped_ptr<StateProvider> state_provider_;
   scoped_ptr<MonitorInfoProvider> monitor_info_provider_;
 
   // Note that this browser handle might be NULL.
   const Browser* browser_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowSizer);
 };
 
 #endif  // CHROME_BROWSER_UI_WINDOW_SIZER_WINDOW_SIZER_H_