MonitorManager to manage multiple monitors.

ui/aura/root_window.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 "ui/aura/root_window.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "ui/aura/aura_switches.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/env.h"
-#include "ui/aura/root_window_host.h"
-#include "ui/aura/root_window_observer.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/gestures/gesture_recognizer.h"
+#include "ui/aura/monitor.h"
+#include "ui/aura/monitor_manager.h"
+#include "ui/aura/root_window_host.h"
+#include "ui/aura/root_window_observer.h"
 #include "ui/aura/screen_aura.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/compositor/layer_animator.h"
 
 using std::string;
 using std::vector;
@@ skipping 49 matching lines @@
 // RootWindow, public:
 
 RootWindow::RootWindow()
     : Window(NULL),
       host_(aura::RootWindowHost::Create(GetInitialHostWindowBounds())),
       ALLOW_THIS_IN_INITIALIZER_LIST(schedule_paint_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(event_factory_(this)),
       mouse_button_flags_(0),
       last_cursor_(kCursorNull),
       cursor_shown_(true),
-      ALLOW_THIS_IN_INITIALIZER_LIST(screen_(new ScreenAura(this))),
       capture_window_(NULL),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       focused_window_(NULL),
       touch_event_handler_(NULL),
       gesture_handler_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           gesture_recognizer_(GestureRecognizer::Create(this))),
       synthesize_mouse_move_(false),
       waiting_on_compositing_end_(false),
       draw_on_compositing_end_(false) {
   SetName("RootWindow");
-  gfx::Screen::SetInstance(screen_);
+
+  gfx::Screen::SetInstance(new ScreenAura(this));
+
   last_mouse_location_ = host_->QueryMouseLocation();
 
   ui::Compositor::Initialize(false);
   compositor_.reset(new ui::Compositor(this, host_->GetAcceleratedWidget(),
       host_->GetSize()));
   DCHECK(compositor_.get());
   compositor_->AddObserver(this);
   Init();
 }
 
@@ skipping 23 matching lines @@
   last_mouse_location_ = host_->QueryMouseLocation();
   synthesize_mouse_move_ = false;
 }
 
 gfx::Size RootWindow::GetHostSize() const {
   gfx::Rect rect(host_->GetSize());
   layer()->transform().TransformRect(&rect);
   return rect.size();
 }
 
-void RootWindow::SetScreenWorkAreaInsets(const gfx::Insets& insets) {
-  if (screen_->work_area_insets() == insets)
+void RootWindow::SetMonitorWorkAreaInsets(const gfx::Insets& insets) {
+  Monitor* monitor = Env::GetInstance()->monitor_manager()->
+      GetMonitorNearestWindow(this);
+  if (monitor->work_area_insets() == insets)
     return;
-  screen_->set_work_area_insets(insets);
+  monitor->set_work_area_insets(insets);
   FOR_EACH_OBSERVER(RootWindowObserver, observers_,
-                    OnScreenWorkAreaInsetsChanged());
+                    OnMonitorWorkAreaInsetsChanged());
 }
 
 void RootWindow::SetCursor(gfx::NativeCursor cursor) {
   last_cursor_ = cursor;
   // A lot of code seems to depend on NULL cursors actually showing an arrow,
   // so just pass everything along to the host.
   host_->SetCursor(cursor);
 }
 
 void RootWindow::ShowCursor(bool show) {
@@ skipping 614 matching lines @@
 bool RootWindow::IsFocusedWindow(const Window* window) const {
   return focused_window_ == window;
 }
 
 void RootWindow::Init() {
   Window::Init(ui::Layer::LAYER_NOT_DRAWN);
   SetBounds(gfx::Rect(host_->GetSize()));
   Show();
   compositor()->SetRootLayer(layer());
   host_->SetRootWindow(this);
+  // MonitorManager needs to access the root's bounds, so initialize after
+  // layer is created.
+  aura::Env::GetInstance()->SetMonitorManager(
+      aura::CreateSingleMonitorManager(this));
 }
 
 gfx::Rect RootWindow::GetInitialHostWindowBounds() const {
   gfx::Rect bounds(kDefaultHostWindowX, kDefaultHostWindowY,
                    kDefaultHostWindowWidth, kDefaultHostWindowHeight);
 
   const string size_str = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kAuraHostWindowSize);
   vector<string> parts;
   base::SplitString(size_str, 'x', &parts);
@@ skipping 32 matching lines @@
   // is currently broken. See/ crbug.com/107931.
   MouseEvent event(ui::ET_MOUSE_MOVED,
                    orig_mouse_location,
                    orig_mouse_location,
                    ui::EF_IS_SYNTHESIZED);
   DispatchMouseEvent(&event);
 #endif
 }
 
 }  // namespace aura