Remove now-unnecessary wrappers around gfx::Screen::GetScreen()

ash/display/window_tree_host_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/window_tree_host_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 #include <utility>
@@ skipping 228 matching lines @@
       cursor_display_id_for_restore_(gfx::Display::kInvalidDisplayID),
       weak_ptr_factory_(this) {
   // Reset primary display to make sure that tests don't use
   // stale display info from previous tests.
   primary_display_id = gfx::Display::kInvalidDisplayID;
 }
 
 WindowTreeHostManager::~WindowTreeHostManager() {}
 
 void WindowTreeHostManager::Start() {
-  Shell::GetScreen()->AddObserver(this);
+  gfx::Screen::GetScreen()->AddObserver(this);
   Shell::GetInstance()->display_manager()->set_delegate(this);
 }
 
 void WindowTreeHostManager::Shutdown() {
   FOR_EACH_OBSERVER(Observer, observers_, OnWindowTreeHostManagerShutdown());
 
   // Unset the display manager's delegate here because
   // DisplayManager outlives WindowTreeHostManager.
   Shell::GetInstance()->display_manager()->set_delegate(nullptr);
 
   cursor_window_controller_.reset();
   mirror_window_controller_.reset();
 
-  Shell::GetScreen()->RemoveObserver(this);
+  gfx::Screen::GetScreen()->RemoveObserver(this);
 
-  int64_t primary_id = Shell::GetScreen()->GetPrimaryDisplay().id();
+  int64_t primary_id = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
 
   // Delete non primary root window controllers first, then
   // delete the primary root window controller.
   aura::Window::Windows root_windows =
       WindowTreeHostManager::GetAllRootWindows();
   std::vector<RootWindowController*> to_delete;
   RootWindowController* primary_rwc = nullptr;
   for (aura::Window::Windows::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     RootWindowController* rwc = GetRootWindowController(*iter);
@@ skipping 108 matching lines @@
        it != window_tree_hosts_.end(); ++it) {
     RootWindowController* controller =
         GetRootWindowController(GetWindow(it->second));
     if (controller)
       controllers.push_back(controller);
   }
   return controllers;
 }
 
 void WindowTreeHostManager::SwapPrimaryDisplayForTest() {
-  if (Shell::GetScreen()->GetNumDisplays() <= 1)
+  if (gfx::Screen::GetScreen()->GetNumDisplays() <= 1)
     return;
   SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
 }
 
 void WindowTreeHostManager::SetPrimaryDisplayId(int64_t id) {
   DCHECK_NE(gfx::Display::kInvalidDisplayID, id);
   if (id == gfx::Display::kInvalidDisplayID || primary_display_id == id)
     return;
 
   const gfx::Display& display = GetDisplayManager()->GetDisplayForId(id);
@@ skipping 20 matching lines @@
   }
 
   AshWindowTreeHost* non_primary_host =
       window_tree_hosts_[new_primary_display.id()];
   LOG_IF(ERROR, !non_primary_host)
       << "Unknown display is requested in SetPrimaryDisplay: id="
       << new_primary_display.id();
   if (!non_primary_host)
     return;
 
-  gfx::Display old_primary_display = Shell::GetScreen()->GetPrimaryDisplay();
+  gfx::Display old_primary_display =
+      gfx::Screen::GetScreen()->GetPrimaryDisplay();
 
   // Swap root windows between current and new primary display.
   AshWindowTreeHost* primary_host = window_tree_hosts_[primary_display_id];
   CHECK(primary_host);
   CHECK_NE(primary_host, non_primary_host);
 
   window_tree_hosts_[new_primary_display.id()] = primary_host;
   GetRootWindowSettings(GetWindow(primary_host))->display_id =
       new_primary_display.id();
 
@@ skipping 14 matching lines @@
   GetDisplayManager()->set_force_bounds_changed(true);
   GetDisplayManager()->UpdateDisplays();
   GetDisplayManager()->set_force_bounds_changed(false);
 }
 
 void WindowTreeHostManager::UpdateMouseLocationAfterDisplayChange() {
   // If the mouse is currently on a display in native location,
   // use the same native location. Otherwise find the display closest
   // to the current cursor location in screen coordinates.
 
-  gfx::Point point_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
+  gfx::Point point_in_screen = gfx::Screen::GetScreen()->GetCursorScreenPoint();
   gfx::Point target_location_in_native;
   int64_t closest_distance_squared = -1;
   DisplayManager* display_manager = GetDisplayManager();
 
   aura::Window* dst_root_window = nullptr;
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     const gfx::Display& display = display_manager->GetDisplayAt(i);
     const DisplayInfo display_info =
         display_manager->GetDisplayInfo(display.id());
     aura::Window* root_window = GetRootWindowForDisplayId(display.id());
@@ skipping 219 matching lines @@
     return;
   const DisplayInfo& display_info =
       GetDisplayManager()->GetDisplayInfo(display.id());
   DCHECK(!display_info.bounds_in_native().IsEmpty());
   AshWindowTreeHost* ash_host = window_tree_hosts_[display.id()];
   ash_host->AsWindowTreeHost()->SetBounds(display_info.bounds_in_native());
   SetDisplayPropertiesOnHost(ash_host, display);
 }
 
 void WindowTreeHostManager::OnHostResized(const aura::WindowTreeHost* host) {
-  gfx::Display display = Shell::GetScreen()->GetDisplayNearestWindow(
+  gfx::Display display = gfx::Screen::GetScreen()->GetDisplayNearestWindow(
       const_cast<aura::Window*>(host->window()));
 
   DisplayManager* display_manager = GetDisplayManager();
   if (display_manager->UpdateDisplayBounds(display.id(), host->GetBounds())) {
     mirror_window_controller_->UpdateWindow();
     cursor_window_controller_->UpdateContainer();
   }
 }
 
 void WindowTreeHostManager::CreateOrUpdateMirroringDisplay(
@@ skipping 13 matching lines @@
   // always on the desktop display (the visible cursor on the non-desktop
   // display is drawn through compositor mirroring). Therefore, it's unnecessary
   // to handle the cursor_window at all. See: http://crbug.com/412910
   if (!cursor_window_controller_->is_cursor_compositing_enabled())
     cursor_window_controller_->UpdateContainer();
 }
 
 void WindowTreeHostManager::PreDisplayConfigurationChange(bool clear_focus) {
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanging());
   focus_activation_store_->Store(clear_focus);
-  gfx::Screen* screen = Shell::GetScreen();
+  gfx::Screen* screen = gfx::Screen::GetScreen();
   gfx::Point point_in_screen = screen->GetCursorScreenPoint();
   cursor_location_in_screen_coords_for_restore_ = point_in_screen;
 
   gfx::Display display = screen->GetDisplayNearestPoint(point_in_screen);
   cursor_display_id_for_restore_ = display.id();
 
   gfx::Point point_in_native = point_in_screen;
   aura::Window* root_window = GetRootWindowForDisplayId(display.id());
   ::wm::ConvertPointFromScreen(root_window, &point_in_native);
   root_window->GetHost()->ConvertPointToNativeScreen(&point_in_native);
   cursor_location_in_native_coords_for_restore_ = point_in_native;
 }
 
 void WindowTreeHostManager::PostDisplayConfigurationChange() {
   focus_activation_store_->Restore();
 
   DisplayManager* display_manager = GetDisplayManager();
   DisplayLayoutStore* layout_store = display_manager->layout_store();
   if (display_manager->num_connected_displays() > 1) {
     DisplayIdPair pair = display_manager->GetCurrentDisplayIdPair();
     DisplayLayout layout = layout_store->GetRegisteredDisplayLayout(pair);
     layout_store->UpdateMultiDisplayState(
         pair, display_manager->IsInMirrorMode(), layout.default_unified);
 
-    if (Shell::GetScreen()->GetNumDisplays() > 1) {
+    if (gfx::Screen::GetScreen()->GetNumDisplays() > 1) {
       int64_t primary_id = layout.primary_id;
       SetPrimaryDisplayId(primary_id == gfx::Display::kInvalidDisplayID
                               ? pair.first
                               : primary_id);
       // Update the primary_id in case the above call is
       // ignored. Happens when a) default layout's primary id
       // doesn't exist, or b) the primary_id has already been
       // set to the same and didn't update it.
       layout_store->UpdatePrimaryDisplayId(
-          pair, Shell::GetScreen()->GetPrimaryDisplay().id());
+          pair, gfx::Screen::GetScreen()->GetPrimaryDisplay().id());
     }
   }
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanged());
   UpdateMouseLocationAfterDisplayChange();
 }
 
 ui::EventDispatchDetails WindowTreeHostManager::DispatchKeyEventPostIME(
     ui::KeyEvent* event) {
   // Getting the active root window to dispatch the event. This isn't
   // significant as the event will be sent to the window resolved by
@@ skipping 43 matching lines @@
   SetDisplayPropertiesOnHost(ash_host, display);
 
 #if defined(OS_CHROMEOS)
   if (switches::ConstrainPointerToRoot())
     ash_host->ConfineCursorToRootWindow();
 #endif
   return ash_host;
 }
 
 }  // namespace ash