chromeos: Make OutputConfigurator save latest config.

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 80 matching lines @@
   for (size_t i = 0; i < outputs.size(); ++i)
     has_internal_output |= outputs[i].is_internal;
 
   // "Projecting" is defined as having more than 1 output connected while at
   // least one of them is an internal output.
   return has_internal_output && (connected_output_count > 1);
 }
 
 }  // namespace
 
+OutputConfigurator::CoordinateTransformation::CoordinateTransformation()
+    : x_scale(1.0),
+      x_offset(0.0),
+      y_scale(1.0),
+      y_offset(0.0) {}
+
 OutputConfigurator::OutputSnapshot::OutputSnapshot()
     : output(None),
       crtc(None),
       current_mode(None),
       native_mode(None),
       mirror_mode(None),
       selected_mode(None),
+      x(0),
       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),
-    x_offset(0.0),
-    y_scale(1.0),
-    y_offset(0.0) {}
-
-OutputConfigurator::CrtcConfig::CrtcConfig()
-    : crtc(None),
-      x(0),
-      y(0),
-      mode(None),
-      output(None) {}
-
-OutputConfigurator::CrtcConfig::CrtcConfig(RRCrtc crtc,
-                                           int x, int y,
-                                           RRMode mode,
-                                           RROutput output)
-    : crtc(crtc),
-      x(x),
-      y(y),
-      mode(mode),
-      output(output) {}
-
 bool OutputConfigurator::TestApi::SendOutputChangeEvents(bool connected) {
   XRRScreenChangeNotifyEvent screen_event;
   memset(&screen_event, 0, sizeof(screen_event));
   screen_event.type = xrandr_event_base_ + RRScreenChangeNotify;
   configurator_->Dispatch(
       reinterpret_cast<const base::NativeEvent>(&screen_event));
 
   XRROutputChangeNotifyEvent notify_event;
   memset(&notify_event, 0, sizeof(notify_event));
   notify_event.type = xrandr_event_base_ + RRNotify;
@@ skipping 262 matching lines @@
 }
 
 bool OutputConfigurator::EnterState(
     OutputState output_state,
     DisplayPowerState power_state,
     const std::vector<OutputSnapshot>& outputs) {
   std::vector<bool> output_power;
   int num_on_outputs = GetOutputPower(outputs, power_state, &output_power);
   VLOG(1) << "EnterState: output=" << OutputStateToString(output_state)
           << " power=" << DisplayPowerStateToString(power_state);
+
+  // Framebuffer dimensions.
+  int width = 0, height = 0;
+  std::vector<OutputSnapshot> updated_outputs = outputs;
+
   switch (output_state) {
     case STATE_HEADLESS:

[oshima, 2013/08/08 01:19:49]

do you think we can nuke STATE_HEADLESS?

[Daniel Erat, 2013/08/08 16:07:37]

What's the alternate proposal? Do you think we should use STATE_SINGLE when a
Chromebox doesn't have any displays connected?

[oshima, 2013/08/08 16:52:09]

Exit early if there is no output and just leave the state as is.
Not sure if that's possible, or better though. Just wondering because
chrome has no headless state and just ignores such change.

       if (outputs.size() != 0) {
         LOG(WARNING) << "Ignoring request to enter headless mode with "
                      << outputs.size() << " connected output(s)";
         return false;
       }
       break;
     case STATE_SINGLE: {
       // If there are multiple outputs connected, only one should be turned on.
       if (outputs.size() != 1 && num_on_outputs != 1) {
         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.selected_mode, &width, &height, NULL))
-        return false;
+      for (size_t i = 0; i < updated_outputs.size(); ++i) {
+        OutputSnapshot* output = &updated_outputs[i];
+        output->x = 0;
+        output->y = 0;
+        output->current_mode = output_power[i] ? output->selected_mode : None;
 
-      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].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());
+        if (output_power[i] || outputs.size() == 1) {
+          if (!delegate_->GetModeDetails(
+                  output->selected_mode, &width, &height, NULL))
+            return false;
         }
       }
       break;
     }
     case STATE_DUAL_MIRROR: {
       if (outputs.size() != 2 || (num_on_outputs != 0 && num_on_outputs != 2)) {
         LOG(WARNING) << "Ignoring request to enter mirrored mode with "
                      << outputs.size() << " connected output(s) and "
                      << num_on_outputs << " turned on";
         return false;
       }
 
-      int width = 0, height = 0;
       if (!delegate_->GetModeDetails(
-              outputs[0].mirror_mode, &width, &height, NULL)) {
+              outputs[0].mirror_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].mirror_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) {
-          CoordinateTransformation ctm;
+        OutputSnapshot* output = &updated_outputs[i];
+        output->x = 0;
+        output->y = 0;
+        output->current_mode = output_power[i] ? output->mirror_mode : None;
+        if (output->touch_device_id) {
           // CTM needs to be calculated if aspect preserving scaling is used.
           // Otherwise, assume it is full screen, and use identity CTM.
-          if (outputs[i].mirror_mode != outputs[i].native_mode &&
-              outputs[i].is_aspect_preserving_scaling) {
-            ctm = GetMirrorModeCTM(&outputs[i]);
-            mirrored_display_area_ratio_map_[outputs[i].touch_device_id] =
-              GetMirroredDisplayAreaRatio(&outputs[i]);
+          if (output->mirror_mode != output->native_mode &&
+              output->is_aspect_preserving_scaling) {
+            output->transform = GetMirrorModeCTM(output);
+            mirrored_display_area_ratio_map_[output->touch_device_id] =
+                GetMirroredDisplayAreaRatio(output);
           }
-          delegate_->ConfigureCTM(outputs[i].touch_device_id, ctm);
         }
       }
       break;
     }
     case STATE_DUAL_EXTENDED: {
       if (outputs.size() != 2 || (num_on_outputs != 0 && num_on_outputs != 2)) {
         LOG(WARNING) << "Ignoring request to enter extended mode with "
                      << outputs.size() << " connected output(s) and "
                      << 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].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].selected_mode : None,
-            outputs[i].output);
+        OutputSnapshot* output = &updated_outputs[i];
+        output->x = 0;
+        output->y = height ? height + kVerticalGap : 0;
+        output->current_mode = output_power[i] ? output->selected_mode : None;
 
         // 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);
-
       for (size_t i = 0; i < outputs.size(); ++i) {
-        delegate_->ConfigureCrtc(&configs[i]);
-        if (outputs[i].touch_device_id) {
-          CoordinateTransformation ctm;
-          ctm.x_scale = static_cast<float>(mode_sizes[i].first) / width;
-          ctm.x_offset = static_cast<float>(configs[i].x) / width;
-          ctm.y_scale = static_cast<float>(mode_sizes[i].second) / height;
-          ctm.y_offset = static_cast<float>(configs[i].y) / height;
-          delegate_->ConfigureCTM(outputs[i].touch_device_id, ctm);
+        OutputSnapshot* output = &updated_outputs[i];
+        if (output->touch_device_id) {
+          CoordinateTransformation* ctm = &(output->transform);
+          ctm->x_scale = static_cast<float>(mode_sizes[i].first) / width;
+          ctm->x_offset = static_cast<float>(output->x) / width;
+          ctm->y_scale = static_cast<float>(mode_sizes[i].second) / height;
+          ctm->y_offset = static_cast<float>(output->y) / height;
         }
       }
       break;
     }
     default:
       NOTREACHED() << "Got request to enter output state " << output_state
                    << " with " << outputs.size() << " output(s)";
       return false;

[oshima, 2013/08/08 01:19:49]

let's remove default because output_state is enum.

[Daniel Erat, 2013/08/08 16:07:37]

It was covering STATE_INVALID. I've added a separate case for this.

   }
 
+  // Finally, apply the desired changes.
+  DCHECK_EQ(outputs.size(), updated_outputs.size());
+  if (!outputs.empty()) {
+    delegate_->CreateFrameBuffer(width, height, updated_outputs);
+    for (size_t i = 0; i < 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);
+      } else {
+        LOG(WARNING) << "Unable to configure CRTC " << output.crtc << ":"
+                     << " mode=" << output.current_mode
+                     << " output=" << output.output
+                     << " x=" << output.x
+                     << " y=" << output.y;
+        updated_outputs[i] = outputs[i];
+      }
+    }
+  }
+
   output_state_ = output_state;
   power_state_ = power_state;
+  cached_outputs_ = updated_outputs;
   return true;
 }
 
 OutputState OutputConfigurator::GetOutputState(
     const std::vector<OutputSnapshot>& outputs,
     DisplayPowerState power_state) const {
   int num_on_outputs = GetOutputPower(outputs, power_state, NULL);
   switch (outputs.size()) {
     case 0:
       return STATE_HEADLESS;
@@ skipping 80 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