Move DisplayManager and DisplayChangeObserverX11 from aura to ash.

ash/display/display_controller.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/display_controller.h"
 
 #include <algorithm>
 
 #include "ash/ash_switches.h"
-#include "ash/display/multi_display_manager.h"
+#include "ash/display/display_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/json/json_value_converter.h"
 #include "base/string_piece.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
@@ skipping 50 matching lines @@
     case DisplayLayout::BOTTOM:
       return std::string("bottom");
     case DisplayLayout::RIGHT:
       return std::string("right");
     case DisplayLayout::LEFT:
       return std::string("left");
   }
   return std::string("unknown");
 }
 
-internal::MultiDisplayManager* GetDisplayManager() {
-  return static_cast<internal::MultiDisplayManager*>(
-      aura::Env::GetInstance()->display_manager());
+internal::DisplayManager* GetDisplayManager() {
+  return Shell::GetInstance()->display_manager();
 }
 
 }  // namespace
 
 DisplayLayout::DisplayLayout()
     : position(RIGHT),
       offset(0) {}
 
 DisplayLayout::DisplayLayout(DisplayLayout::Position position, int offset)
     : position(position),
@@ skipping 60 matching lines @@
       "position", &DisplayLayout::position, &GetPositionFromString);
   converter->RegisterIntField("offset", &DisplayLayout::offset);
 }
 
 DisplayController::DisplayController()
     : desired_primary_display_id_(gfx::Display::kInvalidDisplayID) {
   // Reset primary display to make sure that tests don't use
   // stale display info from previous tests.
   primary_display_id = gfx::Display::kInvalidDisplayID;
 
-  GetDisplayManager()->AddObserver(this);
+  Shell::GetScreen()->AddObserver(this);
 }
 
 DisplayController::~DisplayController() {
-  GetDisplayManager()->RemoveObserver(this);
+  Shell::GetScreen()->RemoveObserver(this);
   // Delete all root window controllers, which deletes root window
   // from the last so that the primary root window gets deleted last.
   for (std::map<int64, aura::RootWindow*>::const_reverse_iterator it =
            root_windows_.rbegin(); it != root_windows_.rend(); ++it) {
     internal::RootWindowController* controller =
         GetRootWindowController(it->second);
     DCHECK(controller);
     delete controller;
   }
 }
 // static
 const gfx::Display& DisplayController::GetPrimaryDisplay() {
   DCHECK_NE(primary_display_id, gfx::Display::kInvalidDisplayID);
   return GetDisplayManager()->GetDisplayForId(primary_display_id);
 }
 
+// static
+bool DisplayController::HasPrimaryDisplay() {
+  return primary_display_id != gfx::Display::kInvalidDisplayID;
+}
+
 void DisplayController::InitPrimaryDisplay() {
   const gfx::Display* primary_candidate = GetDisplayManager()->GetDisplayAt(0);
 #if defined(OS_CHROMEOS)
   if (base::chromeos::IsRunningOnChromeOS()) {
-    internal::MultiDisplayManager* display_manager = GetDisplayManager();
+    internal::DisplayManager* display_manager = GetDisplayManager();
     // On ChromeOS device, root windows are stacked vertically, and
     // default primary is the one on top.
     int count = display_manager->GetNumDisplays();
     int y = primary_candidate->bounds_in_pixel().y();
     for (int i = 1; i < count; ++i) {
       const gfx::Display* display = display_manager->GetDisplayAt(i);
       if (display_manager->IsInternalDisplayId(display->id())) {
         primary_candidate = display;
         break;
       } else if (display->bounds_in_pixel().y() < y) {
         primary_candidate = display;
         y = display->bounds_in_pixel().y();
       }
     }
   }
 #endif
   primary_display_id = primary_candidate->id();
   aura::RootWindow* root = AddRootWindowForDisplay(*primary_candidate);
   root->SetHostBounds(primary_candidate->bounds_in_pixel());
   UpdateDisplayBoundsForLayout();
 }
 
 void DisplayController::InitSecondaryDisplays() {
-  internal::MultiDisplayManager* display_manager = GetDisplayManager();
+  internal::DisplayManager* display_manager = GetDisplayManager();
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     const gfx::Display* display = display_manager->GetDisplayAt(i);
     if (primary_display_id != display->id()) {
       aura::RootWindow* root = AddRootWindowForDisplay(*display);
       Shell::GetInstance()->InitRootWindowForSecondaryDisplay(root);
     }
   }
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAshSecondaryDisplayLayout)) {
     std::string value = command_line->GetSwitchValueASCII(
@@ skipping 119 matching lines @@
   // On release build, just fallback to default instead of blowing up.
   return default_display_layout_;
 }
 
 void DisplayController::SetPrimaryDisplayId(int64 id) {
   desired_primary_display_id_ = id;
 
   if (desired_primary_display_id_ == primary_display_id)
     return;
 
-  aura::DisplayManager* display_manager =
-      aura::Env::GetInstance()->display_manager();
+  internal::DisplayManager* display_manager = GetDisplayManager();
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     gfx::Display* display = display_manager->GetDisplayAt(i);
     if (display->id() == id) {
       SetPrimaryDisplay(*display);
       break;
     }
   }
 }
 
 void DisplayController::SetPrimaryDisplay(
     const gfx::Display& new_primary_display) {
-  internal::MultiDisplayManager* display_manager = GetDisplayManager();
+  internal::DisplayManager* display_manager = GetDisplayManager();
   DCHECK(new_primary_display.is_valid());
   DCHECK(display_manager->IsActiveDisplay(new_primary_display));
 
   if (!new_primary_display.is_valid() ||
       !display_manager->IsActiveDisplay(new_primary_display)) {
     LOG(ERROR) << "Invalid or non-existent display is requested:"
                << new_primary_display.ToString();
     return;
   }
 
@@ skipping 39 matching lines @@
   // Update the dispay manager with new display info.
   std::vector<gfx::Display> displays;
   displays.push_back(display_manager->GetDisplayForId(primary_display_id));
   displays.push_back(*GetSecondaryDisplay());
   GetDisplayManager()->set_force_bounds_changed(true);
   GetDisplayManager()->OnNativeDisplaysChanged(displays);
   GetDisplayManager()->set_force_bounds_changed(false);
 }
 
 gfx::Display* DisplayController::GetSecondaryDisplay() {
-  internal::MultiDisplayManager* display_manager = GetDisplayManager();
+  internal::DisplayManager* display_manager = GetDisplayManager();
   CHECK_EQ(2U, display_manager->GetNumDisplays());
   return display_manager->GetDisplayAt(0)->id() == primary_display_id ?
       display_manager->GetDisplayAt(1) : display_manager->GetDisplayAt(0);
 }
 
 void DisplayController::OnDisplayBoundsChanged(const gfx::Display& display) {
   NotifyDisplayConfigurationChanging();
   UpdateDisplayBoundsForLayout();
   root_windows_[display.id()]->SetHostBounds(display.bounds_in_pixel());
 }
@@ skipping 108 matching lines @@
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 void DisplayController::NotifyDisplayConfigurationChanging() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanging());
 }
 
 }  // namespace ash