Add ability to set resolution on external display

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 86 matching lines @@
 }
 
 }  // namespace
 
 OutputConfigurator::OutputSnapshot::OutputSnapshot()
     : output(None),
       crtc(None),
       current_mode(None),
       native_mode(None),
       mirror_mode(None),
+      selected_mode(None),
       y(0),
       height(0),
       is_internal(false),
       is_aspect_preserving_scaling(false),
       touch_device_id(0),
       display_id(0),
       has_display_id(false) {}
 
 OutputConfigurator::CoordinateTransformation::CoordinateTransformation()
   : x_scale(1.0),
@@ skipping 68 matching lines @@
                               uint32 background_color_argb) {
   if (!configure_display_)
     return;
 
   if (!delegate_)
     delegate_.reset(new RealOutputConfiguratorDelegate());
 
   // Cache the initial output state.
   delegate_->SetPanelFittingEnabled(is_panel_fitting_enabled);
   delegate_->GrabServer();
-  std::vector<OutputSnapshot> outputs = delegate_->GetOutputs();
+  std::vector<OutputSnapshot> outputs =
+      delegate_->GetOutputs(state_controller_);
   if (outputs.size() > 1 && background_color_argb)
     delegate_->SetBackgroundColor(background_color_argb);
   delegate_->UngrabServer();
 }
 
 void OutputConfigurator::Start() {
   if (!configure_display_)
     return;
 
   delegate_->GrabServer();
   delegate_->InitXRandRExtension(&xrandr_event_base_);
 
-  std::vector<OutputSnapshot> outputs = delegate_->GetOutputs();
+  std::vector<OutputSnapshot> outputs =
+      delegate_->GetOutputs(state_controller_);
   EnterStateOrFallBackToSoftwareMirroring(
       GetOutputState(outputs, power_state_), power_state_, outputs);
 
   // Force the DPMS on chrome startup as the driver doesn't always detect
   // that all displays are on when signing out.
   delegate_->ForceDPMSOn();
   delegate_->UngrabServer();
   delegate_->SendProjectingStateToPowerManager(IsProjecting(outputs));
 }
 
 void OutputConfigurator::Stop() {
   configure_display_ = false;
 }
 
 bool OutputConfigurator::SetDisplayPower(DisplayPowerState power_state,
                                          int flags) {
   if (!configure_display_)
     return false;
 
   VLOG(1) << "SetDisplayPower: power_state="
           << DisplayPowerStateToString(power_state) << " flags=" << flags;
   if (power_state == power_state_ && !(flags & kSetDisplayPowerForceProbe))
     return true;
 
   delegate_->GrabServer();
-  std::vector<OutputSnapshot> outputs = delegate_->GetOutputs();
+  std::vector<OutputSnapshot> outputs =
+      delegate_->GetOutputs(state_controller_);
 
   bool only_if_single_internal_display =
       flags & kSetDisplayPowerOnlyIfSingleInternalDisplay;
   bool single_internal_display = outputs.size() == 1 && outputs[0].is_internal;
   if ((single_internal_display || !only_if_single_internal_display) &&
       EnterStateOrFallBackToSoftwareMirroring(
           GetOutputState(outputs, power_state), power_state, outputs)) {
     if (power_state != DISPLAY_POWER_ALL_OFF)  {
       // Force the DPMS on since the driver doesn't always detect that it
       // should turn on. This is needed when coming back from idle suspend.
@@ skipping 13 matching lines @@
   if (output_state_ == new_state) {
     // Cancel software mirroring if the state is moving from
     // STATE_DUAL_EXTENDED to STATE_DUAL_EXTENDED.
     if (mirroring_controller_ && new_state == STATE_DUAL_EXTENDED)
       mirroring_controller_->SetSoftwareMirroring(false);
     NotifyOnDisplayChanged();
     return true;
   }
 
   delegate_->GrabServer();
-  std::vector<OutputSnapshot> outputs = delegate_->GetOutputs();
+  std::vector<OutputSnapshot> outputs =
+      delegate_->GetOutputs(state_controller_);
   bool success = EnterStateOrFallBackToSoftwareMirroring(
       new_state, power_state_, outputs);
   delegate_->UngrabServer();
 
   if (success) {
     NotifyOnDisplayChanged();
   } else {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChangeFailed(new_state));
   }
@@ skipping 71 matching lines @@
     delegate_->SyncWithServer();
   }
 }
 
 void OutputConfigurator::ResumeDisplays() {
   // Force probing to ensure that we pick up any changes that were made
   // while the system was suspended.
   SetDisplayPower(power_state_, kSetDisplayPowerForceProbe);
 }
 
+void OutputConfigurator::ScheduleConfigureOutputs() {
+  if (configure_timer_.get()) {
+    configure_timer_->Reset();
+  } else {
+    configure_timer_.reset(new base::OneShotTimer<OutputConfigurator>());
+    configure_timer_->Start(
+        FROM_HERE,
+        base::TimeDelta::FromMilliseconds(kConfigureDelayMs),
+        this,
+        &OutputConfigurator::ConfigureOutputs);
+  }
+}
+
 void OutputConfigurator::ConfigureOutputs() {
   configure_timer_.reset();
 
   delegate_->GrabServer();
-  std::vector<OutputSnapshot> outputs = delegate_->GetOutputs();
+  std::vector<OutputSnapshot> outputs =
+      delegate_->GetOutputs(state_controller_);
   OutputState new_state = GetOutputState(outputs, power_state_);
   bool success = EnterStateOrFallBackToSoftwareMirroring(
       new_state, power_state_, outputs);
   delegate_->UngrabServer();
 
   if (success) {
     NotifyOnDisplayChanged();
   } else {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChangeFailed(new_state));
   }
   delegate_->SendProjectingStateToPowerManager(IsProjecting(outputs));
 }
 
-void OutputConfigurator::ScheduleConfigureOutputs() {
-  if (configure_timer_.get()) {
-    configure_timer_->Reset();
-  } else {
-    configure_timer_.reset(new base::OneShotTimer<OutputConfigurator>());
-    configure_timer_->Start(
-        FROM_HERE,
-        base::TimeDelta::FromMilliseconds(kConfigureDelayMs),
-        this,
-        &OutputConfigurator::ConfigureOutputs);
-  }
-}
-
 void OutputConfigurator::NotifyOnDisplayChanged() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayModeChanged());
 }
 
 bool OutputConfigurator::EnterStateOrFallBackToSoftwareMirroring(
     OutputState output_state,
     DisplayPowerState power_state,
     const std::vector<OutputSnapshot>& outputs) {
   bool success = EnterState(output_state, power_state, outputs);
   if (mirroring_controller_) {
@@ skipping 31 matching lines @@
         LOG(WARNING) << "Ignoring request to enter single mode with "
                      << outputs.size() << " connected outputs and "
                      << num_on_outputs << " turned on";
         return false;
       }
 
       // Determine which output to use.
       const OutputSnapshot& output = outputs.size() == 1 ? outputs[0] :
           (output_power[0] ? outputs[0] : outputs[1]);
       int width = 0, height = 0;
-      if (!delegate_->GetModeDetails(output.native_mode, &width, &height, NULL))
+      if (!delegate_->GetModeDetails(
+              output.selected_mode, &width, &height, NULL))
         return false;
 
       std::vector<CrtcConfig> configs(outputs.size());
       for (size_t i = 0; i < outputs.size(); ++i) {
         configs[i] = CrtcConfig(
             outputs[i].crtc, 0, 0,
-            output_power[i] ? outputs[i].native_mode : None,
+            output_power[i] ? outputs[i].selected_mode : None,
             outputs[i].output);
       }
       delegate_->CreateFrameBuffer(width, height, configs);
 
       for (size_t i = 0; i < outputs.size(); ++i) {
         delegate_->ConfigureCrtc(&configs[i]);
         if (outputs[i].touch_device_id) {
           delegate_->ConfigureCTM(outputs[i].touch_device_id,
                                   CoordinateTransformation());
         }
@@ skipping 47 matching lines @@
                      << num_on_outputs << " turned on";
         return false;
       }
 
       // Pairs are [width, height] corresponding to the given output's mode.
       std::vector<std::pair<int, int> > mode_sizes(outputs.size());
       std::vector<CrtcConfig> configs(outputs.size());
       int width = 0, height = 0;
 
       for (size_t i = 0; i < outputs.size(); ++i) {
-        if (!delegate_->GetModeDetails(outputs[i].native_mode,
+        if (!delegate_->GetModeDetails(outputs[i].selected_mode,
                 &(mode_sizes[i].first), &(mode_sizes[i].second), NULL)) {
           return false;
         }
 
         configs[i] = CrtcConfig(
             outputs[i].crtc, 0, (height ? height + kVerticalGap : 0),
-            output_power[i] ? outputs[i].native_mode : None,
+            output_power[i] ? outputs[i].selected_mode : None,
             outputs[i].output);
 
         // Retain the full screen size even if all outputs are off so the
         // same desktop configuration can be restored when the outputs are
         // turned back on.
         width = std::max<int>(width, mode_sizes[i].first);
         height += (height ? kVerticalGap : 0) + mode_sizes[i].second;
       }
 
       delegate_->CreateFrameBuffer(width, height, configs);
@@ skipping 112 matching lines @@
   float width_ratio = static_cast<float>(mirror_mode_width) /
       static_cast<float>(native_mode_width);
   float height_ratio = static_cast<float>(mirror_mode_height) /
       static_cast<float>(native_mode_height);
 
   area_ratio = width_ratio * height_ratio;
   return area_ratio;
 }
 
 }  // namespace chromeos