Add display task to trigger display configuration

ui/display/chromeos/display_configurator.cc

 // Copyright 2014 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 "ui/display/chromeos/display_configurator.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
+#include "ui/display/chromeos/display_util.h"
 #include "ui/display/display_switches.h"
 #include "ui/display/types/display_mode.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/native_display_delegate.h"
 
 namespace ui {
 
 namespace {
 
 typedef std::vector<const DisplayMode*> DisplayModeList;
 
 // The delay to perform configuration after RRNotify. See the comment for
 // |configure_timer_|.
 const int kConfigureDelayMs = 500;
 
 // The delay spent before reading the display configuration after coming out of
 // suspend. While coming out of suspend the display state may be updating. This
 // is used to wait until the hardware had a chance to update the display state
 // such that we read an up to date state.
 const int kResumeDelayMs = 500;
 
-// Returns a string describing |state|.
-std::string DisplayPowerStateToString(chromeos::DisplayPowerState state) {
-  switch (state) {
-    case chromeos::DISPLAY_POWER_ALL_ON:
-      return "ALL_ON";
-    case chromeos::DISPLAY_POWER_ALL_OFF:
-      return "ALL_OFF";
-    case chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON:
-      return "INTERNAL_OFF_EXTERNAL_ON";
-    case chromeos::DISPLAY_POWER_INTERNAL_ON_EXTERNAL_OFF:
-      return "INTERNAL_ON_EXTERNAL_OFF";
-    default:
-      return "unknown (" + base::IntToString(state) + ")";
-  }
-}
-
-// Returns a string describing |state|.
-std::string DisplayStateToString(MultipleDisplayState state) {
-  switch (state) {
-    case MULTIPLE_DISPLAY_STATE_INVALID:
-      return "INVALID";
-    case MULTIPLE_DISPLAY_STATE_HEADLESS:
-      return "HEADLESS";
-    case MULTIPLE_DISPLAY_STATE_SINGLE:
-      return "SINGLE";
-    case MULTIPLE_DISPLAY_STATE_DUAL_MIRROR:
-      return "DUAL_MIRROR";
-    case MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED:
-      return "DUAL_EXTENDED";
-    case MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED:
-      return "MULTI_EXTENDED";
-  }
-  NOTREACHED() << "Unknown state " << state;
-  return "INVALID";
-}
-
-// Returns the number of displays in |displays| that should be turned on, per
-// |state|.  If |display_power| is non-NULL, it is updated to contain the
-// on/off state of each corresponding entry in |displays|.
-int GetDisplayPower(
-    const std::vector<DisplayConfigurator::DisplayState>& display_states,
-    chromeos::DisplayPowerState state,
-    std::vector<bool>* display_power) {
-  int num_on_displays = 0;
-  if (display_power)
-    display_power->resize(display_states.size());
-
-  for (size_t i = 0; i < display_states.size(); ++i) {
-    bool internal =
-        display_states[i].display->type() == DISPLAY_CONNECTION_TYPE_INTERNAL;
-    bool on =
-        state == chromeos::DISPLAY_POWER_ALL_ON ||
-        (state == chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON &&
-         !internal) ||
-        (state == chromeos::DISPLAY_POWER_INTERNAL_ON_EXTERNAL_OFF && internal);
-    if (display_power)
-      (*display_power)[i] = on;
-    if (on)
-      num_on_displays++;
-  }
-  return num_on_displays;
-}
-
 }  // namespace
 
 
 const int DisplayConfigurator::kSetDisplayPowerNoFlags = 0;
 const int DisplayConfigurator::kSetDisplayPowerForceProbe = 1 << 0;
 const int
 DisplayConfigurator::kSetDisplayPowerOnlyIfSingleInternalDisplay = 1 << 1;
 
 DisplayConfigurator::DisplayState::DisplayState()
     : display(NULL),
@@ skipping 411 matching lines @@
   native_display_delegate_->UngrabServer();
   if (attempted_change)
     NotifyObservers(success, new_state);
   return success;
 }
 
 bool DisplayConfigurator::SetDisplayMode(MultipleDisplayState new_state) {
   if (!configure_display_ || display_externally_controlled_)
     return false;
 
-  VLOG(1) << "SetDisplayMode: state=" << DisplayStateToString(new_state);
+  VLOG(1) << "SetDisplayMode: state="
+          << MultipleDisplayStateToString(new_state);
   if (display_state_ == new_state) {
     // Cancel software mirroring if the state is moving from
     // MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED to
     // MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED.
     if (mirroring_controller_ &&
         new_state == MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED)
       mirroring_controller_->SetSoftwareMirroring(false);
     NotifyObservers(true, new_state);
     return true;
   }
@@ skipping 251 matching lines @@
     mirroring_controller_->SetSoftwareMirroring(enable_software_mirroring);
   }
   return success;
 }
 
 bool DisplayConfigurator::EnterState(MultipleDisplayState display_state,
                                      chromeos::DisplayPowerState power_state) {
   std::vector<bool> display_power;
   int num_on_displays =
       GetDisplayPower(cached_displays_, power_state, &display_power);
-  VLOG(1) << "EnterState: display=" << DisplayStateToString(display_state)
+  VLOG(1) << "EnterState: display="
+          << MultipleDisplayStateToString(display_state)
           << " power=" << DisplayPowerStateToString(power_state);
 
   // Save the requested state so we'll try to use it next time even if we fail.
   requested_power_state_ = power_state;
 
   // Framebuffer dimensions.
   gfx::Size size;
 
   std::vector<gfx::Point> new_origins(cached_displays_.size(), gfx::Point());
   std::vector<const DisplayMode*> new_mode;
@@ skipping 195 matching lines @@
 
         return state_controller_->GetStateForDisplayIds(display_ids);
       }
       NOTREACHED();
     }
   }
   return MULTIPLE_DISPLAY_STATE_INVALID;
 }
 
 }  // namespace ui