Rename the remaining usage of Monitor to Display

ash/shell.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 "ash/shell.h"
 
 #include <algorithm>
 #include <string>
 
 #include "ash/accelerators/focus_manager_factory.h"
 #include "ash/ash_switches.h"
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_resources.h"
 #include "ash/desktop_background/desktop_background_view.h"
 #include "ash/drag_drop/drag_drop_controller.h"
 #include "ash/focus_cycler.h"
 #include "ash/high_contrast/high_contrast_controller.h"
 #include "ash/launcher/launcher.h"
 #include "ash/magnifier/magnification_controller.h"
-#include "ash/monitor/monitor_controller.h"
-#include "ash/monitor/mouse_cursor_event_filter.h"
-#include "ash/monitor/multi_monitor_manager.h"
-#include "ash/monitor/secondary_monitor_view.h"
+#include "ash/display/display_controller.h"
+#include "ash/display/mouse_cursor_event_filter.h"
+#include "ash/display/multi_display_manager.h"
+#include "ash/display/secondary_display_view.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell_context_menu.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_factory.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/tooltips/tooltip_controller.h"
 #include "ash/touch/touch_observer_hud.h"
@@ skipping 32 matching lines @@
 #include "ash/wm/workspace_controller.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "grit/ui_resources.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/user_action_client.h"
 #include "ui/aura/cursor_manager.h"
 #include "ui/aura/env.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/layout_manager.h"
-#include "ui/aura/monitor_manager.h"
+#include "ui/aura/display_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/shared/compound_event_filter.h"
 #include "ui/aura/shared/input_method_event_filter.h"
 #include "ui/aura/ui_controls_aura.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size.h"
 #include "ui/ui_controls/ui_controls.h"
 #include "ui/views/focus/focus_manager_factory.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget.h"
 
 #if !defined(OS_MACOSX)
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_filter.h"
 #include "ash/accelerators/nested_dispatcher_controller.h"
 #endif
 
 #if defined(OS_CHROMEOS)
-#include "chromeos/monitor/output_configurator.h"
+#include "chromeos/display/output_configurator.h"
 #include "ui/aura/dispatcher_linux.h"
 #endif  // defined(OS_CHROMEOS)
 
 namespace ash {
 
 namespace {
 
 using aura::Window;
 using views::Widget;
 
@@ skipping 105 matching lines @@
   // The status area needs to be shut down before the windows are destroyed.
   status_area_widget_->Shutdown();
 
   // AppList needs to be released before shelf layout manager, which is
   // destroyed with launcher container in the loop below. However, app list
   // container is now on top of launcher container and released after it.
   // TODO(xiyuan): Move it back when app list container is no longer needed.
   app_list_controller_.reset();
 
   // Destroy all child windows including widgets.
-  monitor_controller_->CloseChildWindows();
+  display_controller_->CloseChildWindows();
 
   // These need a valid Shell instance to clean up properly, so explicitly
   // delete them before invalidating the instance.
   // Alphabetical.
   drag_drop_controller_.reset();
   magnification_controller_.reset();
   power_button_controller_.reset();
   resize_shadow_controller_.reset();
   shadow_controller_.reset();
   tooltip_controller_.reset();
   window_cycle_controller_.reset();
   capture_controller_.reset();
   nested_dispatcher_controller_.reset();
   user_action_client_.reset();
   visibility_controller_.reset();
 
   // This also deletes all RootWindows.
-  monitor_controller_.reset();
+  display_controller_.reset();
 
   // Launcher widget has a InputMethodBridge that references to
   // input_method_filter_'s input_method_. So explicitly release launcher_
   // before input_method_filter_. And this needs to be after we delete all
   // containers in case there are still live browser windows which access
   // LauncherModel during close.
   launcher_.reset();
 
   // Delete the activation controller after other controllers and launcher
   // because they might have registered ActivationChangeObserver.
   activation_controller_.reset();
 
   DCHECK(instance_ == this);
   instance_ = NULL;
 
 #if defined(OS_CHROMEOS)
   // Remove OutputConfigurator from Dispatcher.
   static_cast<aura::DispatcherLinux*>(
       aura::Env::GetInstance()->GetDispatcher())->RemoveDispatcherForRootWindow(
           output_configurator());
 #endif  // defined(OS_CHROMEOS)
 }
 
 // static
 Shell* Shell::CreateInstance(ShellDelegate* delegate) {
   CHECK(!instance_);
-  aura::Env::GetInstance()->SetMonitorManager(
-      new internal::MultiMonitorManager());
+  aura::Env::GetInstance()->SetDisplayManager(
+      new internal::MultiDisplayManager());
   instance_ = new Shell(delegate);
   instance_->Init();
   return instance_;
 }
 
 // static
 Shell* Shell::GetInstance() {
   DCHECK(instance_);
   return instance_;
 }
 
 // static
 bool Shell::HasInstance() {
   return !!instance_;
 }
 
 // static
 void Shell::DeleteInstance() {
   delete instance_;
   instance_ = NULL;
 }
 
 // static
 internal::RootWindowController* Shell::GetPrimaryRootWindowController() {
   return wm::GetRootWindowController(GetPrimaryRootWindow());
 }
 
 // static
 Shell::RootWindowControllerList Shell::GetAllRootWindowControllers() {
-  return Shell::GetInstance()->monitor_controller()->
+  return Shell::GetInstance()->display_controller()->
       GetAllRootWindowControllers();
 }
 
 // static
 aura::RootWindow* Shell::GetPrimaryRootWindow() {
-  return GetInstance()->monitor_controller()->GetPrimaryRootWindow();
+  return GetInstance()->display_controller()->GetPrimaryRootWindow();
 }
 
 // static
 aura::RootWindow* Shell::GetActiveRootWindow() {
   return GetInstance()->active_root_window_;
 }
 
 // static
 aura::RootWindow* Shell::GetRootWindowAt(const gfx::Point& point) {
-  if (!internal::MonitorController::IsVirtualScreenCoordinatesEnabled())
+  if (!internal::DisplayController::IsVirtualScreenCoordinatesEnabled())
     return GetPrimaryRootWindow();
   RootWindowList root_windows = GetAllRootWindows();
   for (RootWindowList::const_iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     aura::RootWindow* root_window = *iter;
     if (root_window->bounds().Contains(point))
       return root_window;
   }
   // Fallback to the primary window if there is no root window containing
   // the |point|.
   return GetPrimaryRootWindow();
 }
 
 // static
 aura::RootWindow* Shell::GetRootWindowMatching(const gfx::Rect& rect) {
-  if (!internal::MonitorController::IsVirtualScreenCoordinatesEnabled())
+  if (!internal::DisplayController::IsVirtualScreenCoordinatesEnabled())
     return GetPrimaryRootWindow();
   if (rect.IsEmpty())
     return GetRootWindowAt(rect.origin());
   RootWindowList root_windows = GetAllRootWindows();
   int max = 0;
   aura::RootWindow* matching = NULL;
   for (RootWindowList::const_iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     aura::RootWindow* root_window = *iter;
     gfx::Rect intersect = root_window->bounds().Intersect(rect);
     int area = intersect.width() * intersect.height();
     if (area > max) {
       max = area;
       matching = root_window;
     }
   }
   // Fallback to the primary window if there is no matching root window.
   return matching ? matching : GetPrimaryRootWindow();
 }
 
 // static
 Shell::RootWindowList Shell::GetAllRootWindows() {
-  return Shell::GetInstance()->monitor_controller()->
+  return Shell::GetInstance()->display_controller()->
       GetAllRootWindows();
 }
 
 // static
 aura::Window* Shell::GetContainer(aura::RootWindow* root_window,
                                   int container_id) {
   return root_window->GetChildById(container_id);
 }
 
 // static
@@ skipping 15 matching lines @@
   // Pass ownership of the filter to the Env.
   aura::Env::GetInstance()->SetEventFilter(env_filter_);
 
   aura::Env::GetInstance()->cursor_manager()->set_delegate(this);
 
 
   focus_manager_.reset(new aura::FocusManager);
   activation_controller_.reset(
       new internal::ActivationController(focus_manager_.get()));
 
-  monitor_controller_.reset(new internal::MonitorController);
-  monitor_controller_->InitPrimaryDisplay();
-  aura::RootWindow* root_window = monitor_controller_->GetPrimaryRootWindow();
+  display_controller_.reset(new internal::DisplayController);
+  display_controller_->InitPrimaryDisplay();
+  aura::RootWindow* root_window = display_controller_->GetPrimaryRootWindow();
   active_root_window_ = root_window;
 
 #if !defined(OS_MACOSX)
   nested_dispatcher_controller_.reset(new NestedDispatcherController);
   accelerator_controller_.reset(new AcceleratorController);
 #endif
   shell_context_menu_.reset(new internal::ShellContextMenu);
 
   // The order in which event filters are added is significant.
   DCHECK(!GetEnvEventFilterCount());
@@ skipping 44 matching lines @@
   visibility_controller_.reset(new internal::VisibilityController);
   drag_drop_controller_.reset(new internal::DragDropController);
   if (delegate_.get())
     user_action_client_.reset(delegate_->CreateUserActionClient());
   window_modality_controller_.reset(new internal::WindowModalityController);
   AddEnvEventFilter(window_modality_controller_.get());
 
   magnification_controller_.reset(
       internal::MagnificationController::CreateInstance());
 
-  if (internal::MonitorController::IsExtendedDesktopEnabled()) {
+  if (internal::DisplayController::IsExtendedDesktopEnabled()) {
     mouse_cursor_filter_.reset(
-        new internal::MouseCursorEventFilter(monitor_controller_.get()));
+        new internal::MouseCursorEventFilter(display_controller_.get()));
     AddEnvEventFilter(mouse_cursor_filter_.get());
   }
 
   high_contrast_controller_.reset(new HighContrastController);
   video_detector_.reset(new VideoDetector);
   window_cycle_controller_.reset(new WindowCycleController);
 
   InitRootWindowController(root_window_controller);
 
   // Initialize Primary RootWindow specific items.
@@ skipping 31 matching lines @@
   // Force Layout
   root_window_controller->root_window_layout()->OnWindowResized();
 
   // It needs to be created after OnWindowResized has been called, otherwise the
   // widget will not paint when restoring after a browser crash.
   user_wallpaper_delegate_->InitializeWallpaper();
 
   power_button_controller_.reset(new PowerButtonController);
   AddShellObserver(power_button_controller_.get());
 
-  monitor_controller_->InitSecondaryDisplays();
+  display_controller_->InitSecondaryDisplays();
 
   if (initially_hide_cursor_)
     aura::Env::GetInstance()->cursor_manager()->ShowCursor(false);
 }
 
 void Shell::AddEnvEventFilter(aura::EventFilter* filter) {
   env_filter_->AddFilter(filter);
 }
 
 void Shell::RemoveEnvEventFilter(aura::EventFilter* filter) {
@@ skipping 48 matching lines @@
   frame_view->Init(widget);
   return frame_view;
 }
 
 void Shell::RotateFocus(Direction direction) {
   focus_cycler_->RotateFocus(
       direction == FORWARD ? internal::FocusCycler::FORWARD :
                              internal::FocusCycler::BACKWARD);
 }
 
-void Shell::SetMonitorWorkAreaInsets(Window* contains,
+void Shell::SetDisplayWorkAreaInsets(Window* contains,
                                      const gfx::Insets& insets) {
-  internal::MultiMonitorManager* monitor_manager =
-      static_cast<internal::MultiMonitorManager*>(
-          aura::Env::GetInstance()->monitor_manager());
-  if (!monitor_manager->UpdateWorkAreaOfMonitorNearestWindow(contains, insets))
+  internal::MultiDisplayManager* display_manager =
+      static_cast<internal::MultiDisplayManager*>(
+          aura::Env::GetInstance()->display_manager());
+  if (!display_manager->UpdateWorkAreaOfDisplayNearestWindow(contains, insets))
     return;
   FOR_EACH_OBSERVER(ShellObserver, observers_,
-                    OnMonitorWorkAreaInsetsChanged());
+                    OnDisplayWorkAreaInsetsChanged());
 }
 
 void Shell::OnLoginStateChanged(user::LoginStatus status) {
   FOR_EACH_OBSERVER(ShellObserver, observers_, OnLoginStateChanged(status));
 }
 
 void Shell::OnAppTerminating() {
   FOR_EACH_OBSERVER(ShellObserver, observers_, OnAppTerminating());
 }
 
@@ skipping 62 matching lines @@
 
 SystemTray* Shell::system_tray() {
   return status_area_widget_->system_tray();
 }
 
 int Shell::GetGridSize() const {
   return GetPrimaryRootWindowController()->workspace_controller()->
       workspace_manager()->grid_size();
 }
 
-void Shell::InitRootWindowForSecondaryMonitor(aura::RootWindow* root) {
+void Shell::InitRootWindowForSecondaryDisplay(aura::RootWindow* root) {
   root->set_focus_manager(focus_manager_.get());
-  if (internal::MonitorController::IsExtendedDesktopEnabled()) {
+  if (internal::DisplayController::IsExtendedDesktopEnabled()) {
     internal::RootWindowController* controller =
         new internal::RootWindowController(root);
     controller->CreateContainers();
     InitRootWindowController(controller);
     controller->root_window_layout()->OnWindowResized();
     desktop_background_controller_->OnRootWindowAdded(root);
     root->ShowRootWindow();
     // Activate new root for testing.
     active_root_window_ = root;
   } else {
     root->SetFocusWhenShown(false);
     root->SetLayoutManager(new internal::RootWindowLayoutManager(root));
     aura::Window* container = new aura::Window(NULL);
-    container->SetName("SecondaryMonitorContainer");
+    container->SetName("SecondaryDisplayContainer");
     container->Init(ui::LAYER_NOT_DRAWN);
     root->AddChild(container);
     container->SetLayoutManager(new internal::BaseLayoutManager(root));
-    CreateSecondaryMonitorWidget(container);
+    CreateSecondaryDisplayWidget(container);
     container->Show();
     root->layout_manager()->OnWindowResized();
     root->ShowRootWindow();
     aura::client::SetCaptureClient(root, capture_controller_.get());
   }
 }
 
 void Shell::InitRootWindowController(
     internal::RootWindowController* controller) {
   aura::RootWindow* root_window = controller->root_window();
@@ skipping 75 matching lines @@
 }
 
 void Shell::ShowCursor(bool visible) {
   RootWindowList root_windows = GetAllRootWindows();
   for (RootWindowList::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter)
     (*iter)->ShowCursor(visible);
 }
 
 }  // namespace ash