Merge monitor_reconfigure into powerd.

resolution_selector.cc

Index: resolution_selector.cc
diff --git a/resolution_selector.cc b/resolution_selector.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7bd42ba83d5d1c9c4ac567d87bb21de6f51ab879
--- /dev/null
+++ b/resolution_selector.cc
@@ -0,0 +1,91 @@
+// Copyright (c) 2010 The Chromium OS Authors. All rights reserved.

[Daniel Erat, 2011/04/13 23:33:26]

nit: 2011

[marcheu, 2011/04/14 02:23:55]

Done.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "power_manager/resolution_selector.h"
+
+#include "base/logging.h"
+
+namespace power_manager {
+
+using std::string;
+using std::vector;
+
+
+const int ResolutionSelector::kMaxProjectorPixels = 1280 * 720;
+
+
+bool ResolutionSelector::FindBestResolutions(
+    const vector<Mode>& lcd_modes,
+    const vector<Mode>& external_modes,
+    Mode* lcd_resolution,
+    Mode* external_resolution,
+    Mode* screen_resolution) {
+  DCHECK(!lcd_modes.empty());
+
+  // If there's no external display, just use the highest resolution
+  // available from the LCD.
+  if (external_modes.empty()) {
+    *lcd_resolution = *screen_resolution = lcd_modes[0];
+    external_resolution->name.clear();
+    return true;
+  }
+
+  const int max_lcd_size = lcd_modes[0].width * lcd_modes[0].height;
+  const int max_external_size =
+      external_modes[0].width * external_modes[0].height;
+
+  if (max_lcd_size >= max_external_size) {
+    return FindNearestResolutions(
+        lcd_modes, external_modes,
+        lcd_resolution, external_resolution, screen_resolution);
+  } else {
+    // If the external output is large enough that we think it's a monitor
+    // (as opposed to a projector), then we just use its max resolution and
+    // forget about trying to choose a screen size that'll fit on the
+    // built-in display.
+    if (max_external_size > kMaxProjectorPixels) {
+      *external_resolution = *screen_resolution = external_modes[0];
+      lcd_resolution->name.clear();
+      return true;
+    }
+    return FindNearestResolutions(
+        external_modes, lcd_modes,
+        external_resolution, lcd_resolution, screen_resolution);
+  }
+}
+
+bool ResolutionSelector::FindNearestResolutions(
+    const vector<Mode>& larger_device_modes,
+    const vector<Mode>& smaller_device_modes,
+    Mode* larger_resolution,
+    Mode* smaller_resolution,
+    Mode* screen_resolution) {
+  DCHECK(!larger_device_modes.empty());
+  DCHECK(!smaller_device_modes.empty());
+  DCHECK(larger_resolution);
+  DCHECK(smaller_resolution);
+  DCHECK(screen_resolution);
+
+  // Start with the best that the smaller device has to offer.
+  *smaller_resolution = smaller_device_modes[0];
+  *screen_resolution = *smaller_resolution;
+  int smaller_width = smaller_device_modes[0].width;
+  int smaller_height = smaller_device_modes[0].height;
+
+  for (vector<Mode>::const_reverse_iterator it =
+           larger_device_modes.rbegin();
+       it != larger_device_modes.rend(); ++it) {
+    if (it->width >= smaller_width && it->height >= smaller_height) {
+      *larger_resolution = *it;
+      return true;
+    }
+  }
+
+  LOG(WARNING) << "Failed to find a resolution from larger device "
+               << "exceeding chosen resolution from smaller device ("
+               << smaller_resolution->name << ")";
+  return false;
+}
+
+}  // namespace power_manager