Move DisplayList to display; add ScreenBase.

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 <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
@@ skipping 669 matching lines @@
   if (multi_display_mode_ != MIRRORING)
     multi_display_mode_ = current_default_multi_display_mode_;
 
   CreateSoftwareMirroringDisplayInfo(&new_display_info_list);
 
   // Close the mirroring window if any here to avoid creating two compositor on
   // one display.
   if (delegate_)
     delegate_->CloseMirroringDisplayIfNotNecessary();
 
-  display::DisplayList new_displays;
-  display::DisplayList removed_displays;
+  display::Displays new_displays;
+  display::Displays removed_displays;
   std::map<size_t, uint32_t> display_changes;
   std::vector<size_t> added_display_indices;
 
-  display::DisplayList::iterator curr_iter = active_display_list_.begin();
+  display::Displays::iterator curr_iter = active_display_list_.begin();
   DisplayInfoList::const_iterator new_info_iter = new_display_info_list.begin();
 
   while (curr_iter != active_display_list_.end() ||
          new_info_iter != new_display_info_list.end()) {
     if (curr_iter == active_display_list_.end()) {
       // more displays in new list.
       added_display_indices.push_back(new_displays.size());
       InsertAndUpdateDisplayInfo(*new_info_iter);
       new_displays.push_back(
           CreateDisplayFromDisplayInfoById(new_info_iter->id()));
@@ skipping 277 matching lines @@
   }
   num_connected_displays_ = new_display_info_list.size();
   mirroring_display_id_ = display::Display::kInvalidDisplayID;
   software_mirroring_display_list_.clear();
   UpdateDisplaysWith(new_display_info_list);
 }
 
 void DisplayManager::ToggleDisplayScaleFactor() {
   DCHECK(!active_display_list_.empty());
   DisplayInfoList new_display_info_list;
-  for (display::DisplayList::const_iterator iter = active_display_list_.begin();
+  for (display::Displays::const_iterator iter = active_display_list_.begin();
        iter != active_display_list_.end(); ++iter) {
     display::ManagedDisplayInfo display_info = GetDisplayInfo(iter->id());
     display_info.set_device_scale_factor(
         display_info.device_scale_factor() == 1.0f ? 2.0f : 1.0f);
     new_display_info_list.push_back(display_info);
   }
   AddMirrorDisplayInfoIfAny(&new_display_info_list);
   UpdateDisplaysWith(new_display_info_list);
 }
 
@@ skipping 340 matching lines @@
   display::Display new_display(display_info.id());
   new_display.SetScaleAndBounds(
       1.0f, gfx::Rect(origin, gfx::ScaleToFlooredSize(
                                   display_info.size_in_pixel(), scale)));
   new_display.set_touch_support(display_info.touch_support());
   new_display.set_maximum_cursor_size(display_info.maximum_cursor_size());
   return new_display;
 }
 
 void DisplayManager::UpdateNonPrimaryDisplayBoundsForLayout(
-    display::DisplayList* display_list,
+    display::Displays* display_list,
     std::vector<size_t>* updated_indices) {
   if (display_list->size() == 1u)
     return;
 
   const display::DisplayLayout& layout =
       layout_store_->GetRegisteredDisplayLayout(
           display::CreateDisplayIdList(*display_list));
 
   // Ignore if a user has a old format (should be extremely rare)
   // and this will be replaced with DCHECK.
@@ skipping 16 matching lines @@
 void DisplayManager::CreateMirrorWindowIfAny() {
   if (software_mirroring_display_list_.empty() || !delegate_)
     return;
   DisplayInfoList list;
   for (auto& display : software_mirroring_display_list_)
     list.push_back(GetDisplayInfo(display.id()));
   delegate_->CreateOrUpdateMirroringDisplay(list);
 }
 
 void DisplayManager::ApplyDisplayLayout(const display::DisplayLayout& layout,
-                                        display::DisplayList* display_list,
+                                        display::Displays* display_list,
                                         std::vector<int64_t>* updated_ids) {
   layout.ApplyToDisplayList(display_list, updated_ids,
                             kMinimumOverlapForInvalidOffset);
 }
 
 void DisplayManager::RunPendingTasksForTest() {
   if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace ash