Move ash::DisplayInfo to ui

ui/display/manager/managed_display_info.h

 // Copyright (c) 2013 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_COMMON_DISPLAY_DISPLAY_INFO_H_
-#define ASH_COMMON_DISPLAY_DISPLAY_INFO_H_
+#ifndef UI_DISPLAY_MANAGER_MANAGED_DISPLAY_INFO_H_
+#define UI_DISPLAY_MANAGER_MANAGED_DISPLAY_INFO_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
-#include "ash/ash_export.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "ui/display/display.h"
+#include "ui/display/display_export.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/rect.h"
 
-namespace ash {
+namespace ui {

[kylechar, 2016/08/29 16:01:33]

Should this be namespace display? It seems like all new code in ui/display is
going there and would make sense to eventually move everything in ui/display
into the same namespace.

[rjkroege, 2016/08/29 22:21:59]

Done.

 
 // A class that represents the display's mode info.
-class ASH_EXPORT ManagedDisplayMode
+class DISPLAY_EXPORT ManagedDisplayMode
     : public base::RefCounted<ManagedDisplayMode> {
  public:
   ManagedDisplayMode();
 
   ManagedDisplayMode(const gfx::Size& size);
 
   ManagedDisplayMode(const gfx::Size& size,
                      float refresh_rate,
                      bool is_interlaced,
                      bool native);
@@ skipping 27 matching lines @@
   gfx::Size size_;             // Physical pixel size of the display.
   float refresh_rate_;         // Refresh rate of the display, in Hz.
   bool is_interlaced_;         // True if mode is interlaced.
   bool native_;                // True if mode is native mode of the display.
   float ui_scale_;             // The UI scale factor of the mode.
   float device_scale_factor_;  // The device scale factor of the mode.
 
   DISALLOW_COPY_AND_ASSIGN(ManagedDisplayMode);
 };
 
-// DisplayInfo contains metadata for each display. This is used to
+// ManagedDisplayInfo contains metadata for each display. This is used to
 // create |display::Display| as well as to maintain extra infomation
 // to manage displays in ash environment.
 // This class is intentionally made copiable.
-class ASH_EXPORT DisplayInfo {
+class DISPLAY_EXPORT ManagedDisplayInfo {
  public:
   using ManagedDisplayModeList = std::vector<scoped_refptr<ManagedDisplayMode>>;
 
-  // Creates a DisplayInfo from string spec. 100+200-1440x800 creates display
+  // Creates a ManagedDisplayInfo from string spec. 100+200-1440x800 creates
+  // display
   // whose size is 1440x800 at the location (100, 200) in host coordinates.
   // The format is
   //
   // [origin-]widthxheight[*device_scale_factor][#resolutions list]
   //     [/<properties>][@ui-scale]
   //
   // where [] are optional:
   // - |origin| is given in x+y- format.
   // - |device_scale_factor| is either 2 or 1 (or empty).
   // - properties can combination of 'o', which adds default overscan insets
@@ skipping 14 matching lines @@
   // "300x200/ol"
   //      300x200 window at 0,0 origin. 1x device scale factor.
   //      with 5% overscan. rotated to left (90 degree counter clockwise).
   //      1.0 ui scale.
   // "10+20-300x200/u@1.5"
   //      300x200 window at 10,20 origin. 1x device scale factor.
   //      no overscan. flipped upside-down (180 degree) and 1.5 ui scale.
   // "200x100#300x200|200x100%59.0|100x100%60"
   //      200x100 window at 0,0 origin, with 3 possible resolutions,
   //      300x200, 200x100 at 59 Hz, and 100x100 at 60 Hz.
-  static DisplayInfo CreateFromSpec(const std::string& spec);
+  static ManagedDisplayInfo CreateFromSpec(const std::string& spec);
 
-  // Creates a DisplayInfo from string spec using given |id|.
-  static DisplayInfo CreateFromSpecWithID(const std::string& spec, int64_t id);
+  // Creates a ManagedDisplayInfo from string spec using given |id|.
+  static ManagedDisplayInfo CreateFromSpecWithID(const std::string& spec,
+                                                 int64_t id);
 
   // When this is set to true on the device whose internal display has
   // 1.25 dsf, Chrome uses 1.0f as a default scale factor, and uses
   // dsf 1.25 when UI scaling is set to 0.8f.
   static void SetUse125DSFForUIScalingForTest(bool enable);
 
-  DisplayInfo();
-  DisplayInfo(int64_t id, const std::string& name, bool has_overscan);
-  DisplayInfo(const DisplayInfo& other);
-  ~DisplayInfo();
+  ManagedDisplayInfo();
+  ManagedDisplayInfo(int64_t id, const std::string& name, bool has_overscan);
+  ManagedDisplayInfo(const ManagedDisplayInfo& other);
+  ~ManagedDisplayInfo();
 
   int64_t id() const { return id_; }
 
   // The name of the display.
   const std::string& name() const { return name_; }
 
   // The path to the display device in the sysfs filesystem.
   void set_sys_path(const base::FilePath& sys_path) { sys_path_ = sys_path; }
   const base::FilePath& sys_path() const { return sys_path_; }
 
@@ skipping 69 matching lines @@
   //    uses 1.0f DFS unless 0.8x UI scaling is specified.
   float GetEffectiveDeviceScaleFactor() const;
 
   // Returns the ui scale used for the device scale factor. This
   // return 1.0f if the ui scale and dsf are both set to 2.0.
   float GetEffectiveUIScale() const;
 
   // Copy the display info except for fields that can be modified by a
   // user (|rotation_| and |configured_ui_scale_|). |rotation_| and
   // |configured_ui_scale_| are copied when the |another_info| isn't native one.
-  void Copy(const DisplayInfo& another_info);
+  void Copy(const ManagedDisplayInfo& another_info);
 
   // Update the |bounds_in_native_| and |size_in_pixel_| using
   // given |bounds_in_native|.
   void SetBounds(const gfx::Rect& bounds_in_native);
 
   // Update the |bounds_in_native| according to the current overscan
   // and rotation settings.
   void UpdateDisplaySize();
 
   // Sets/Clears the overscan insets.
@@ skipping 42 matching lines @@
   void set_is_aspect_preserving_scaling(bool value) {
     is_aspect_preserving_scaling_ = value;
   }
 
   // Maximum cursor size in native pixels.
   const gfx::Size& maximum_cursor_size() const { return maximum_cursor_size_; }
   void set_maximum_cursor_size(const gfx::Size& size) {
     maximum_cursor_size_ = size;
   }
 
-  // Returns a string representation of the DisplayInfo, excluding display
+  // Returns a string representation of the ManagedDisplayInfo, excluding
+  // display
   // modes.
   std::string ToString() const;
 
-  // Returns a string representation of the DisplayInfo, including display
+  // Returns a string representation of the ManagedDisplayInfo, including
+  // display
   // modes.
   std::string ToFullString() const;
 
  private:
   // Returns true if this display should use DSF=1.25 for UI scaling; i.e.
   // SetUse125DSFForUIScaling(true) is called and this is the internal display.
   bool Use125DSFForUIScaling() const;
 
   int64_t id_;
   std::string name_;
@@ skipping 53 matching lines @@
   std::vector<ui::ColorCalibrationProfile> available_color_profiles_;
 
   // Maximum cursor size.
   gfx::Size maximum_cursor_size_;
 
   // If you add a new member, you need to update Copy().
 };
 
 // Resets the synthesized display id for testing. This
 // is necessary to avoid overflowing the output index.
-ASH_EXPORT void ResetDisplayIdForTest();
+void DISPLAY_EXPORT ResetDisplayIdForTest();
 
-}  // namespace ash
+}  // namespace ui
 
-#endif  //  ASH_COMMON_DISPLAY_DISPLAY_INFO_H_
+#endif  //  UI_DISPLAY_MANAGER_MANAGED_DISPLAY_INFO_H_