chromeos: Make OutputConfigurator save latest config.

chromeos/display/real_output_configurator_delegate.cc

 // Copyright (c) 2013 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/real_output_configurator_delegate.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/dpms.h>
 #include <X11/extensions/XInput.h>
@@ skipping 120 matching lines @@
       if (!to_populate.has_display_id && to_populate.is_internal)
         to_populate.has_display_id = true;
 
       (outputs.empty() ? one_info : two_info) = output_info;
 
       // Now, look up the current CRTC and any related info.
       if (output_info->crtc) {
         XRRCrtcInfo* crtc_info = XRRGetCrtcInfo(
             display_, screen_, output_info->crtc);
         to_populate.current_mode = crtc_info->mode;
-        to_populate.height = crtc_info->height;
+        to_populate.x = crtc_info->x;
         to_populate.y = crtc_info->y;
         XRRFreeCrtcInfo(crtc_info);
       }
 
       // Assign a CRTC that isn't already in use.
       for (int j = 0; j < output_info->ncrtc; ++j) {
         if (output_info->crtcs[j] != last_used_crtc) {
           to_populate.crtc = output_info->crtcs[j];
           last_used_crtc = to_populate.crtc;
           break;
@@ skipping 93 matching lines @@
       if (height)
         *height = info.height;
       if (interlaced)
         *interlaced = info.modeFlags & RR_Interlace;
       return true;
     }
   }
   return false;
 }
 
-void RealOutputConfiguratorDelegate::ConfigureCrtc(
-    OutputConfigurator::CrtcConfig* config) {
+bool RealOutputConfiguratorDelegate::ConfigureCrtc(
+    RRCrtc crtc,
+    RRMode mode,
+    RROutput output,
+    int x,
+    int y) {
   CHECK(screen_) << "Server not grabbed";
-  VLOG(1) << "ConfigureCrtc: crtc=" << config->crtc
-          << " mode=" << config->mode
-          << " output=" << config->output
-          << " x=" << config->x
-          << " y=" << config->y;
-
-  RROutput* outputs = NULL;
-  int num_outputs = 0;
-  if (config->output && config->mode) {
-    outputs = &config->output;
-    num_outputs = 1;
-  }
-
-  XRRSetCrtcConfig(display_,
-                   screen_,
-                   config->crtc,
-                   CurrentTime,
-                   config->x,
-                   config->y,
-                   config->mode,
-                   RR_Rotate_0,
-                   outputs,
-                   num_outputs);
+  VLOG(1) << "ConfigureCrtc: crtc=" << crtc
+          << " mode=" << mode
+          << " output=" << output
+          << " x=" << x
+          << " y=" << y;
+  return XRRSetCrtcConfig(display_,
+                          screen_,
+                          crtc,
+                          CurrentTime,
+                          x,
+                          y,
+                          mode,
+                          RR_Rotate_0,
+                          (output && mode) ? &output : NULL,
+                          (output && mode) ? 1 : 0);
 }
 
 void RealOutputConfiguratorDelegate::CreateFrameBuffer(
     int width,
     int height,
-    const std::vector<OutputConfigurator::CrtcConfig>& configs) {
+    const std::vector<OutputConfigurator::OutputSnapshot>& outputs) {
   CHECK(screen_) << "Server not grabbed";
   int current_width = DisplayWidth(display_, DefaultScreen(display_));
   int current_height = DisplayHeight(display_, DefaultScreen(display_));
   VLOG(1) << "CreateFrameBuffer: new=" << width << "x" << height
           << " current=" << current_width << "x" << current_height;
   if (width ==  current_width && height == current_height)
     return;
 
-  DestroyUnusedCrtcs(configs);
+  DestroyUnusedCrtcs(outputs);
   int mm_width = width * kPixelsToMmScale;
   int mm_height = height * kPixelsToMmScale;
   XRRSetScreenSize(display_, window_, width, height, mm_width, mm_height);
 }
 
 void RealOutputConfiguratorDelegate::ConfigureCTM(
     int touch_device_id,
     const OutputConfigurator::CoordinateTransformation& ctm) {
   VLOG(1) << "ConfigureCTM: id=" << touch_device_id
           << " scale=" << ctm.x_scale << "x" << ctm.y_scale
@@ skipping 32 matching lines @@
   XIFreeDeviceInfo(info);
 }
 
 void RealOutputConfiguratorDelegate::SendProjectingStateToPowerManager(
     bool projecting) {
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
       SetIsProjecting(projecting);
 }
 
 void RealOutputConfiguratorDelegate::DestroyUnusedCrtcs(
-    const std::vector<OutputConfigurator::CrtcConfig>& configs) {
+    const std::vector<OutputConfigurator::OutputSnapshot>& outputs) {
   CHECK(screen_) << "Server not grabbed";
   // Setting the screen size will fail if any CRTC doesn't fit afterwards.
   // At the same time, turning CRTCs off and back on uses up a lot of time.
   // This function tries to be smart to avoid too many off/on cycles:
   // - We disable all the CRTCs we won't need after the FB resize.
   // - We set the new modes on CRTCs, if they fit in both the old and new
   //   FBs, and park them at (0,0)
   // - We disable the CRTCs we will need but don't fit in the old FB. Those
   //   will be reenabled after the resize.
   // We don't worry about the cached state of the outputs here since we are
   // not interested in the state we are setting - we just try to get the CRTCs
   // out of the way so we can rebuild the frame buffer.
   for (int i = 0; i < screen_->ncrtc; ++i) {
     // Default config is to disable the crtcs.
-    OutputConfigurator::CrtcConfig config(
-        screen_->crtcs[i], 0, 0, None, None);
-    for (std::vector<OutputConfigurator::CrtcConfig>::const_iterator it =
-         configs.begin(); it != configs.end(); ++it) {
-      if (config.crtc == it->crtc) {
-        config.mode = it->mode;
-        config.output = it->output;
+    RRCrtc crtc = screen_->crtcs[i];
+    RRMode mode = None;
+    RROutput output = None;
+    for (std::vector<OutputConfigurator::OutputSnapshot>::const_iterator it =
+         outputs.begin(); it != outputs.end(); ++it) {
+      if (crtc == it->crtc) {
+        mode = it->current_mode;
+        output = it->output;
         break;
       }
     }
 
-    if (config.mode != None) {
+    if (mode != None) {
       // In case our CRTC doesn't fit in our current framebuffer, disable it.
       // It'll get reenabled after we resize the framebuffer.
       int mode_width = 0, mode_height = 0;
-      CHECK(GetModeDetails(config.mode, &mode_width, &mode_height, NULL));
+      CHECK(GetModeDetails(mode, &mode_width, &mode_height, NULL));
       int current_width = DisplayWidth(display_, DefaultScreen(display_));
       int current_height = DisplayHeight(display_, DefaultScreen(display_));
       if (mode_width > current_width || mode_height > current_height) {
-        config.mode = None;
-        config.output = None;
+        mode = None;
+        output = None;
       }
     }
 
-    ConfigureCrtc(&config);
+    ConfigureCrtc(crtc, mode, output, 0, 0);
   }
 }
 
 bool RealOutputConfiguratorDelegate::IsOutputAspectPreservingScaling(
     RROutput id) {
   bool ret = false;
 
   Atom scaling_prop = XInternAtom(display_, "scaling mode", False);
   Atom full_aspect_atom = XInternAtom(display_, "Full aspect", False);
   if (scaling_prop == None || full_aspect_atom == None)
@@ skipping 186 matching lines @@
           << " id " << info[i].deviceid
           << " width " << width
           << " height " << height;
     }
   }
 
   XIFreeDeviceInfo(info);
 }
 
 }  // namespace chromeos