Open non browser window on the target display

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/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.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/browser/ui/browser_window_state.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "ui/gfx/screen.h"
 
 #if defined(USE_ASH)
 #include "ash/shell.h"
 #include "ash/wm/window_positioner.h"
 #include "chrome/browser/ui/ash/ash_init.h"
 #endif
 
+namespace {
+
 // 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;
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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:
@@ skipping 91 matching lines @@
   }
 
  private:
   std::string app_name_;
 
   // If set, is used as the reference browser for GetLastActiveWindowState.
   const Browser* browser_;
   DISALLOW_COPY_AND_ASSIGN(DefaultStateProvider);
 };
 
+class DefaultTargetDisplayProvider : public WindowSizer::TargetDisplayProvider {
+ public:
+  DefaultTargetDisplayProvider() {}
+  virtual ~DefaultTargetDisplayProvider() {}
+
+  virtual gfx::Display GetTargetDisplay(
+      const gfx::Screen* screen,
+      const gfx::Rect& bounds) const OVERRIDE {
+#if defined(USE_ASH)
+    // Use the target display on ash.
+    if (chrome::ShouldOpenAshOnStartup()) {
+      aura::Window* target = ash::Shell::GetTargetRootWindow();
+      return screen->GetDisplayNearestWindow(target);
+    }
+#endif
+    // Find the size of the work area of the monitor that intersects the bounds
+    // of the anchor window.
+    return screen->GetDisplayMatching(bounds);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DefaultTargetDisplayProvider);
+};
+
+}  // namespace
+
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer, public:
 
-WindowSizer::WindowSizer(StateProvider* state_provider, const Browser* browser)
-    : state_provider_(state_provider),
+WindowSizer::WindowSizer(
+    scoped_ptr<StateProvider> state_provider,
+    scoped_ptr<TargetDisplayProvider> target_display_provider,
+    const Browser* browser)
+    : state_provider_(state_provider.Pass()),
+      target_display_provider_(target_display_provider.Pass()),
       // TODO(scottmg): NativeScreen is wrong. http://crbug.com/133312
       screen_(gfx::Screen::GetNativeScreen()),
       browser_(browser) {
 }
 
-WindowSizer::WindowSizer(StateProvider* state_provider,
-                         gfx::Screen* screen,
-                         const Browser* browser)
-    : state_provider_(state_provider),
+WindowSizer::WindowSizer(
+    scoped_ptr<StateProvider> state_provider,
+    scoped_ptr<TargetDisplayProvider> target_display_provider,
+    gfx::Screen* screen,
+    const Browser* browser)
+    : state_provider_(state_provider.Pass()),
+      target_display_provider_(target_display_provider.Pass()),
       screen_(screen),
       browser_(browser) {
   DCHECK(screen_);
 }
 
 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);
+  scoped_ptr<StateProvider> state_provider(
+      new DefaultStateProvider(app_name, browser));
+  scoped_ptr<TargetDisplayProvider> target_display_provider(
+      new DefaultTargetDisplayProvider);
+  const WindowSizer sizer(state_provider.Pass(),
+                          target_display_provider.Pass(),
+                          browser);
   sizer.DetermineWindowBoundsAndShowState(specified_bounds,
                                           window_bounds,
                                           show_state);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer, private:
 
 void WindowSizer::DetermineWindowBoundsAndShowState(
     const gfx::Rect& specified_bounds,
@@ skipping 11 matching lines @@
       GetTabbedBrowserBoundsAsh(bounds, show_state);
       return;
     } else if (browser_ && browser_->host_desktop_type() ==
                chrome::HOST_DESKTOP_TYPE_ASH) {
       // In ash, saved show state takes precidence.  If you have a
       // question or an issue, please contact oshima@chromium.org.
       GetSavedWindowBounds(bounds, show_state);
     }
 #endif
     // See if there's last active window's placement information.
-    if (GetLastWindowBounds(bounds, show_state))
+    if (GetLastActiveWindowBounds(bounds, show_state))
       return;
     // See if there's saved placement information.
     if (GetSavedWindowBounds(bounds, show_state))
       return;
     // No saved placement, figure out some sensible default size based on
     // the user's screen size.
-    GetDefaultWindowBounds(screen_->GetPrimaryDisplay(), bounds);
+    GetDefaultWindowBounds(GetTargetDisplay(gfx::Rect()), bounds);
   } else {
 #if defined(USE_ASH)
     // In case of a popup with an 'unspecified' location in ash, we are
     // looking for a good screen location. We are interpreting (0,0) as an
     // unspecified location.
     if (IsPopupBrowserInAsh() && bounds->origin().IsOrigin()) {
       *bounds = ash::Shell::GetInstance()->window_positioner()->
           GetPopupPosition(*bounds);
       return;
     }
 #endif
     // 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 = screen_->GetDisplayMatching(*bounds).work_area();
     // Resize so that it fits.
     bounds->AdjustToFit(work_area);
   }
 }
 
-bool WindowSizer::GetLastWindowBounds(gfx::Rect* bounds,
-                                      ui::WindowShowState* show_state) const {
+bool WindowSizer::GetLastActiveWindowBounds(
+    gfx::Rect* bounds,
+    ui::WindowShowState* show_state) const {
   DCHECK(bounds);
   DCHECK(show_state);
   if (!state_provider_.get() ||
       !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);
+  AdjustBoundsToBeVisibleOnDisplay(screen_->GetDisplayMatching(*bounds),
+                                   gfx::Rect(),
+                                   bounds);
   return true;
 }
 
 bool WindowSizer::GetSavedWindowBounds(gfx::Rect* bounds,
                                        ui::WindowShowState* show_state) const {
   DCHECK(bounds);
   DCHECK(show_state);
   gfx::Rect saved_work_area;
   if (!state_provider_.get() ||
       !state_provider_->GetPersistentState(bounds,
                                            &saved_work_area,
                                            show_state))
     return false;
-  AdjustBoundsToBeVisibleOnMonitorContaining(*bounds, saved_work_area, bounds);
+  AdjustBoundsToBeVisibleOnDisplay(GetTargetDisplay(*bounds),
+                                   saved_work_area,
+                                   bounds);
   return true;
 }
 
 void WindowSizer::GetDefaultWindowBounds(const gfx::Display& display,
                                          gfx::Rect* default_bounds) const {
   DCHECK(default_bounds);
 #if defined(USE_ASH)
   // TODO(beng): insufficient but currently necessary. http://crbug.com/133312
   if (chrome::ShouldOpenAshOnStartup()) {
-    *default_bounds = ash::WindowPositioner::GetDefaultWindowBounds(
-        display);
+    *default_bounds = ash::WindowPositioner::GetDefaultWindowBounds(display);
     return;
   }
 #endif
   gfx::Rect work_area = display.work_area();
 
   // The default size is either some reasonably wide width, or if the work
   // area is narrower, then the work area width less some aesthetic padding.
   int default_width = std::min(work_area.width() - 2 * kWindowTilePixels, 1050);
   int default_height = work_area.height() - 2 * kWindowTilePixels;
 
@@ skipping 13 matching lines @@
     // The padding is set so that two windows, side by side have
     // kWindowTilePixels between screen edge and each other.
     default_width = static_cast<int>(work_area.width() / 2. -
         1.5 * kWindowTilePixels);
   }
   default_bounds->SetRect(kWindowTilePixels + work_area.x(),
                           kWindowTilePixels + work_area.y(),
                           default_width, default_height);
 }
 
-void WindowSizer::AdjustBoundsToBeVisibleOnMonitorContaining(
-    const gfx::Rect& other_bounds,
+void WindowSizer::AdjustBoundsToBeVisibleOnDisplay(
+    const gfx::Display& display,
     const gfx::Rect& saved_work_area,
     gfx::Rect* bounds) const {
   DCHECK(bounds);
 
-  // Find the size of the work area of the monitor that intersects the bounds
-  // of the anchor window.
-  gfx::Display display = screen_->GetDisplayMatching(other_bounds);
-
-  // If height or width are 0, reset to the default size.
-  gfx::Rect default_bounds;
-  GetDefaultWindowBounds(display, &default_bounds);
-  if (bounds->height() <= 0)
-    bounds->set_height(default_bounds.height());
-  if (bounds->width() <= 0)
-    bounds->set_width(default_bounds.width());
+  // If |bounds| is empty, reset to the default size.
+  if (bounds->IsEmpty()) {
+    gfx::Rect default_bounds;
+    GetDefaultWindowBounds(display, &default_bounds);
+    if (bounds->height() <= 0)
+      bounds->set_height(default_bounds.height());
+    if (bounds->width() <= 0)
+      bounds->set_width(default_bounds.width());
+  }
 
   // Ensure the minimum height and width.
   bounds->set_height(std::max(kMinVisibleHeight, bounds->height()));
   bounds->set_width(std::max(kMinVisibleWidth, bounds->width()));
 
   gfx::Rect work_area = display.work_area();
   // Ensure that the title bar is not above the work area.
   if (bounds->y() < work_area.y())
     bounds->set_y(work_area.y());
 
@@ skipping 36 matching lines @@
   // 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)
 }
 
+gfx::Display WindowSizer::GetTargetDisplay(const gfx::Rect& bounds) const {
+  return target_display_provider_->GetTargetDisplay(screen_, bounds);
+}
+
 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.
@@ skipping 19 matching lines @@
       browser_->host_desktop_type() == chrome::HOST_DESKTOP_TYPE_ASH &&
       browser_->is_type_tabbed();
 }
 
 bool WindowSizer::IsPopupBrowserInAsh() const {
   return browser_ &&
       browser_->host_desktop_type() == chrome::HOST_DESKTOP_TYPE_ASH &&
       browser_->is_type_popup();
 }
 #endif