chromeos: Add testing support code to OutputConfigurator.

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 "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/power_manager_client.h"
 #include "chromeos/display/real_output_configurator_delegate.h"
 
 namespace chromeos {
 
 namespace {
 
 // Prefixes for the built-in displays.
 const char kInternal_LVDS[] = "LVDS";
 const char kInternal_eDP[] = "eDP";
 
 // The delay to perform configuration after RRNotify.  See the comment
 // in |Dispatch()|.
 const int64 kConfigureDelayMs = 500;
 
-// Gap between screens so cursor at bottom of active display doesn't partially
-// appear on top of inactive display. Higher numbers guard against larger
-// cursors, but also waste more memory.
-// For simplicity, this is hard-coded to 60 to avoid the complexity of always
-// determining the DPI of the screen and rationalizing which screen we need to
-// use for the DPI calculation.
-// See crbug.com/130188 for initial discussion.
-const int kVerticalGap = 60;
-
 // Returns a string describing |state|.
 std::string DisplayPowerStateToString(DisplayPowerState state) {
   switch (state) {
     case DISPLAY_POWER_ALL_ON:
       return "ALL_ON";
     case DISPLAY_POWER_ALL_OFF:
       return "ALL_OFF";
     case DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON:
       return "INTERNAL_OFF_EXTERNAL_ON";
     case DISPLAY_POWER_INTERNAL_ON_EXTERNAL_OFF:
@@ skipping 38 matching lines @@
         // At this point, we expect both displays to be in native mode and tiled
         // such that one is primary and another is correctly positioned as
         // secondary.  If any of these assumptions are false, this is an unknown
         // configuration.
         bool primary_native = (primary_mode == outputs[0].native_mode) ||
             (primary_mode == None);
         bool secondary_native = (secondary_mode == outputs[1].native_mode) ||
             (secondary_mode == None);
         if (primary_native && secondary_native) {
           // Just check the relative locations.
-          int secondary_offset = outputs[0].height + kVerticalGap;
+          int secondary_offset = outputs[0].height +
+              OutputConfigurator::kVerticalGap;
           if (outputs[0].y == 0 && outputs[1].y == secondary_offset) {
             state = STATE_DUAL_EXTENDED;
           } else {
             // Unexpected locations.
             state = STATE_DUAL_UNKNOWN;
           }
         } else {
           // Mode assumptions don't hold.
           state = STATE_DUAL_UNKNOWN;
         }
@@ skipping 50 matching lines @@
 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;
+  notify_event.subtype = RRNotify_OutputChange;
+  notify_event.connection = connected ? RR_Connected : RR_Disconnected;
+  configurator_->Dispatch(
+      reinterpret_cast<const base::NativeEvent>(&notify_event));
+
+  if (!configurator_->configure_timer_->IsRunning()) {
+    LOG(ERROR) << "ConfigureOutputs() timer not running";
+    return false;
+  }
+
+  configurator_->ConfigureOutputs();
+  return true;
+}
+
 // static
 bool OutputConfigurator::IsInternalOutputName(const std::string& name) {
   return name.find(kInternal_LVDS) == 0 || name.find(kInternal_eDP) == 0;
 }
 
 OutputConfigurator::OutputConfigurator()
     : state_controller_(NULL),
-      delegate_(new RealOutputConfiguratorDelegate()),
       configure_display_(base::chromeos::IsRunningOnChromeOS()),
       connected_output_count_(0),
       xrandr_event_base_(0),
       output_state_(STATE_INVALID),
       power_state_(DISPLAY_POWER_ALL_ON) {
 }
 
 OutputConfigurator::~OutputConfigurator() {}
 
+void OutputConfigurator::SetDelegateForTesting(
+    scoped_ptr<Delegate> delegate) {
+  delegate_.swap(delegate);

[oshima, 2013/04/08 17:29:15]

delegate_ = delegate.Pass();

is more common nowadays.

[Daniel Erat, 2013/04/08 21:47:53]

Done.

+  configure_display_ = true;
+}
+
 void OutputConfigurator::Init(bool is_panel_fitting_enabled,
                               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();
   if (outputs.size() > 1 && background_color_argb)
     delegate_->SetBackgroundColor(background_color_argb);
   delegate_->UngrabServer();
 }
 
 void OutputConfigurator::Start() {
+  if (!configure_display_)
+    return;
+
   delegate_->GrabServer();
-  // Detect our initial state.
   std::vector<OutputSnapshot> outputs = delegate_->GetOutputs();
   connected_output_count_ = outputs.size();
 
   output_state_ = InferCurrentState(outputs);
   // Ensure that we are in a supported state with all connected displays powered
   // on.
   OutputState starting_state = GetNextState(outputs);
   if (output_state_ != starting_state &&
       EnterState(starting_state, power_state_, outputs)) {
     output_state_ = starting_state;
   }
   bool is_projecting = IsProjecting(outputs);
 
   delegate_->InitXRandRExtension(&xrandr_event_base_);
 
   // Force the DPMS on chrome startup as the driver doesn't always detect
   // that all displays are on when signing out.
   delegate_->ForceDPMSOn();
-
-  // Relinquish X resources.
   delegate_->UngrabServer();
-
-  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
-      SetIsProjecting(is_projecting);
+  delegate_->SendProjectingStateToPowerManager(is_projecting);
 }
 
 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 (!configure_display_)
-    return false;
   if (power_state == power_state_ && !(flags & kSetDisplayPowerForceProbe))
     return true;
 
   delegate_->GrabServer();
   std::vector<OutputSnapshot> outputs = delegate_->GetOutputs();
   connected_output_count_ = outputs.size();
 
   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) &&
       EnterState(output_state_, power_state, outputs)) {
     power_state_ = power_state;
     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.
       delegate_->ForceDPMSOn();
     }
   }
 
   delegate_->UngrabServer();
   return true;
 }
 
 bool OutputConfigurator::SetDisplayMode(OutputState new_state) {
+  if (!configure_display_)
+    return false;
+
   if (output_state_ == STATE_INVALID ||
       output_state_ == STATE_HEADLESS ||
       output_state_ == STATE_SINGLE)
     return false;
 
   if (output_state_ == new_state)
     return true;
 
   delegate_->GrabServer();
   std::vector<OutputSnapshot> outputs = delegate_->GetOutputs();
   connected_output_count_ = outputs.size();
   if (EnterState(new_state, power_state_, outputs))
     output_state_ = new_state;
   delegate_->UngrabServer();
 
   if (output_state_ == new_state) {
     NotifyOnDisplayChanged();
   } else {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChangeFailed(new_state));
   }
   return true;
 }
 
 bool OutputConfigurator::Dispatch(const base::NativeEvent& event) {
-  if (event->type - xrandr_event_base_ == RRScreenChangeNotify)
-    delegate_->UpdateXRandRConfiguration(event);
-  // Ignore this event if the Xrandr extension isn't supported, or
-  // the device is being shutdown.
-  if (!configure_display_ ||
-      (event->type - xrandr_event_base_ != RRNotify)) {
+  if (event->type - xrandr_event_base_ == RRScreenChangeNotify) {
+    if (delegate_)

[oshima, 2013/04/08 17:29:15]

This is only place you check if it's NULL. How this can happen?

[Daniel Erat, 2013/04/08 21:47:53]

All of the other members return early on !configure_display_.  I'm preserving
this method's previous behavior of updating Xlib even if configure_display_ is
false, but I'll move the !configure_display_ test earlier if you think this
isn't needed.

[oshima, 2013/04/08 23:21:44]

I see. I think it's safe to move after configure_display_ because it can happen
only when we're shutting down and syncing state isn't important at this stage.

[Daniel Erat, 2013/04/09 00:21:34]

Done.

+      delegate_->UpdateXRandRConfiguration(event);
     return true;
   }
+
+  if (!configure_display_ || event->type - xrandr_event_base_ != RRNotify)
+    return true;
+
   XEvent* xevent = static_cast<XEvent*>(event);
   XRRNotifyEvent* notify_event =
       reinterpret_cast<XRRNotifyEvent*>(xevent);
   if (notify_event->subtype == RRNotify_OutputChange) {
     XRROutputChangeNotifyEvent* output_change_event =
         reinterpret_cast<XRROutputChangeNotifyEvent*>(xevent);
     if ((output_change_event->connection == RR_Connected) ||
         (output_change_event->connection == RR_Disconnected)) {
       // Connecting/Disconnecting display may generate multiple
       // RRNotify. Defer configuring outputs to avoid
       // grabbing X and configuring displays multiple times.
       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);
       }
     }
   }
 
   // Ignore the case of RR_UnknownConnection.
   return true;
 }
 
-void OutputConfigurator::ConfigureOutputs() {
-  configure_timer_.reset();
-
-  delegate_->GrabServer();
-  std::vector<OutputSnapshot> outputs = delegate_->GetOutputs();
-  int new_output_count = outputs.size();
-  // Don't skip even if the output counts didn't change because
-  // a display might have been swapped during the suspend.
-  connected_output_count_ = new_output_count;
-  OutputState new_state = GetNextState(outputs);
-  // When a display was swapped, the state moves from
-  // STATE_DUAL_EXTENDED to STATE_DUAL_EXTENDED, so don't rely on
-  // the state chagne to tell if it was successful.
-  bool success = EnterState(new_state, power_state_, outputs);
-  bool is_projecting = IsProjecting(outputs);
-  delegate_->UngrabServer();
-
-  if (success) {
-    output_state_ = new_state;
-    NotifyOnDisplayChanged();
-  } else {
-    FOR_EACH_OBSERVER(
-        Observer, observers_, OnDisplayModeChangeFailed(new_state));
-  }
-  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
-      SetIsProjecting(is_projecting);
-}
-
 void OutputConfigurator::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void OutputConfigurator::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void OutputConfigurator::SuspendDisplays() {
   // If the display is off due to user inactivity and there's only a single
@@ skipping 11 matching lines @@
   // racing with the HandleSuspendReadiness message.
   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::ConfigureOutputs() {
+  configure_timer_.reset();
+
+  delegate_->GrabServer();
+  std::vector<OutputSnapshot> outputs = delegate_->GetOutputs();
+  int new_output_count = outputs.size();
+  // Don't skip even if the output counts didn't change because
+  // a display might have been swapped during the suspend.
+  connected_output_count_ = new_output_count;
+  OutputState new_state = GetNextState(outputs);
+  // When a display was swapped, the state moves from
+  // STATE_DUAL_EXTENDED to STATE_DUAL_EXTENDED, so don't rely on
+  // the state chagne to tell if it was successful.
+  bool success = EnterState(new_state, power_state_, outputs);
+  bool is_projecting = IsProjecting(outputs);
+  delegate_->UngrabServer();
+
+  if (success) {
+    output_state_ = new_state;
+    NotifyOnDisplayChanged();
+  } else {
+    FOR_EACH_OBSERVER(
+        Observer, observers_, OnDisplayModeChangeFailed(new_state));
+  }
+  delegate_->SendProjectingStateToPowerManager(is_projecting);
+}
+
 void OutputConfigurator::NotifyOnDisplayChanged() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayModeChanged());
 }
 
 bool OutputConfigurator::EnterState(
     OutputState output_state,
     DisplayPowerState power_state,
     const std::vector<OutputSnapshot>& outputs) {
   std::vector<bool> output_power(outputs.size());
   bool all_outputs_off = true;
@@ skipping 69 matching lines @@
         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,
                   &(mode_sizes[i].first), &(mode_sizes[i].second), NULL)) {
             return false;
           }
 
           configs[i] = CrtcConfig(
-              outputs[i].crtc, 0, height,
+              outputs[i].crtc, 0, (height ? height + kVerticalGap : 0),
               output_power[i] ? outputs[i].native_mode : None,
               outputs[i].output);
 
           // Retain the full screen size if all outputs are off so the same
           // desktop configuration can be restored when the outputs are
           // turned back on.
           if (output_power[i] || all_outputs_off) {
             width = std::max<int>(width, mode_sizes[i].first);
             height += (height ? kVerticalGap : 0) + mode_sizes[i].second;
           }
@@ skipping 77 matching lines @@
     ctm.y_offset = 0.0;
     ctm.x_scale = native_mode_ar / mirror_mode_ar;
     ctm.x_offset = (mirror_mode_ar / native_mode_ar - 1.0) * 0.5;
     return ctm;
   }
 
   return ctm;  // Same aspect ratio - return identity
 }
 
 }  // namespace chromeos