chromeos: Include mode details in OutputSnapshot.

chromeos/display/output_configurator.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 CHROMEOS_DISPLAY_OUTPUT_CONFIGURATOR_H_
 #define CHROMEOS_DISPLAY_OUTPUT_CONFIGURATOR_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 24 matching lines @@
   STATE_DUAL_MIRROR,
   STATE_DUAL_EXTENDED,
 };
 
 // This class interacts directly with the underlying Xrandr API to manipulate
 // CTRCs and Outputs.
 class CHROMEOS_EXPORT OutputConfigurator
     : public base::MessageLoop::Dispatcher,
       public base::MessagePumpObserver {
  public:
+  struct ModeInfo {
+    ModeInfo();
+
+    int width;
+    int height;
+    bool interlaced;

[oshima, 2013/08/15 19:03:24]

just FYI: i'm going to add preferred flag to this.

+  };
+
   struct CoordinateTransformation {
     // Initialized to the identity transformation.
     CoordinateTransformation();
 
     float x_scale;
     float x_offset;
     float y_scale;
     float y_offset;
   };
 
   // Information about an output's current state.
   struct OutputSnapshot {
     OutputSnapshot();
+    ~OutputSnapshot();
 
     RROutput output;
 
     // CRTC that should be used for this output. Not necessarily the CRTC
     // that XRandR reports is currently being used.
     RRCrtc crtc;
 
     // Mode currently being used by the output.
     RRMode current_mode;
 
     // "Best" mode supported by the output.
     RRMode native_mode;
 
     // Mode used when displaying the same desktop on multiple outputs.
     RRMode mirror_mode;
 
     // User-selected mode for the output.
     RRMode selected_mode;
 
     // Output's origin on the framebuffer.
     int x;
     int y;
 
+    // Output's physical dimensions.
+    uint64 width_mm;
+    uint64 height_mm;

[oshima, 2013/08/15 19:03:24]

are we using uint64 because that's what X is using?

[Daniel Erat, 2013/08/15 19:26:23]

Xrandr.h and ash::internal::ShouldIgnoreSize() look like they use unsigned longs
(i.e. uint32 in 32-bit builds and uint64 in 64-bit builds).

+
     bool is_internal;
     bool is_aspect_preserving_scaling;
 
+    // Map from mode IDs to details about the corresponding modes.
+    std::map<RRMode, ModeInfo> mode_infos;
+
     // XInput device ID or 0 if this output isn't a touchscreen.
     int touch_device_id;
 
     CoordinateTransformation transform;
 
     // Display id for this output.
     int64 display_id;
 
     bool has_display_id;
   };
 
   class Observer {
    public:
     virtual ~Observer() {}
 
-    // Called when the change of the display mode finished.  It will usually
-    // start the fading in the displays.
-    virtual void OnDisplayModeChanged() {}
+    // Called after the display mode has been changed. |output| contains the
+    // just-applied configuration. Note that the X server is no longer grabbed
+    // when this method is called, so the actual configuration could've changed
+    // already.
+    virtual void OnDisplayModeChanged(
+        const std::vector<OutputSnapshot>& outputs) {}
 
-    // Called when the change of the display mode is issued but failed.
-    // |failed_new_state| is the new state which the system failed to enter.
+    // Called after a display mode change attempt failed. |failed_new_state| is
+    // the new state which the system failed to enter.
     virtual void OnDisplayModeChangeFailed(OutputState failed_new_state) {}
   };
 
   // Interface for classes that make decisions about which output state
   // should be used.
   class StateController {
    public:
     virtual ~StateController() {}
 
     // Called when displays are detected.
@@ skipping 46 matching lines @@
     virtual void SetBackgroundColor(uint32 color_argb) = 0;
 
     // Enables DPMS and forces it to the "on" state.
     virtual void ForceDPMSOn() = 0;
 
     // Returns information about the current outputs.
     // This method may block for 60 milliseconds or more.
     virtual std::vector<OutputSnapshot> GetOutputs(
         const StateController* state_controller) = 0;
 
-    // Gets details corresponding to |mode|.  Parameters may be NULL.
-    // Returns true on success.
-    virtual bool GetModeDetails(RRMode mode,
-                                int* width,
-                                int* height,
-                                bool* interlaced) = 0;
-
     // Calls XRRSetCrtcConfig() with the given options but some of our default
     // output count and rotation arguments. Returns true on success.
     virtual bool ConfigureCrtc(RRCrtc crtc,
                                RRMode mode,
                                RROutput output,
                                int x,
                                int y) = 0;
 
     // Called to set the frame buffer (underlying XRR "screen") size.  Has
     // a side-effect of disabling all CRTCs.
@@ skipping 54 matching lines @@
 
   // Gap between screens so cursor at bottom of active display doesn't
   // partially appear on top of inactive display. Higher numbers guard
   // against larger cursors, but also waste more memory.
   // For simplicity, this is hard-coded to avoid the complexity of always
   // determining the DPI of the screen and rationalizing which screen we
   // need to use for the DPI calculation.
   // See crbug.com/130188 for initial discussion.
   static const int kVerticalGap = 60;
 
+  // Returns a pointer to the ModeInfo struct in |output| corresponding to
+  // |mode|, or NULL if the struct isn't present.
+  static const ModeInfo* GetModeInfo(const OutputSnapshot& output,
+                                     RRMode mode);
+
   OutputConfigurator();
   virtual ~OutputConfigurator();
 
   OutputState output_state() const { return output_state_; }
   DisplayPowerState power_state() const { return power_state_; }
 
   void set_state_controller(StateController* controller) {
     state_controller_ = controller;
   }
   void set_mirroring_controller(SoftwareMirroringController* controller) {
@@ skipping 91 matching lines @@
 
   // Returns the output state that should be used with |outputs| connected
   // while in |power_state|.
   OutputState GetOutputState(const std::vector<OutputSnapshot>& outputs,
                              DisplayPowerState power_state) const;
 
   // Computes the relevant transformation for mirror mode.
   // |output| is the output on which mirror mode is being applied.
   // Returns the transformation or identity if computations fail.
   CoordinateTransformation GetMirrorModeCTM(
-      const OutputConfigurator::OutputSnapshot* output);
+      const OutputConfigurator::OutputSnapshot& output);
 
   // Returns the ratio between mirrored mode area and native mode area:
   // (mirror_mode_width * mirrow_mode_height) / (native_width * native_height)
   float GetMirroredDisplayAreaRatio(
-      const OutputConfigurator::OutputSnapshot* output);
+      const OutputConfigurator::OutputSnapshot& output);
 
   StateController* state_controller_;
   SoftwareMirroringController* mirroring_controller_;
   scoped_ptr<Delegate> delegate_;
 
   // Key of the map is the touch display's id, and the value of the map is the
   // touch display's area ratio in mirror mode defined as :
   // mirror_mode_area / native_mode_area.
   // This is used for scaling touch event's radius when the touch display is in
   // mirror mode :
@@ skipping 28 matching lines @@
   scoped_ptr<base::OneShotTimer<OutputConfigurator> > configure_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(OutputConfigurator);
 };
 
 typedef std::vector<OutputConfigurator::OutputSnapshot> OutputSnapshotList;
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_DISPLAY_OUTPUT_CONFIGURATOR_H_