Support failing modeset

chromeos/display/output_configurator.cc

 // 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.
 
 #include "chromeos/display/output_configurator.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/Xrandr.h>
 #include <X11/extensions/XInput2.h>
 
@@ skipping 923 matching lines @@
         OutputSnapshot* output = &updated_outputs[i];
         if (output->touch_device_id)
           output->transform = GetExtendedModeCTM(*output, width, height);
       }
       break;
     }
   }
 
   // Finally, apply the desired changes.
   DCHECK_EQ(cached_outputs_.size(), updated_outputs.size());
+  bool all_succeeded = true;
   if (!updated_outputs.empty()) {
     delegate_->CreateFrameBuffer(width, height, updated_outputs);
     for (size_t i = 0; i < updated_outputs.size(); ++i) {
       const OutputSnapshot& output = updated_outputs[i];
-      if (delegate_->ConfigureCrtc(output.crtc, output.current_mode,
-                                   output.output, output.x, output.y)) {
-        if (output.touch_device_id)
-          delegate_->ConfigureCTM(output.touch_device_id, output.transform);
-        cached_outputs_[i] = updated_outputs[i];
-      } else {
+      bool configure_succeeded;
+
+      while (true) {
+        configure_succeeded = false;

[Daniel Erat, 2014/01/09 00:40:34]

nit: just initialize the variable to false where it's defined outside of the
loop; that way you can set it to true when you break out of the loop on success
but not need to set it to false in the multiple places where you break out of
the loop on failure

+        if (delegate_->ConfigureCrtc(output.crtc, output.current_mode,
+                                       output.output, output.x, output.y)) {
+          configure_succeeded = true;
+          break;
+        }
+
         LOG(WARNING) << "Unable to configure CRTC " << output.crtc << ":"
                      << " mode=" << output.current_mode
                      << " output=" << output.output
                      << " x=" << output.x
                      << " y=" << output.y;
+
+        const ModeInfo* mode_info = GetModeInfo(output, output.current_mode);
+        if (!mode_info)
+          break;
+
+        // Find the mode with the next-best resolution and see if that can
+        // be set.
+        int best_mode_pixels = 0;
+
+        int current_mode_pixels = mode_info->width * mode_info->height;
+        for (ModeInfoMap::const_iterator it = output.mode_infos.begin();
+             it != output.mode_infos.end(); it++) {
+          int pixel_count = it->second.width * it->second.height;
+          if ((pixel_count < current_mode_pixels) &&
+              (pixel_count > best_mode_pixels)) {
+            updated_outputs[i].current_mode = it->first;
+            best_mode_pixels = pixel_count;
+          }
+        }
+
+        if (best_mode_pixels == 0)
+          break;
       }
+
+      if (configure_succeeded) {
+        if (output.touch_device_id)
+          delegate_->ConfigureCTM(output.touch_device_id, output.transform);
+        cached_outputs_[i] = updated_outputs[i];
+      } else {
+        all_succeeded = false;
+      }
+
+      // If we are trying to set mirror mode and one of the modesets fails,
+      // then the two monitors will be mis-matched.  In this case, return
+      // false to let the observers be aware.
+      if (output_state == STATE_DUAL_MIRROR &&
+          output_power[i] &&
+          output.current_mode != output.mirror_mode)
+        all_succeeded = false;
+
     }
   }
 
-  output_state_ = output_state;
-  power_state_ = power_state;
-  return true;
+  if (all_succeeded)  {
+    output_state_ = output_state;
+    power_state_ = power_state;
+  }
+  return all_succeeded;
 }
 
 OutputState OutputConfigurator::ChooseOutputState(
     DisplayPowerState power_state) const {
   int num_on_outputs = GetOutputPower(cached_outputs_, power_state, NULL);
   switch (cached_outputs_.size()) {
     case 0:
       return STATE_HEADLESS;
     case 1:
       return STATE_SINGLE;
@@ skipping 109 matching lines @@
   float width_ratio = static_cast<float>(mirror_mode_info->width) /
       static_cast<float>(native_mode_info->width);
   float height_ratio = static_cast<float>(mirror_mode_info->height) /
       static_cast<float>(native_mode_info->height);
 
   area_ratio = width_ratio * height_ratio;
   return area_ratio;
 }
 
 }  // namespace chromeos