Open non browser window on the target display

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 14 matching lines @@
 //  shown at based several factors, including the position and size of the last
 //  window of the same type, the last saved bounds of the window from the
 //  previous session, and default system metrics if neither of the above two
 //  conditions exist. The system has built-in providers for monitor metrics
 //  and persistent storage (using preferences) but can be overrided with mocks
 //  for testing.
 //
 class WindowSizer {
  public:
   class StateProvider;
+  class TargetDisplayProvider;
 
-  // WindowSizer owns |state_provider| and will create a default
-  // MonitorInfoProvider using the physical screen.
-  WindowSizer(StateProvider* state_provider, const Browser* browser);
+  // WindowSizer owns |state_provider| and |target_display_provider|,
+  // and will use the platforms's gfx::Screen.
+  WindowSizer(scoped_ptr<StateProvider> state_provider,
+              scoped_ptr<TargetDisplayProvider> target_display_provider,
+              const Browser* browser);
 
-  // WindowSizer owns |state_provider| and will use the supplied |screen|.
-  // Used only for testing.
-  WindowSizer(StateProvider* state_provider,
+  // WindowSizer owns |state_provider| and |target_display_provider|,
+  // and will use the supplied |screen|. Used only for testing.
+  WindowSizer(scoped_ptr<StateProvider> state_provider,
+              scoped_ptr<TargetDisplayProvider> target_display_provider,
               gfx::Screen* screen,
               const Browser* browser);
 
   virtual ~WindowSizer();
 
   // 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.
     // The |show_state| variable will only be touched if there was persisted
     // data and the |show_state| variable is SHOW_STATE_DEFAULT.
     virtual bool GetPersistentState(gfx::Rect* bounds,
                                     gfx::Rect* work_area,
                                     ui::WindowShowState* show_state) 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.
     // The |show_state| variable will only be touched if we have found a
     // suitable window and the |show_state| variable is SHOW_STATE_DEFAULT.
     virtual bool GetLastActiveWindowState(
         gfx::Rect* bounds,
         ui::WindowShowState* show_state) const = 0;
   };
 
+  // An interface implemented by an object to identify on which
+  // display a new window should be located.
+  class TargetDisplayProvider {
+    public:
+      virtual ~TargetDisplayProvider() {}
+      virtual gfx::Display GetTargetDisplay(const gfx::Screen* screen,
+                                            const gfx::Rect& bounds) const = 0;
+  };
+
   // Determines the position and size for a window as it is created as well
   // as the initial state. 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.
   // |show_state| will be overwritten and return the initial visual state of
   // the window to use.
   void DetermineWindowBoundsAndShowState(
       const gfx::Rect& specified_bounds,
@@ skipping 17 matching lines @@
                                           chrome::HostDesktopType type);
 
   // 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
+  // Gets the size and placement of the last active 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.
   // |show_state| will only be changed if it was set to SHOW_STATE_DEFAULT.
-  bool GetLastWindowBounds(gfx::Rect* bounds,
-                           ui::WindowShowState* show_state) const;
+  bool GetLastActiveWindowBounds(gfx::Rect* bounds,
+                                 ui::WindowShowState* show_state) 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.
   // |show_state| will only be changed if it was set to SHOW_STATE_DEFAULT.
   bool GetSavedWindowBounds(gfx::Rect* bounds,
                             ui::WindowShowState* show_state) const;
 
   // Gets the default window position and size to be shown on
   // |display| 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(const gfx::Display& display,
                               gfx::Rect* default_bounds) const;
 
   // 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;
+  // the |display|.  Despite the name, this doesn't
+  // guarantee the bounds are fully contained within this display'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,
+  void AdjustBoundsToBeVisibleOnDisplay(
+      const gfx::Display& display,
       const gfx::Rect& saved_work_area,
       gfx::Rect* bounds) const;
 
+  // Determine the target display for a new window based on
+  // |bounds|. On ash environment, this returns the display containing
+  // ash's the target root window.
+  gfx::Display GetTargetDisplay(const gfx::Rect& bounds) const;
+
 #if defined(USE_ASH)
   // Determines the position and size for a tabbed browser window in
   // ash as it gets created. This will be called before other standard
   // placement logic. |show_state| will only be changed
   // if it was set to SHOW_STATE_DEFAULT.
   void GetTabbedBrowserBoundsAsh(gfx::Rect* bounds_in_screen,
                                  ui::WindowShowState* show_state) const;
 #endif
 
   // Determine the default show state for the window - not looking at other
   // windows or at persistent information.
   ui::WindowShowState GetWindowDefaultShowState() const;
 
 #if defined(USE_ASH)
   bool IsTabbedBrowserInAsh() const;
   bool IsPopupBrowserInAsh() const;
 #endif
 
   // Providers for persistent storage and monitor metrics.
   scoped_ptr<StateProvider> state_provider_;
+  scoped_ptr<TargetDisplayProvider> target_display_provider_;
   gfx::Screen* screen_;  // not owned.
 
   // 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_