Move DisplayManager and DisplayChangeObserverX11 from aura to ash.

ash/display/display_manager.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/display/multi_display_manager.h"
+#include "ash/display/display_manager.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/display/display_controller.h"
+#include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "base/string_split.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "grit/ash_strings.h"
 #include "ui/aura/aura_switches.h"
 #include "ui/aura/client/screen_position_client.h"
+#include "ui/aura/display_util.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size_conversions.h"
 
@@ skipping 42 matching lines @@
 }  // namespace
 
 using aura::RootWindow;
 using aura::Window;
 using std::string;
 using std::vector;
 
 DEFINE_WINDOW_PROPERTY_KEY(int64, kDisplayIdKey,
                            gfx::Display::kInvalidDisplayID);
 
-MultiDisplayManager::MultiDisplayManager() :
+DisplayManager::DisplayManager() :
     internal_display_id_(gfx::Display::kInvalidDisplayID),
     force_bounds_changed_(false) {
   Init();
 }
 
-MultiDisplayManager::~MultiDisplayManager() {
+DisplayManager::~DisplayManager() {
 }
 
 // static
-void MultiDisplayManager::CycleDisplay() {
-  MultiDisplayManager* manager = static_cast<MultiDisplayManager*>(
-      aura::Env::GetInstance()->display_manager());
-  manager->CycleDisplayImpl();
+void DisplayManager::CycleDisplay() {
+  Shell::GetInstance()->display_manager()->CycleDisplayImpl();
 }
 
 // static
-void MultiDisplayManager::ToggleDisplayScale() {
-  MultiDisplayManager* manager = static_cast<MultiDisplayManager*>(
-      aura::Env::GetInstance()->display_manager());
-  manager->ScaleDisplayImpl();
+void DisplayManager::ToggleDisplayScale() {
+  Shell::GetInstance()->display_manager()->ScaleDisplayImpl();
 }
 
-bool MultiDisplayManager::IsActiveDisplay(const gfx::Display& display) const {
+bool DisplayManager::IsActiveDisplay(const gfx::Display& display) const {
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     if ((*iter).id() == display.id())
       return true;
   }
   return false;
 }
 
-bool MultiDisplayManager::HasInternalDisplay() const {
+bool DisplayManager::HasInternalDisplay() const {
   return internal_display_id_ != gfx::Display::kInvalidDisplayID;
 }
 
-bool MultiDisplayManager::IsInternalDisplayId(int64 id) const {
+bool DisplayManager::IsInternalDisplayId(int64 id) const {
   return internal_display_id_ == id;
 }
 
-bool MultiDisplayManager::UpdateWorkAreaOfDisplayNearestWindow(
+bool DisplayManager::UpdateWorkAreaOfDisplayNearestWindow(
     const aura::Window* window,
     const gfx::Insets& insets) {
   const RootWindow* root = window->GetRootWindow();
   gfx::Display& display = FindDisplayForRootWindow(root);
   gfx::Rect old_work_area = display.work_area();
   display.UpdateWorkAreaFromInsets(insets);
   return old_work_area != display.work_area();
 }
 
-const gfx::Display& MultiDisplayManager::GetDisplayForId(int64 id) const {
-  return const_cast<MultiDisplayManager*>(this)->FindDisplayForId(id);
+const gfx::Display& DisplayManager::GetDisplayForId(int64 id) const {
+  return const_cast<DisplayManager*>(this)->FindDisplayForId(id);
 }
 
-const gfx::Display& MultiDisplayManager::FindDisplayContainingPoint(
+const gfx::Display& DisplayManager::FindDisplayContainingPoint(
     const gfx::Point& point_in_screen) const {
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     const gfx::Display& display = *iter;
     if (display.bounds().Contains(point_in_screen))
       return display;
   }
   return GetInvalidDisplay();
 }
 
-void MultiDisplayManager::SetOverscanInsets(int64 display_id,
-                                            const gfx::Insets& insets_in_dip) {
+void DisplayManager::SetOverscanInsets(int64 display_id,
+                                       const gfx::Insets& insets_in_dip) {
   DisplayList displays = displays_;
   std::map<int64, gfx::Insets>::const_iterator old_overscan =
       overscan_mapping_.find(display_id);
   if (old_overscan != overscan_mapping_.end()) {
     gfx::Insets old_insets = old_overscan->second;
     for (DisplayList::iterator iter = displays.begin();
          iter != displays.end(); ++iter) {
       if (iter->id() == display_id) {
         // Undo the existing insets before applying the new insets.
         gfx::Rect bounds = iter->bounds_in_pixel();
         bounds.Inset(old_insets.Scale(-iter->device_scale_factor()));
         iter->SetScaleAndBounds(iter->device_scale_factor(), bounds);
         break;
       }
     }
   }
   overscan_mapping_[display_id] = insets_in_dip;
   OnNativeDisplaysChanged(displays);
 }
 
-gfx::Insets MultiDisplayManager::GetOverscanInsets(int64 display_id) const {
+gfx::Insets DisplayManager::GetOverscanInsets(int64 display_id) const {
   std::map<int64, gfx::Insets>::const_iterator it =
       overscan_mapping_.find(display_id);
   return (it != overscan_mapping_.end()) ? it->second : gfx::Insets();
 }
 
-void MultiDisplayManager::OnNativeDisplaysChanged(
+void DisplayManager::OnNativeDisplaysChanged(
     const std::vector<gfx::Display>& updated_displays) {
   if (updated_displays.empty()) {
     // Don't update the displays when all displays are disconnected.
     // This happens when:
     // - the device is idle and powerd requested to turn off all displays.
     // - the device is suspended. (kernel turns off all displays)
     // - the internal display's brightness is set to 0 and no external
     //   display is connected.
     // - the internal display's brightness is 0 and external display is
     //   disconnected.
@@ skipping 98 matching lines @@
 
   displays_ = new_displays;
   RefreshDisplayNames();
 
   // Temporarily add displays to be removed because display object
   // being removed are accessed during shutting down the root.
   displays_.insert(displays_.end(), removed_displays.begin(),
                    removed_displays.end());
   for (std::vector<size_t>::iterator iter = changed_display_indices.begin();
        iter != changed_display_indices.end(); ++iter) {
-    NotifyBoundsChanged(displays_[*iter]);
+    Shell::GetInstance()->screen()->NotifyBoundsChanged(displays_[*iter]);
   }
   for (std::vector<size_t>::iterator iter = added_display_indices.begin();
        iter != added_display_indices.end(); ++iter) {
-    NotifyDisplayAdded(displays_[*iter]);
+    Shell::GetInstance()->screen()->NotifyDisplayAdded(displays_[*iter]);
   }
-
   for (DisplayList::const_reverse_iterator iter = removed_displays.rbegin();
        iter != removed_displays.rend(); ++iter) {
-    NotifyDisplayRemoved(displays_.back());
+    Shell::GetInstance()->screen()->NotifyDisplayRemoved(displays_.back());
     displays_.pop_back();
   }
   EnsurePointerInDisplays();
 }
 
-RootWindow* MultiDisplayManager::CreateRootWindowForDisplay(
+RootWindow* DisplayManager::CreateRootWindowForDisplay(
     const gfx::Display& display) {
-
   RootWindow::CreateParams params(display.bounds_in_pixel());
 #if defined(OS_WIN)
   if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
     params.host = aura::RemoteRootWindowHostWin::Create(
         display.bounds_in_pixel());
   }
 #endif
   aura::RootWindow* root_window = new aura::RootWindow(params);
   // No need to remove RootWindowObserver because
   // the DisplayManager object outlives RootWindow objects.
   root_window->AddRootWindowObserver(this);
   root_window->SetProperty(kDisplayIdKey, display.id());
   root_window->Init();
   return root_window;
 }
 
-gfx::Display* MultiDisplayManager::GetDisplayAt(size_t index) {
+gfx::Display* DisplayManager::GetDisplayAt(size_t index) {
   return index < displays_.size() ? &displays_[index] : NULL;
 }
 
-size_t MultiDisplayManager::GetNumDisplays() const {
+size_t DisplayManager::GetNumDisplays() const {
   return displays_.size();
 }
 
-const gfx::Display& MultiDisplayManager::GetDisplayNearestWindow(
+const gfx::Display& DisplayManager::GetDisplayNearestWindow(
     const Window* window) const {
   if (!window)
     return DisplayController::GetPrimaryDisplay();
   const RootWindow* root = window->GetRootWindow();
-  MultiDisplayManager* manager = const_cast<MultiDisplayManager*>(this);
+  DisplayManager* manager = const_cast<DisplayManager*>(this);
   return root ?
       manager->FindDisplayForRootWindow(root) :
       DisplayController::GetPrimaryDisplay();
 }
 
-const gfx::Display& MultiDisplayManager::GetDisplayNearestPoint(
+const gfx::Display& DisplayManager::GetDisplayNearestPoint(
     const gfx::Point& point) const {
   // Fallback to the primary display if there is no root display containing
   // the |point|.
   const gfx::Display& display = FindDisplayContainingPoint(point);
   return display.is_valid() ? display : DisplayController::GetPrimaryDisplay();
 }
 
-const gfx::Display& MultiDisplayManager::GetDisplayMatching(
+const gfx::Display& DisplayManager::GetDisplayMatching(
     const gfx::Rect& rect) const {
   if (rect.IsEmpty())
     return GetDisplayNearestPoint(rect.origin());
 
   int max = 0;
   const gfx::Display* matching = 0;
   for (std::vector<gfx::Display>::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     const gfx::Display& display = *iter;
     gfx::Rect intersect = gfx::IntersectRects(display.bounds(), rect);
     int area = intersect.width() * intersect.height();
     if (area > max) {
       max = area;
       matching = &(*iter);
     }
   }
   // Fallback to the primary display if there is no matching display.
   return matching ? *matching : DisplayController::GetPrimaryDisplay();
 }
 
-std::string MultiDisplayManager::GetDisplayNameFor(
+std::string DisplayManager::GetDisplayNameFor(
     const gfx::Display& display) {
   if (!display.is_valid())
     return l10n_util::GetStringUTF8(IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
 
   std::map<int64, std::string>::const_iterator iter =
       display_names_.find(display.id());
   if (iter != display_names_.end())
     return iter->second;
 
   return base::StringPrintf("Display %d", static_cast<int>(display.id()));
 }
 
-void MultiDisplayManager::OnRootWindowResized(const aura::RootWindow* root,
-                                              const gfx::Size& old_size) {
-  if (!use_fullscreen_host_window()) {
+void DisplayManager::OnRootWindowResized(const aura::RootWindow* root,
+                                         const gfx::Size& old_size) {
+  if (!aura::UseFullscreenHostWindow()) {
     gfx::Display& display = FindDisplayForRootWindow(root);
     if (display.size() != root->GetHostSize()) {
       display.SetSize(root->GetHostSize());
-      NotifyBoundsChanged(display);
+      Shell::GetInstance()->screen()->NotifyBoundsChanged(display);
     }
   }
 }
 
-void MultiDisplayManager::Init() {
+void DisplayManager::Init() {
 #if defined(OS_CHROMEOS)
   if (base::chromeos::IsRunningOnChromeOS()) {
     std::vector<XID> outputs;
     ui::GetOutputDeviceHandles(&outputs);
     std::vector<std::string> output_names = ui::GetOutputNames(outputs);
     for (size_t i = 0; i < output_names.size(); ++i) {
       if (chromeos::OutputConfigurator::IsInternalOutputName(
               output_names[i])) {
         internal_display_id_ = GetDisplayIdForOutput(outputs[i]);
         break;
       }
     }
   }
 #endif
 
   RefreshDisplayNames();
 
 #if defined(OS_WIN)
   if (base::win::GetVersion() >= base::win::VERSION_WIN8)
-    set_use_fullscreen_host_window(true);
+    aura::SetUseFullscreenHostWindow(true);
 #endif
   // TODO(oshima): Move this logic to DisplayChangeObserver.
   const string size_str = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kAuraHostWindowSize);
   vector<string> parts;
   base::SplitString(size_str, ',', &parts);
   for (vector<string>::const_iterator iter = parts.begin();
        iter != parts.end(); ++iter) {
     AddDisplayFromSpec(*iter);
   }
   if (displays_.empty())
     AddDisplayFromSpec(std::string() /* default */);
 }
 
-void MultiDisplayManager::CycleDisplayImpl() {
+void DisplayManager::CycleDisplayImpl() {
   DCHECK(!displays_.empty());
   std::vector<gfx::Display> new_displays;
   new_displays.push_back(DisplayController::GetPrimaryDisplay());
   // Add if there is only one display.
   if (displays_.size() == 1)
-    new_displays.push_back(CreateDisplayFromSpec("100+200-500x400"));
+    new_displays.push_back(aura::CreateDisplayFromSpec("100+200-500x400"));
   OnNativeDisplaysChanged(new_displays);
 }
 
-void MultiDisplayManager::ScaleDisplayImpl() {
+void DisplayManager::ScaleDisplayImpl() {
   DCHECK(!displays_.empty());
   std::vector<gfx::Display> new_displays;
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     gfx::Display display = *iter;
     float factor = display.device_scale_factor() == 1.0f ? 2.0f : 1.0f;
     display.SetScaleAndBounds(
         factor, gfx::Rect(display.bounds_in_pixel().origin(),
                           gfx::ToFlooredSize(display.size().Scale(factor))));
     new_displays.push_back(display);
   }
   OnNativeDisplaysChanged(new_displays);
 }
 
-gfx::Display& MultiDisplayManager::FindDisplayForRootWindow(
+gfx::Display& DisplayManager::FindDisplayForRootWindow(
     const aura::RootWindow* root_window) {
   int64 id = root_window->GetProperty(kDisplayIdKey);
   // if id is |kInvaildDisplayID|, it's being deleted.
   DCHECK(id != gfx::Display::kInvalidDisplayID);
   gfx::Display& display = FindDisplayForId(id);
   DCHECK(display.is_valid());
   return display;
 }
 
-gfx::Display& MultiDisplayManager::FindDisplayForId(int64 id) {
+gfx::Display& DisplayManager::FindDisplayForId(int64 id) {
   for (DisplayList::iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     if ((*iter).id() == id)
       return *iter;
   }
   DLOG(WARNING) << "Could not find display:" << id;
   return GetInvalidDisplay();
 }
 
-void MultiDisplayManager::AddDisplayFromSpec(const std::string& spec) {
-  gfx::Display display = CreateDisplayFromSpec(spec);
+void DisplayManager::AddDisplayFromSpec(const std::string& spec) {
+  gfx::Display display = aura::CreateDisplayFromSpec(spec);
 
   const gfx::Insets insets = display.GetWorkAreaInsets();
   const gfx::Rect& native_bounds = display.bounds_in_pixel();
   display.SetScaleAndBounds(display.device_scale_factor(), native_bounds);
   display.UpdateWorkAreaFromInsets(insets);
   displays_.push_back(display);
 }
 
-int64 MultiDisplayManager::SetFirstDisplayAsInternalDisplayForTest() {
+int64 DisplayManager::SetFirstDisplayAsInternalDisplayForTest() {
   internal_display_id_ = displays_[0].id();
   internal_display_.reset(new gfx::Display);
   *internal_display_ = displays_[0];
   return internal_display_id_;
 }
 
-void MultiDisplayManager::EnsurePointerInDisplays() {
+void DisplayManager::EnsurePointerInDisplays() {
   // Don't try to move the pointer during the boot/startup.
   if (!Shell::HasInstance())
     return;
   gfx::Point location_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
   gfx::Point target_location;
   int64 closest_distance_squared = -1;
 
   for (DisplayList::const_iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     const gfx::Rect& display_bounds = iter->bounds();
@@ skipping 17 matching lines @@
   }
 
   aura::RootWindow* root_window = Shell::GetPrimaryRootWindow();
   aura::client::ScreenPositionClient* client =
       aura::client::GetScreenPositionClient(root_window);
   client->ConvertPointFromScreen(root_window, &target_location);
 
   root_window->MoveCursorTo(target_location);
 }
 
-void MultiDisplayManager::RefreshDisplayNames() {
+void DisplayManager::RefreshDisplayNames() {
   display_names_.clear();
 
 #if defined(OS_CHROMEOS)
   if (!base::chromeos::IsRunningOnChromeOS())
     return;
 #endif
 
 #if defined(USE_X11)
   std::vector<XID> outputs;
   if (!ui::GetOutputDeviceHandles(&outputs))
@@ skipping 10 matching lines @@
         display_names_[id] =
             l10n_util::GetStringUTF8(IDS_ASH_INTERNAL_DISPLAY_NAME);
       } else {
         display_names_[id] = name;
       }
     }
   }
 #endif
 }
 
-void MultiDisplayManager::SetDisplayIdsForTest(DisplayList* to_update) const {
+void DisplayManager::SetDisplayIdsForTest(DisplayList* to_update) const {
   DisplayList::iterator iter_to_update = to_update->begin();
   DisplayList::const_iterator iter = displays_.begin();
   for (; iter != displays_.end() && iter_to_update != to_update->end();
        ++iter, ++iter_to_update) {
     (*iter_to_update).set_id((*iter).id());
   }
 }
 
 }  // namespace internal
 }  // namespace ash