chromeos: Fix display failures when going to mirrored mode.

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 26 matching lines @@
 };
 
 // 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();
-    ModeInfo(int width, int height, bool interlaced);
+    ModeInfo(int width, int height, bool interlaced, float refresh_rate);
 
     int width;
     int height;
     bool interlaced;
+    float refresh_rate;
   };
 
+  typedef std::map<RRMode, ModeInfo> ModeInfoMap;
+
   struct CoordinateTransformation {
     // Initialized to the identity transformation.
     CoordinateTransformation();
 
     float x_scale;
     float x_offset;
     float y_scale;
     float y_offset;
   };
 
@@ skipping 25 matching lines @@
     int y;
 
     // Output's physical dimensions.
     uint64 width_mm;
     uint64 height_mm;
 
     bool is_internal;
     bool is_aspect_preserving_scaling;
 
     // Map from mode IDs to details about the corresponding modes.
-    std::map<RRMode, ModeInfo> mode_infos;
+    ModeInfoMap 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;
@@ skipping 43 matching lines @@
 
     // Called when the hardware mirroring failed.
     virtual void SetSoftwareMirroring(bool enabled) = 0;
   };
 
   // Interface for classes that perform actions on behalf of OutputController.
   class Delegate {
    public:
     virtual ~Delegate() {}
 
-    virtual void SetPanelFittingEnabled(bool enabled) = 0;
-
     // Initializes the XRandR extension, saving the base event ID to
     // |event_base|.
     virtual void InitXRandRExtension(int* event_base) = 0;
 
     // Tells XRandR to update its configuration in response to |event|, an
     // RRScreenChangeNotify event.
     virtual void UpdateXRandRConfiguration(const base::NativeEvent& event) = 0;
 
     // Grabs the X server and refreshes XRandR-related resources.  While
     // the server is grabbed, other clients are blocked.  Must be balanced
     // by a call to UngrabServer().
     virtual void GrabServer() = 0;
 
     // Ungrabs the server and frees XRandR-related resources.
     virtual void UngrabServer() = 0;
 
     // Flushes all pending requests and waits for replies.
     virtual void SyncWithServer() = 0;
 
     // Sets the window's background color to |color_argb|.
     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;
+    // Returns information about the current outputs. This method may block for
+    // 60 milliseconds or more. The returned outputs are not fully initialized;
+    // the rest of the work happens in OutputConfigurator::GetOutputs().
+    virtual std::vector<OutputSnapshot> GetOutputs() = 0;
+
+    // Adds |mode| to |output|.
+    virtual void AddOutputMode(RROutput output, RRMode mode) = 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
@@ skipping 60 matching lines @@
   // 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);
 
+  // Returns the mode within |output| that matches the given size with highest
+  // refresh rate. Returns None if no matching output was found.
+  static RRMode FindOutputModeMatchingSize(const OutputSnapshot& output,
+                                           int width,
+                                           int height);
+
   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 58 matching lines @@
 
   const std::map<int, float>& GetMirroredDisplayAreaRatioMap() {
     return mirrored_display_area_ratio_map_;
   }
 
   // Configure outputs with |kConfigureDelayMs| delay,
   // so that time-consuming ConfigureOutputs() won't be called multiple times.
   void ScheduleConfigureOutputs();
 
  private:
-  // Configure outputs.
+  // Returns currently-connected outputs. This method is a wrapper around
+  // |delegate_->GetOutputs()| that does additional work, like finding the
+  // mirror mode and setting user-preferred modes. Note that the server must
+  // be grabbed via |delegate_->GrabServer()| first.
+  std::vector<OutputSnapshot> GetOutputs();
+
+  // Helper method for GetOutputs() that initializes the passed-in outputs'
+  // |mirror_mode| fields by looking for a mode in |internal_output| and
+  // |external_output| having the same resolution. Returns false if a shared
+  // mode wasn't found or created.
+  //
+  // |try_panel_fitting| allows creating a panel-fitting mode for
+  // |internal_output| instead of only searching for a matching mode (note that
+  // it may lead to a crash if |internal_info| is not capable of panel fitting).
+  //
+  // |preserve_aspect| limits the search/creation only to the modes having the
+  // native aspect ratio of |external_output|.
+  bool FindMirrorMode(OutputSnapshot* internal_output,
+                      OutputSnapshot* external_output,
+                      bool try_panel_fitting,
+                      bool preserve_aspect);
+
+  // Configures outputs.
   void ConfigureOutputs();
 
   // Notifies observers about an attempted state change.
   void NotifyObservers(bool success, OutputState attempted_state);
 
   // Switches to the state specified in |output_state| and |power_state|.
   // If the hardware mirroring failed and |mirroring_controller_| is set,
   // it switches to |STATE_DUAL_EXTENDED| and calls |SetSoftwareMirroring()|
   // to enable software based mirroring.
   // On success, updates |output_state_|, |power_state_|, and |cached_outputs_|
@@ skipping 23 matching lines @@
 
   // 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);
 
   StateController* state_controller_;
   SoftwareMirroringController* mirroring_controller_;
   scoped_ptr<Delegate> delegate_;
 
+  // Used to enable modes which rely on panel fitting.
+  bool is_panel_fitting_enabled_;
+
   // 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 :
   // new_touch_radius = sqrt(area_ratio) * old_touch_radius
   std::map<int, float> mirrored_display_area_ratio_map_;
 
   // This is detected by the constructor to determine whether or not we should
   // be enabled.  If we aren't running on ChromeOS, we can't assume that the
@@ skipping 23 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_