Move DisplayList to display; add ScreenBase.

ash/display/display_manager.h

 // 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.
 
 #ifndef ASH_DISPLAY_DISPLAY_MANAGER_H_
 #define ASH_DISPLAY_DISPLAY_MANAGER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 227 matching lines @@
   const display::Display& GetPrimaryDisplayCandidate() const;
 
   // Returns the logical number of displays. This returns 1
   // when displays are mirrored.
   size_t GetNumDisplays() const;
 
   // Returns only the currently active displays. This list does not include the
   // displays that will be removed if |UpdateDisplaysWith| is currently
   // executing.
   // See https://crbug.com/632755
-  const display::DisplayList& active_only_display_list() const {
+  const display::Displays& active_only_display_list() const {

[msw, 2016/09/06 20:14:27]

I can rename identifiers using the Displays type if desired.

     return is_updating_display_list_ ? active_only_display_list_
                                      : active_display_list();
   }
 
-  const display::DisplayList& active_display_list() const {
+  const display::Displays& active_display_list() const {
     return active_display_list_;
   }
 
   // Returns true if the display specified by |display_id| is currently
   // connected and active. (mirroring display isn't active, for example).
   bool IsActiveDisplayId(int64_t display_id) const;
 
   // Returns the number of connected displays. This returns 2
   // when displays are mirrored.
   size_t num_connected_displays() const { return num_connected_displays_; }
 
   // Returns the mirroring status.
   bool IsInMirrorMode() const;
   int64_t mirroring_display_id() const { return mirroring_display_id_; }
-  const display::DisplayList& software_mirroring_display_list() const {
+  const display::Displays& software_mirroring_display_list() const {
     return software_mirroring_display_list_;
   }
 
   // Sets/gets if the unified desktop feature is enabled.
   void SetUnifiedDesktopEnabled(bool enabled);
   bool unified_desktop_enabled() const { return unified_desktop_enabled_; }
 
   // Returns true if it's in unified desktop mode.
   bool IsInUnifiedMode() const;
 
@@ skipping 120 matching lines @@
       int64_t display_id,
       const gfx::Point& origin,
       float scale);
 
   // Updates the bounds of all non-primary displays in |display_list| and
   // append the indices of displays updated to |updated_indices|.
   // When the size of |display_list| equals 2, the bounds are updated using
   // the layout registered for the display pair. For more than 2 displays,
   // the bounds are updated using horizontal layout.
   void UpdateNonPrimaryDisplayBoundsForLayout(
-      display::DisplayList* display_list,
+      display::Displays* display_list,
       std::vector<size_t>* updated_indices);
 
   void CreateMirrorWindowIfAny();
 
   void RunPendingTasksForTest();
 
   // Applies the |layout| and updates the bounds of displays in |display_list|.
   // |updated_ids| contains the ids for displays whose bounds have changed.
   void ApplyDisplayLayout(const display::DisplayLayout& layout,
-                          display::DisplayList* display_list,
+                          display::Displays* display_list,
                           std::vector<int64_t>* updated_ids);
 
   Delegate* delegate_;  // not owned.
 
   std::unique_ptr<ScreenAsh> screen_;
 
   std::unique_ptr<display::DisplayLayoutStore> layout_store_;
 
   int64_t first_display_id_;
 
   // List of current active displays.
-  display::DisplayList active_display_list_;
+  display::Displays active_display_list_;
   // This list does not include the displays that will be removed if
   // |UpdateDisplaysWith| is under execution.
   // See https://crbug.com/632755
-  display::DisplayList active_only_display_list_;
+  display::Displays active_only_display_list_;
 
   // True if active_display_list is being modified and has displays that are not
   // presently active.
   // See https://crbug.com/632755
   bool is_updating_display_list_;
 
   int num_connected_displays_;
 
   bool force_bounds_changed_;
 
   // The mapping from the display ID to its internal data.
   std::map<int64_t, display::ManagedDisplayInfo> display_info_;
 
   // Selected display modes for displays. Key is the displays' ID.
   std::map<int64_t, scoped_refptr<display::ManagedDisplayMode>> display_modes_;
 
   // When set to true, the host window's resize event updates
   // the display's size. This is set to true when running on
   // desktop environment (for debugging) so that resizing the host
   // window will update the display properly. This is set to false
   // on device as well as during the unit tests.
   bool change_display_upon_host_resize_;
 
   MultiDisplayMode multi_display_mode_;
   MultiDisplayMode current_default_multi_display_mode_;
 
   int64_t mirroring_display_id_;
-  display::DisplayList software_mirroring_display_list_;
+  display::Displays software_mirroring_display_list_;
 
   // User preference for rotation lock of the internal display.
   bool registered_internal_display_rotation_lock_;
 
   // User preference for the rotation of the internal display.
   display::Display::Rotation registered_internal_display_rotation_;
 
   bool unified_desktop_enabled_;
 
   base::WeakPtrFactory<DisplayManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayManager);
 };
 
 }  // namespace ash
 
 #endif  // ASH_DISPLAY_DISPLAY_MANAGER_H_