Refactor screen/monitor so that gfx::Screen returns monitor object.

ui/gfx/screen_mac.mm

 // 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 "ui/gfx/screen.h"
 
 #import <ApplicationServices/ApplicationServices.h>
 #import <Cocoa/Cocoa.h>
 
+#include "base/logging.h"
+#include "ui/gfx/monitor.h"
+
 namespace {
 
 gfx::Rect ConvertCoordinateSystem(NSRect ns_rect) {
   // Primary monitor is defined as the monitor with the menubar,
   // which is always at index 0.
   NSScreen* primary_screen = [[NSScreen screens] objectAtIndex:0];
   float primary_screen_height = [primary_screen frame].size.height;
   gfx::Rect rect(NSRectToCGRect(ns_rect));
   rect.set_y(primary_screen_height - rect.y() - rect.height());
   return rect;
@@ skipping 11 matching lines @@
     int area = intersection.width() * intersection.height();
     if (area > max_area) {
       max_area = area;
       max_screen = screen;
     }
   }
 
   return max_screen;
 }
 
+gfx::Monitor* GetMonitorForScreen(NSScreen* screen, bool is_primary) {
+  static gfx::SimpleMonitor* monitor = new gfx::SimpleMonitor();

[dhollowa, 2012/04/09 23:41:37]

This will cause SimpleMonitor destructor to fire post-exit of |main()|.  That
may be ok, as long as it is trivial and doesn't hold on to anything important. 
I believe we have shutdown paths that will never reach static destructors too. 
Would a formal singleton be better?

[oshima, 2012/04/10 00:09:08]

This isn't uncommon for near POD objects such as Font and I think Monitor class
is simple enough not to worry about shutdown.

+
+  NSRect frame = [screen frame];
+  monitor->set_bounds(gfx::Rect(NSRectToCGRect(frame)));
+
+  NSRect visible_frame = [screen visibleFrame];
+
+  // Convert work area's coordinate systems.
+  if (is_primary) {
+    gfx::Rect work_area = gfx::Rect(NSRectToCGRect(visible_frame));
+    work_area.set_y(frame.size.height - visible_frame.origin.y -
+                    visible_frame.size.height);
+    monitor->set_work_area(work_area);
+  } else {
+    monitor->set_work_area(ConvertCoordinateSystem(visible_frame));
+  }
+  return monitor;
+}
+
 }  // namespace
 
 namespace gfx {
 
 // static
 gfx::Point Screen::GetCursorScreenPoint() {
   NSPoint mouseLocation  = [NSEvent mouseLocation];
   // Flip coordinates to gfx (0,0 in top-left corner) using primary screen.
   NSScreen* screen = [[NSScreen screens] objectAtIndex:0];
   mouseLocation.y = NSMaxY([screen frame]) - mouseLocation.y;
   return gfx::Point(mouseLocation.x, mouseLocation.y);
 }
 
 // static
-gfx::Rect Screen::GetPrimaryMonitorWorkArea() {
+const gfx::Monitor* Screen::GetPrimaryMonitor() {
   // Primary monitor is defined as the monitor with the menubar,
   // which is always at index 0.
   NSScreen* primary = [[NSScreen screens] objectAtIndex:0];
-  NSRect frame = [primary frame];
-  NSRect visible_frame = [primary visibleFrame];
+  gfx::Monitor* monitor = GetMonitorForScreen(primary, true /* primary */);
 
-  // Convert coordinate systems.
-  gfx::Rect rect = gfx::Rect(NSRectToCGRect(visible_frame));
-  rect.set_y(frame.size.height - visible_frame.origin.y -
-             visible_frame.size.height);
-  return rect;
+  CGDirectDisplayID main_display = CGMainDisplayID();
+  CHECK_EQ(static_cast<const int>(CGDisplayPixelsWide(main_display)),
+           monitor->GetSize().width());
+  CHECK_EQ(static_cast<const int>(CGDisplayPixelsHigh(main_display)),
+           monitor->GetSize().height());
+  return monitor;
 }
 
 // static
-gfx::Rect Screen::GetPrimaryMonitorBounds() {
-  // Primary monitor is defined as the monitor with the menubar,
-  // which is always at index 0.
-  NSScreen* primary = [[NSScreen screens] objectAtIndex:0];
-  return gfx::Rect(NSRectToCGRect([primary frame]));
+const gfx::Monitor* Screen::GetMonitorMatching(const gfx::Rect& match_rect) {
+  NSScreen* match_screen = GetMatchingScreen(match_rect);
+  return GetMonitorForScreen(match_screen, false /* may not be primary */);
 }
 
 // static
-gfx::Rect Screen::GetMonitorWorkAreaMatching(const gfx::Rect& match_rect) {
-  NSScreen* match_screen = GetMatchingScreen(match_rect);
-  return ConvertCoordinateSystem([match_screen visibleFrame]);
-}
-
-// static
-gfx::Size Screen::GetPrimaryMonitorSize() {
-  CGDirectDisplayID main_display = CGMainDisplayID();
-  return gfx::Size(CGDisplayPixelsWide(main_display),
-                   CGDisplayPixelsHigh(main_display));
-}
-
-// static
 int Screen::GetNumMonitors() {
   // Don't just return the number of online displays.  It includes displays
   // that mirror other displays, which are not desired in the count.  It's
   // tempting to use the count returned by CGGetActiveDisplayList, but active
   // displays exclude sleeping displays, and those are desired in the count.
 
   // It would be ridiculous to have this many displays connected, but
   // CGDirectDisplayID is just an integer, so supporting up to this many
   // doesn't hurt.
   CGDirectDisplayID online_displays[128];
@@ skipping 15 matching lines @@
       // The primary display in a mirrored set will be counted, but those that
       // mirror it will not be.
       ++display_count;
     }
   }
 
   return display_count;
 }
 
 }  // namespace gfx