[Cleanup] Screen cleanup

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/display_manager.h"
 
 #include <cmath>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_layout_store.h"
-#include "ash/screen_ash.h"
+#include "ash/display/screen_ash.h"
+#include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "grit/ash_strings.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 16 matching lines @@
 #include "base/win/windows_version.h"
 #endif
 
 namespace ash {
 namespace internal {
 typedef std::vector<gfx::Display> DisplayList;
 typedef std::vector<DisplayInfo> DisplayInfoList;
 
 namespace {
 
+// We need to keep this in order for unittests to tell if
+// the object in gfx::Screen::GetScreenByType is for shutdown.
+gfx::Screen* screen_for_shutdown = NULL;
+
 // The number of pixels to overlap between the primary and secondary displays,
 // in case that the offset value is too large.
 const int kMinimumOverlapForInvalidOffset = 100;
 
 // List of value UI Scale values. Scales for 2x are equivalent to 640,
 // 800, 1024, 1280, 1440, 1600 and 1920 pixel width respectively on
 // 2560 pixel width 2x density display. Please see crbug.com/233375
 // for the full list of resolutions.
 const float kUIScalesFor2x[] =
     {0.5f, 0.625f, 0.8f, 1.0f, 1.125f, 1.25f, 1.5f, 2.0f};
@@ skipping 75 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(NonDesktopDisplayUpdater);
 };
 
 }  // namespace
 
 using std::string;
 using std::vector;
 
 DisplayManager::DisplayManager()
     : delegate_(NULL),
+      screen_ash_(new ScreenAsh),
+      screen_(screen_ash_.get()),
       layout_store_(new DisplayLayoutStore),
       first_display_id_(gfx::Display::kInvalidDisplayID),
       num_connected_displays_(0),
       force_bounds_changed_(false),
       change_display_upon_host_resize_(false),
       second_display_mode_(EXTENDED),
       mirrored_display_id_(gfx::Display::kInvalidDisplayID) {
 #if defined(OS_CHROMEOS)
   change_display_upon_host_resize_ = !base::SysInfo::IsRunningOnChromeOS();
 #endif
+  gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_ALTERNATE,
+                                 screen_ash_.get());
+  if (gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_NATIVE) ==
+      screen_for_shutdown) {
+    gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE,
+                                   screen_ash_.get());
+  }
 }
 
 DisplayManager::~DisplayManager() {
 }
 
 // static
 std::vector<float> DisplayManager::GetScalesForDisplay(
     const DisplayInfo& info) {
   std::vector<float> ret;
   if (info.device_scale_factor() == 2.0f) {
@@ skipping 129 matching lines @@
       return std::make_pair(displays_[1].id(), id_at_zero);
     }
   }
 }
 
 void DisplayManager::SetLayoutForCurrentDisplays(
     const DisplayLayout& layout_relative_to_primary) {
   DCHECK_EQ(2U, GetNumDisplays());
   if (GetNumDisplays() < 2)
     return;
-  const gfx::Display& primary = Shell::GetScreen()->GetPrimaryDisplay();
+  const gfx::Display& primary = screen_->GetPrimaryDisplay();
   const DisplayIdPair pair = GetCurrentDisplayIdPair();
   // Invert if the primary was swapped.
   DisplayLayout to_set = pair.first == primary.id() ?
       layout_relative_to_primary : layout_relative_to_primary.Invert();
 
   DisplayLayout current_layout =
       layout_store_->GetRegisteredDisplayLayout(pair);
   if (to_set.position != current_layout.position ||
       to_set.offset != current_layout.offset) {
     to_set.primary_id = primary.id();
     layout_store_->RegisterLayoutForDisplayIdPair(
         pair.first, pair.second, to_set);
     if (delegate_)
       delegate_->PreDisplayConfigurationChange(false);
     // PreDisplayConfigurationChange(false);
     // TODO(oshima): Call UpdateDisplays instead.
     const DisplayLayout layout = GetCurrentDisplayLayout();
     UpdateDisplayBoundsForLayoutById(
         layout, primary,
-        ScreenAsh::GetSecondaryDisplay().id());
+        ScreenUtil::GetSecondaryDisplay().id());
 
-    //UpdateCurrentDisplayBoundsForLayout();
     // Primary's bounds stay the same. Just notify bounds change
     // on the secondary.
-    Shell::GetInstance()->screen()->NotifyBoundsChanged(
-        ScreenAsh::GetSecondaryDisplay());
+    screen_ash_->NotifyBoundsChanged(
+        ScreenUtil::GetSecondaryDisplay());
     if (delegate_)
       delegate_->PostDisplayConfigurationChange();
   }
 }
 
 const gfx::Display& DisplayManager::GetDisplayForId(int64 id) const {
   gfx::Display* display =
       const_cast<DisplayManager*>(this)->FindDisplayForId(id);
   return display ? *display : GetInvalidDisplay();
 }
@@ skipping 402 matching lines @@
 
   base::AutoReset<bool> resetter(&change_display_upon_host_resize_, false);
 
   // 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 (DisplayList::const_reverse_iterator iter = removed_displays.rbegin();
        iter != removed_displays.rend(); ++iter) {
-    Shell::GetInstance()->screen()->NotifyDisplayRemoved(displays_.back());
+    screen_ash_->NotifyDisplayRemoved(displays_.back());
     displays_.pop_back();
   }
   // Close the non desktop window here to avoid creating two compositor on
   // one display.
   if (!non_desktop_display_updater->enabled())
     non_desktop_display_updater.reset();
   for (std::vector<size_t>::iterator iter = added_display_indices.begin();
        iter != added_display_indices.end(); ++iter) {
-    Shell::GetInstance()->screen()->NotifyDisplayAdded(displays_[*iter]);
+    screen_ash_->NotifyDisplayAdded(displays_[*iter]);
   }
   // Create the non destkop window after all displays are added so that
   // it can mirror the display newly added. This can happen when switching
   // from dock mode to software mirror mode.
   non_desktop_display_updater.reset();
   for (std::vector<size_t>::iterator iter = changed_display_indices.begin();
        iter != changed_display_indices.end(); ++iter) {
-    Shell::GetInstance()->screen()->NotifyBoundsChanged(displays_[*iter]);
+    screen_ash_->NotifyBoundsChanged(displays_[*iter]);
   }
   if (delegate_)
     delegate_->PostDisplayConfigurationChange();
 
 #if defined(USE_X11) && defined(OS_CHROMEOS)
   if (!changed_display_indices.empty() && base::SysInfo::IsRunningOnChromeOS())
     ui::ClearX11DefaultRootWindow();
 #endif
 }
 
@@ skipping 126 matching lines @@
 
 bool DisplayManager::UpdateDisplayBounds(int64 display_id,
                                          const gfx::Rect& new_bounds) {
   if (change_display_upon_host_resize_) {
     display_info_[display_id].SetBounds(new_bounds);
     // Don't notify observers if the mirrored window has changed.
     if (software_mirroring_enabled() && mirrored_display_id_ == display_id)
       return false;
     gfx::Display* display = FindDisplayForId(display_id);
     display->SetSize(display_info_[display_id].size_in_pixel());
-    Shell::GetInstance()->screen()->NotifyBoundsChanged(*display);
+    screen_ash_->NotifyBoundsChanged(*display);
     return true;
   }
   return false;
 }
 
 void DisplayManager::CreateMirrorWindowIfAny() {
   NonDesktopDisplayUpdater updater(this, delegate_);
 }
 
+void DisplayManager::CreateScreenForShutdown() const {
+  bool native_is_ash =
+      gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_NATIVE) ==
+      screen_ash_.get();
+  delete screen_for_shutdown;
+  screen_for_shutdown = screen_ash_->CloneForShutdown();
+  gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_ALTERNATE,
+                                 screen_for_shutdown);
+  if (native_is_ash) {
+    gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE,
+                                   screen_for_shutdown);
+  }
+}
+
 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 NULL;
 }
 
@@ skipping 116 matching lines @@
       break;
   }
   gfx::Insets insets = secondary_display->GetWorkAreaInsets();
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
 }  // namespace internal
 }  // namespace ash