Move DisplayLayout and DisplayLayoutBuilder From ash To ui/display

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>
 
 #include <string>
 #include <vector>
 
 #include "ash/ash_export.h"
 #include "ash/display/display_info.h"
-#include "ash/display/display_layout.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "ui/display/manager/display_layout.h"
 #include "ui/gfx/display.h"
 
 #if defined(OS_CHROMEOS)
 #include "ui/display/chromeos/display_configurator.h"
 #endif
 
 namespace aura {
 class Window;
 }
 
@@ skipping 92 matching lines @@
   bool InitFromCommandLine();
 
   // Initialize default display.
   void InitDefaultDisplay();
 
   // Initializes font related params that depends on display
   // configuration.
   void RefreshFontParams();
 
   // Returns the display layout used for current displays.
-  const DisplayLayout& GetCurrentDisplayLayout() const;
+  const display::DisplayLayout& GetCurrentDisplayLayout() const;
 
   // Returns the current display list.
-  DisplayIdList GetCurrentDisplayIdList() const;
+  display::DisplayIdList GetCurrentDisplayIdList() const;
 
   // Sets the layout for the current display pair. The |layout| specifies
   // the locaion of the displays relative to their parents.
-  void SetLayoutForCurrentDisplays(scoped_ptr<DisplayLayout> layout);
+  void SetLayoutForCurrentDisplays(scoped_ptr<display::DisplayLayout> layout);
 
   // Returns display for given |id|;
   const gfx::Display& GetDisplayForId(int64_t id) const;
 
   // Finds the display that contains |point| in screeen coordinates.
   // Returns invalid display if there is no display that can satisfy
   // the condition.
   const gfx::Display& FindDisplayContainingPoint(
       const gfx::Point& point_in_screen) const;
 
@@ skipping 78 matching lines @@
   // Returns the display at |index|. The display at 0 is
   // no longer considered "primary".
   const gfx::Display& GetDisplayAt(size_t index) const;
 
   const gfx::Display& GetPrimaryDisplayCandidate() const;
 
   // Returns the logical number of displays. This returns 1
   // when displays are mirrored.
   size_t GetNumDisplays() const;
 
-  const DisplayList& active_display_list() const {
+  const display::DisplayList& 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 DisplayList& software_mirroring_display_list() const {
+  const display::DisplayList& 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 116 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(
-      DisplayList* display_list,
+      display::DisplayList* 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 DisplayLayout& layout,
-                          DisplayList* display_list,
+  void ApplyDisplayLayout(const display::DisplayLayout& layout,
+                          display::DisplayList* display_list,
                           std::vector<int64_t>* updated_ids);
 
   // Apply the display placement to the display layout.
   // Returns true if the display bounds has been updated.
-  bool ApplyDisplayPlacement(const DisplayPlacement& placement,
-                             DisplayList* display_list);
+  bool ApplyDisplayPlacement(const display::DisplayPlacement& placement,
+                             display::DisplayList* display_list);
 
   Delegate* delegate_;  // not owned.
 
   scoped_ptr<ScreenAsh> screen_;
 
   scoped_ptr<DisplayLayoutStore> layout_store_;
 
   int64_t first_display_id_;
 
   // List of current active displays.
-  DisplayList active_display_list_;
+  display::DisplayList active_display_list_;
 
   int num_connected_displays_;
 
   bool force_bounds_changed_;
 
   // The mapping from the display ID to its internal data.
   std::map<int64_t, DisplayInfo> display_info_;
 
   // Selected display modes for displays. Key is the displays' ID.
   std::map<int64_t, DisplayMode> 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_;
-  DisplayList software_mirroring_display_list_;
+  display::DisplayList 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.
   gfx::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_