Move DisplayList to display; add ScreenBase.

ui/display/manager/display_layout.cc

 // Copyright 2016 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 "ui/display/manager/display_layout.h"
 
 #include <algorithm>
 #include <set>
 #include <sstream>
 
@@ skipping 18 matching lines @@
 // to change this value in case to support even larger displays.
 const int kMaxValidOffset = 10000;
 
 bool IsIdInList(int64_t id, const DisplayIdList& list) {
   const auto iter =
       std::find_if(list.begin(), list.end(),
                    [id](int64_t display_id) { return display_id == id; });
   return iter != list.end();
 }
 
-Display* FindDisplayById(DisplayList* display_list, int64_t id) {
+Display* FindDisplayById(Displays* display_list, int64_t id) {
   auto iter =
       std::find_if(display_list->begin(), display_list->end(),
                    [id](const Display& display) { return display.id() == id; });
   return &(*iter);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // DisplayPlacement
@@ skipping 125 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // DisplayLayout
 
 DisplayLayout::DisplayLayout()
     : mirrored(false),
       default_unified(true),
       primary_id(Display::kInvalidDisplayID) {}
 
 DisplayLayout::~DisplayLayout() {}
 
-void DisplayLayout::ApplyToDisplayList(DisplayList* display_list,
+void DisplayLayout::ApplyToDisplayList(Displays* display_list,
                                        std::vector<int64_t>* updated_ids,
                                        int minimum_offset_overlap) const {
   // Layout from primary, then dependent displays.
   std::set<int64_t> parents;
   parents.insert(primary_id);
   while (parents.size()) {
     int64_t parent_id = *parents.begin();
     parents.erase(parent_id);
     for (const DisplayPlacement& placement : placement_list) {
       if (placement.parent_display_id == parent_id) {
@@ skipping 107 matching lines @@
       std::find_if(placement_list.begin(), placement_list.end(),
                    [display_id](const DisplayPlacement& placement) {
                      return placement.display_id == display_id;
                    });
   return (iter == placement_list.end()) ? DisplayPlacement()
                                         : DisplayPlacement(*iter);
 }
 
 // static
 bool DisplayLayout::ApplyDisplayPlacement(const DisplayPlacement& placement,
-                                          DisplayList* display_list,
+                                          Displays* display_list,
                                           int minimum_offset_overlap) {
   const Display& parent_display =
       *FindDisplayById(display_list, placement.parent_display_id);
   DCHECK(parent_display.is_valid());
   Display* target_display = FindDisplayById(display_list, placement.display_id);
   gfx::Rect old_bounds(target_display->bounds());
   DCHECK(target_display);
 
   const gfx::Rect& parent_bounds = parent_display.bounds();
   const gfx::Rect& target_bounds = target_display->bounds();
@@ skipping 39 matching lines @@
 
   gfx::Insets insets = target_display->GetWorkAreaInsets();
   target_display->set_bounds(
       gfx::Rect(new_target_origin, target_bounds.size()));
   target_display->UpdateWorkAreaFromInsets(insets);
 
   return old_bounds != target_display->bounds();
 }
 
 }  // namespace display