Rename the remaining usage of Monitor to Display

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 <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ui/aura/aura_switches.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
-#include "ui/aura/monitor_manager.h"
+#include "ui/aura/display_manager.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/aura/root_window_observer.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/gestures/gesture_recognizer.h"
 #include "ui/base/gestures/gesture_types.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
@@ skipping 24 matching lines @@
 void GetEventFiltersToNotify(Window* target, EventFilters* filters) {
   while (target) {
     if (target->event_filter())
       filters->push_back(target->event_filter());
     target = target->parent();
   }
   if (Env::GetInstance()->event_filter())
     filters->push_back(Env::GetInstance()->event_filter());
 }
 
-float GetDeviceScaleFactorFromMonitor(const aura::Window* window) {
-  MonitorManager* monitor_manager = Env::GetInstance()->monitor_manager();
-  return monitor_manager->GetDisplayNearestWindow(window).device_scale_factor();
+float GetDeviceScaleFactorFromDisplay(const aura::Window* window) {
+  DisplayManager* display_manager = Env::GetInstance()->display_manager();
+  return display_manager->GetDisplayNearestWindow(window).device_scale_factor();
 }
 
 Window* ConsumerToWindow(ui::GestureConsumer* consumer) {
   return consumer && !consumer->ignores_events() ?
       static_cast<Window*>(consumer) : NULL;
 }
 
 }  // namespace
 
 CompositorLock::CompositorLock(RootWindow* root_window)
@@ skipping 67 matching lines @@
 }
 
 // static
 RootWindow* RootWindow::GetForAcceleratedWidget(
     gfx::AcceleratedWidget widget) {
   RootWindowHost* host = RootWindowHost::GetForAcceleratedWidget(widget);
   return host ? host->GetRootWindow() : NULL;
 }
 
 void RootWindow::Init() {
-  compositor()->SetScaleAndSize(GetDeviceScaleFactorFromMonitor(this),
+  compositor()->SetScaleAndSize(GetDeviceScaleFactorFromDisplay(this),
                                 host_->GetBounds().size());
   Window::Init(ui::LAYER_NOT_DRAWN);
   last_mouse_location_ =
       ui::ConvertPointToDIP(layer(), host_->QueryMouseLocation());
   compositor()->SetRootLayer(layer());
   SetBounds(
       ui::ConvertRectToDIP(layer(), gfx::Rect(host_->GetBounds().size())));
   Show();
   host_->SetRootWindow(this);
 }
@@ skipping 215 matching lines @@
     ui::GestureStatus status = ProcessGestureEvent(target, &translated_event);
     return status != ui::GESTURE_STATUS_UNKNOWN;
   }
 
   return false;
 }
 
 void RootWindow::OnHostResized(const gfx::Size& size_in_pixel) {
   DispatchHeldMouseMove();
   // The compositor should have the same size as the native root window host.
-  // Get the latest scale from monitor because it might have been changed.
-  compositor_->SetScaleAndSize(GetDeviceScaleFactorFromMonitor(this),
+  // Get the latest scale from display because it might have been changed.
+  compositor_->SetScaleAndSize(GetDeviceScaleFactorFromDisplay(this),
                                size_in_pixel);
   gfx::Size old(bounds().size());
   // The layer, and all the observers should be notified of the
   // transformed size of the root window.
   gfx::Rect bounds(ui::ConvertSizeToDIP(layer(), size_in_pixel));
   layer()->transform().TransformRect(&bounds);
   SetBounds(bounds);
   FOR_EACH_OBSERVER(RootWindowObserver, observers_,
                     OnRootWindowResized(this, old));
 }
@@ skipping 571 matching lines @@
 void RootWindow::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (draw_on_compositor_unlock_) {
     draw_on_compositor_unlock_ = false;
     ScheduleDraw();
   }
 }
 
 }  // namespace aura