Make ash::DisplayMode more like ui::DisplayMode

ash/common/display/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_
 
 #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/types/display_constants.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace ash {
 
-// A struct that represents the display's mode info.
-struct ASH_EXPORT DisplayMode {
+// A class that represents the display's mode info.
+class ASH_EXPORT DisplayMode : public base::RefCounted<DisplayMode> {
+ public:
   DisplayMode();
+
+  DisplayMode(const gfx::Size& size);
+
   DisplayMode(const gfx::Size& size,
               float refresh_rate,
-              bool interlaced,
+              bool is_interlaced,
               bool native);
 
+  DisplayMode(const gfx::Size& size,
+              float refresh_rate,
+              bool is_interlaced,
+              bool native,
+              float ui_scale,
+              float device_scale_factor);
   // Returns the size in DIP which is visible to the user.
   gfx::Size GetSizeInDIP(bool is_internal) const;
 
   // Returns true if |other| has same size and scale factors.
-  bool IsEquivalent(const DisplayMode& other) const;
+  bool IsEquivalent(const scoped_refptr<DisplayMode>& other) const;
 
-  gfx::Size size;             // Physical pixel size of the display.
-  float refresh_rate;         // Refresh rate of the display, in Hz.
-  bool 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.
+  const gfx::Size& size() const { return size_; }
+  bool is_interlaced() const { return is_interlaced_; }
+  float refresh_rate() const { return refresh_rate_; }
+
+  bool native() const { return native_; }
+
+  // Missing from ui::DisplayMode
+  float ui_scale() const { return ui_scale_; }
+  float device_scale_factor() const { return device_scale_factor_; }
+
+ private:
+  ~DisplayMode();
+  friend class base::RefCounted<DisplayMode>;
+
+  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(DisplayMode);
 };
 
 // DisplayInfo 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 {
  public:
+  using DisplayModeList = std::vector<scoped_refptr<DisplayMode>>;
+
   // Creates a DisplayInfo 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).
@@ skipping 139 matching lines @@
   void SetOverscanInsets(const gfx::Insets& insets_in_dip);
   gfx::Insets GetOverscanInsetsInPixel() const;
 
   // Sets/Gets the flag to clear overscan insets.
   bool clear_overscan_insets() const { return clear_overscan_insets_; }
   void set_clear_overscan_insets(bool clear) { clear_overscan_insets_ = clear; }
 
   void set_native(bool native) { native_ = native; }
   bool native() const { return native_; }
 
-  const std::vector<DisplayMode>& display_modes() const {
-    return display_modes_;
-  }
+  const DisplayModeList& display_modes() const { return display_modes_; }
   // Sets the display mode list. The mode list will be sorted for the
   // display.
-  void SetDisplayModes(const std::vector<DisplayMode>& display_modes);
+  void SetDisplayModes(const DisplayModeList& display_modes);
 
   // Returns the native mode size. If a native mode is not present, return an
   // empty size.
   gfx::Size GetNativeModeSize() const;
 
   ui::ColorCalibrationProfile color_profile() const { return color_profile_; }
 
   // Sets the color profile. It will ignore if the specified |profile| is not in
   // |available_color_profiles_|.
   void SetColorProfile(ui::ColorCalibrationProfile profile);
@@ skipping 80 matching lines @@
   // True if the display is configured to preserve the aspect ratio. When the
   // display is configured in a non-native mode, only parts of the display will
   // be used such that the aspect ratio is preserved.
   bool is_aspect_preserving_scaling_;
 
   // True if the displays' overscan inset should be cleared. This is
   // to distinguish the empty overscan insets from native display info.
   bool clear_overscan_insets_;
 
   // The list of modes supported by this display.
-  std::vector<DisplayMode> display_modes_;
+  DisplayModeList display_modes_;
 
   // The current profile of the color calibration.
   ui::ColorCalibrationProfile color_profile_;
 
   // The list of available variations for the color calibration.
   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();
 
 }  // namespace ash
 
 #endif  //  ASH_COMMON_DISPLAY_DISPLAY_INFO_H_