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

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/compiler_specific.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/ash/ash_init.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/common/pref_names.h"
 #include "ui/gfx/screen.h"
 
 // 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;
 
 class DefaultMonitorInfoProvider : public MonitorInfoProvider {
  public:
   // Overridden from MonitorInfoProvider:
   virtual gfx::Rect GetPrimaryDisplayWorkArea() const OVERRIDE {
-    return gfx::Screen::GetPrimaryDisplay().work_area();
+    return gfx::Screen::GetPrimaryDisplay(
+        gfx::Screen::BadTwoWorldsContext()).work_area();
   }
   virtual gfx::Rect GetPrimaryDisplayBounds() const OVERRIDE {
-    return gfx::Screen::GetPrimaryDisplay().bounds();
+    return gfx::Screen::GetPrimaryDisplay(
+        gfx::Screen::BadTwoWorldsContext()).bounds();
   }
   virtual gfx::Rect GetMonitorWorkAreaMatching(
       const gfx::Rect& match_rect) const OVERRIDE {
-    return gfx::Screen::GetDisplayMatching(match_rect).work_area();
+    return gfx::Screen::GetDisplayMatching(
+        gfx::Screen::BadTwoWorldsContext(), match_rect).work_area();
   }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // 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) {
@@ skipping 105 matching lines @@
 
 WindowSizer::~WindowSizer() {
 }
 
 // static
 void WindowSizer::GetBrowserWindowBounds(const std::string& app_name,
                                          const gfx::Rect& specified_bounds,
                                          const Browser* browser,
                                          gfx::Rect* window_bounds) {
   const WindowSizer sizer(new DefaultStateProvider(app_name, browser), browser);
-  sizer.DetermineWindowBounds(specified_bounds, window_bounds);
+  sizer.DetermineWindowBounds(specified_bounds, window_bounds, browser);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer, private:
 
 void WindowSizer::DetermineWindowBounds(const gfx::Rect& specified_bounds,
-                                        gfx::Rect* bounds) const {
+                                        gfx::Rect* bounds,
+                                        const Browser* browser) const {
   *bounds = specified_bounds;
   if (bounds->IsEmpty()) {
-    if (GetBoundsOverride(specified_bounds, bounds))
+    if (GetBoundsOverride(specified_bounds, bounds, browser))
       return;
     // See if there's saved placement information.
-    if (!GetLastWindowBounds(bounds)) {
-      if (!GetSavedWindowBounds(bounds)) {
+    if (!GetLastWindowBounds(bounds, browser)) {
+      if (!GetSavedWindowBounds(bounds, browser)) {
         // No saved placement, figure out some sensible default size based on
         // the user's screen size.
-        GetDefaultWindowBounds(bounds);
+        GetDefaultWindowBounds(bounds, browser);
       }
     }
   } else {
     // 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 =
         monitor_info_provider_->GetMonitorWorkAreaMatching(*bounds);
     // Resize so that it fits.
     *bounds = bounds->AdjustToFit(work_area);
   }
 }
 
-bool WindowSizer::GetLastWindowBounds(gfx::Rect* bounds) const {
+bool WindowSizer::GetLastWindowBounds(gfx::Rect* bounds,
+                                      const Browser* browser) const {
   DCHECK(bounds);
   if (!state_provider_.get() ||
       !state_provider_->GetLastActiveWindowState(bounds))
     return false;
   gfx::Rect last_window_bounds = *bounds;
   bounds->Offset(kWindowTilePixels, kWindowTilePixels);
   AdjustBoundsToBeVisibleOnMonitorContaining(last_window_bounds,
                                              gfx::Rect(),
-                                             bounds);
+                                             bounds,
+                                             browser);
   return true;
 }
 
-bool WindowSizer::GetSavedWindowBounds(gfx::Rect* bounds) const {
+bool WindowSizer::GetSavedWindowBounds(gfx::Rect* bounds,
+                                       const Browser* browser) const {
   DCHECK(bounds);
   gfx::Rect saved_work_area;
   if (!state_provider_.get() ||
       !state_provider_->GetPersistentState(bounds, &saved_work_area))
     return false;
-  AdjustBoundsToBeVisibleOnMonitorContaining(*bounds, saved_work_area, bounds);
+  AdjustBoundsToBeVisibleOnMonitorContaining(
+      *bounds, saved_work_area, bounds, browser);
   return true;
 }
 
-void WindowSizer::GetDefaultWindowBounds(gfx::Rect* default_bounds) const {
-#if defined(USE_ASH)
-  // TODO(beng): insufficient but currently necessary. http://crbug.com/133312
-  if (chrome::ShouldOpenAshOnStartup()) {
+void WindowSizer::GetDefaultWindowBounds(gfx::Rect* default_bounds,
+                                         const Browser* browser) const {
+  // TODO(scottmg): http://crbug.com/133312
+  if (chrome::GetHostDesktopTypeForBrowser(browser) ==
+      chrome::HOST_DESKTOP_TYPE_ASH) {
     GetDefaultWindowBoundsAsh(default_bounds);
     return;
   }
-#endif
   DCHECK(default_bounds);
   DCHECK(monitor_info_provider_.get());
 
   gfx::Rect work_area = monitor_info_provider_->GetPrimaryDisplayWorkArea();
 
   // 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 16 matching lines @@
         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,
     const gfx::Rect& saved_work_area,
-    gfx::Rect* bounds) const {
+    gfx::Rect* bounds,
+    const Browser* browser) const {
   DCHECK(bounds);
   DCHECK(monitor_info_provider_.get());
 
   // Find the size of the work area of the monitor that intersects the bounds
   // of the anchor window.
   gfx::Rect work_area =
       monitor_info_provider_->GetMonitorWorkAreaMatching(other_bounds);
 
   // If height or width are 0, reset to the default size.
   gfx::Rect default_bounds;
-  GetDefaultWindowBounds(&default_bounds);
+  GetDefaultWindowBounds(&default_bounds, browser);
   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()));
 
   // Ensure that the title bar is not above the work area.
@@ skipping 41 matching lines @@
   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)
 }
 
 bool WindowSizer::GetBoundsOverride(
     const gfx::Rect& specified_bounds,
-    gfx::Rect* bounds) const {
+    gfx::Rect* bounds,
+    const Browser* browser) const {
 #if defined(USE_ASH)
-  // TODO(beng): insufficient but currently necessary. http://crbug.com/133312
-  if (chrome::ShouldOpenAshOnStartup())
-    return GetBoundsOverrideAsh(specified_bounds, bounds);
+  // TODO(scottmg): http://crbug.com/133312
+  if (chrome::GetHostDesktopTypeForBrowser(browser) ==
+      chrome::HOST_DESKTOP_TYPE_ASH)
+    return GetBoundsOverrideAsh(specified_bounds, bounds, browser);
 #endif
   return false;
 }