Moving display constants from OutputConfigurator to ui/display

Before defining DisplayMode, DisplaySnapshot, NativeDisplayDelegate,
etc. in ui/display and updating OutputConfigurator to use these 
components, moving all the enums required by these components.

BUG=333413

Review URL: https://codereview.chromium.org/154613002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@250713 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 189 insertions, 228 deletions

diff --git a/chromeos/DEPS b/chromeos/DEPS
index a88fc06..aee6983 100644
--- a/chromeos/DEPS
+++ b/chromeos/DEPS
@@ -3,4 +3,5 @@ include_rules = [
   "+net",
   "+third_party/cros_system_api",
   "+third_party/libxml",
+  "+ui/display",
 ]
diff --git a/chromeos/chromeos.gyp b/chromeos/chromeos.gyp
index ec7fbcb..1597cb6 100644
--- a/chromeos/chromeos.gyp
+++ b/chromeos/chromeos.gyp
@@ -25,6 +25,7 @@
         '../dbus/dbus.gyp:dbus',
         '../net/net.gyp:net',
         '../third_party/libxml/libxml.gyp:libxml',
+        '../ui/display/display.gyp:display',
         '../url/url.gyp:url_lib',
         'ime/input_method.gyp:gencode',
         'power_manager_proto',
diff --git a/chromeos/display/native_display_delegate_x11.cc b/chromeos/display/native_display_delegate_x11.cc
index 22d0e1e..19f1ef8 100644
--- a/chromeos/display/native_display_delegate_x11.cc
+++ b/chromeos/display/native_display_delegate_x11.cc
@@ -254,24 +254,24 @@ OutputConfigurator::OutputSnapshot NativeDisplayDelegateX11::InitOutputSnapshot(
 
   std::string name(info->name);
   if (is_internal) {
-    output.type = OUTPUT_TYPE_INTERNAL;
+    output.type = ui::OUTPUT_TYPE_INTERNAL;
   } else if (name.find(kOutputName_VGA) == 0) {
-    output.type = OUTPUT_TYPE_VGA;
+    output.type = ui::OUTPUT_TYPE_VGA;
   } else if (name.find(kOutputName_HDMI) == 0) {
-    output.type = OUTPUT_TYPE_HDMI;
+    output.type = ui::OUTPUT_TYPE_HDMI;
   } else if (name.find(kOutputName_DVI) == 0) {
-    output.type = OUTPUT_TYPE_DVI;
+    output.type = ui::OUTPUT_TYPE_DVI;
   } else if (name.find(kOutputName_DisplayPort) == 0) {
-    output.type = OUTPUT_TYPE_DISPLAYPORT;
+    output.type = ui::OUTPUT_TYPE_DISPLAYPORT;
   } else {
     LOG(ERROR) << "Unknown link type: " << name;
-    output.type = OUTPUT_TYPE_UNKNOWN;
+    output.type = ui::OUTPUT_TYPE_UNKNOWN;
   }
 
   return output;
 }
 
-bool NativeDisplayDelegateX11::GetHDCPState(RROutput id, HDCPState* state) {
+bool NativeDisplayDelegateX11::GetHDCPState(RROutput id, ui::HDCPState* state) {
   unsigned char* values = NULL;
   int actual_format = 0;
   unsigned long nitems = 0;
@@ -305,13 +305,13 @@ bool NativeDisplayDelegateX11::GetHDCPState(RROutput id, HDCPState* state) {
              actual_format == 32 && nitems == 1) {
     Atom value = reinterpret_cast<Atom*>(values)[0];
     if (value == XInternAtom(display_, kProtectionUndesiredAtomName, False)) {
-      *state = HDCP_STATE_UNDESIRED;
+      *state = ui::HDCP_STATE_UNDESIRED;
     } else if (value ==
                XInternAtom(display_, kProtectionDesiredAtomName, False)) {
-      *state = HDCP_STATE_DESIRED;
+      *state = ui::HDCP_STATE_DESIRED;
     } else if (value ==
                XInternAtom(display_, kProtectionEnabledAtomName, False)) {
-      *state = HDCP_STATE_ENABLED;
+      *state = ui::HDCP_STATE_ENABLED;
     } else {
       LOG(ERROR) << "Unknown " << kContentProtectionAtomName
                  << " value: " << value;
@@ -328,14 +328,14 @@ bool NativeDisplayDelegateX11::GetHDCPState(RROutput id, HDCPState* state) {
   return ok;
 }
 
-bool NativeDisplayDelegateX11::SetHDCPState(RROutput id, HDCPState state) {
+bool NativeDisplayDelegateX11::SetHDCPState(RROutput id, ui::HDCPState state) {
   Atom name = XInternAtom(display_, kContentProtectionAtomName, False);
   Atom value = None;
   switch (state) {
-    case HDCP_STATE_UNDESIRED:
+    case ui::HDCP_STATE_UNDESIRED:
       value = XInternAtom(display_, kProtectionUndesiredAtomName, False);
       break;
-    case HDCP_STATE_DESIRED:
+    case ui::HDCP_STATE_DESIRED:
       value = XInternAtom(display_, kProtectionDesiredAtomName, False);
       break;
     default:
diff --git a/chromeos/display/native_display_delegate_x11.h b/chromeos/display/native_display_delegate_x11.h
index fbce154..b204731 100644
--- a/chromeos/display/native_display_delegate_x11.h
+++ b/chromeos/display/native_display_delegate_x11.h
@@ -48,8 +48,8 @@ class NativeDisplayDelegateX11
       int width,
       int height,
       const std::vector<OutputConfigurator::OutputSnapshot>& outputs) OVERRIDE;
-  virtual bool GetHDCPState(RROutput id, HDCPState* state) OVERRIDE;
-  virtual bool SetHDCPState(RROutput id, HDCPState state) OVERRIDE;
+  virtual bool GetHDCPState(RROutput id, ui::HDCPState* state) OVERRIDE;
+  virtual bool SetHDCPState(RROutput id, ui::HDCPState state) OVERRIDE;
 
  private:
   // Initializes |mode_info| to contain details corresponding to |mode|. Returns
diff --git a/chromeos/display/output_configurator.cc b/chromeos/display/output_configurator.cc
index 22b9fb3..553bb1a 100644
--- a/chromeos/display/output_configurator.cc
+++ b/chromeos/display/output_configurator.cc
@@ -43,17 +43,17 @@ std::string DisplayPowerStateToString(DisplayPowerState state) {
 }
 
 // Returns a string describing |state|.
-std::string OutputStateToString(OutputState state) {
+std::string OutputStateToString(ui::OutputState state) {
   switch (state) {
-    case STATE_INVALID:
+    case ui::OUTPUT_STATE_INVALID:
       return "INVALID";
-    case STATE_HEADLESS:
+    case ui::OUTPUT_STATE_HEADLESS:
       return "HEADLESS";
-    case STATE_SINGLE:
+    case ui::OUTPUT_STATE_SINGLE:
       return "SINGLE";
-    case STATE_DUAL_MIRROR:
+    case ui::OUTPUT_STATE_DUAL_MIRROR:
       return "DUAL_MIRROR";
-    case STATE_DUAL_EXTENDED:
+    case ui::OUTPUT_STATE_DUAL_EXTENDED:
       return "DUAL_EXTENDED";
   }
   NOTREACHED() << "Unknown state " << state;
@@ -95,7 +95,7 @@ int GetOutputPower(
     output_power->resize(outputs.size());
 
   for (size_t i = 0; i < outputs.size(); ++i) {
-    bool internal = outputs[i].type == OUTPUT_TYPE_INTERNAL;
+    bool internal = outputs[i].type == ui::OUTPUT_TYPE_INTERNAL;
     bool on = state == DISPLAY_POWER_ALL_ON ||
         (state == DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON && !internal) ||
         (state == DISPLAY_POWER_INTERNAL_ON_EXTERNAL_OFF && internal);
@@ -142,7 +142,7 @@ OutputConfigurator::OutputSnapshot::OutputSnapshot()
       width_mm(0),
       height_mm(0),
       is_aspect_preserving_scaling(false),
-      type(OUTPUT_TYPE_UNKNOWN),
+      type(ui::OUTPUT_TYPE_UNKNOWN),
       touch_device_id(0),
       display_id(0),
       has_display_id(false),
@@ -237,7 +237,7 @@ OutputConfigurator::OutputConfigurator()
       is_panel_fitting_enabled_(false),
       configure_display_(base::SysInfo::IsRunningOnChromeOS()),
       xrandr_event_base_(0),
-      output_state_(STATE_INVALID),
+      output_state_(ui::OUTPUT_STATE_INVALID),
       power_state_(DISPLAY_POWER_ALL_ON),
       next_output_protection_client_id_(1) {}
 
@@ -255,7 +255,7 @@ void OutputConfigurator::SetTouchscreenDelegateForTesting(
 }
 
 void OutputConfigurator::SetInitialDisplayPower(DisplayPowerState power_state) {
-  DCHECK_EQ(output_state_, STATE_INVALID);
+  DCHECK_EQ(output_state_, ui::OUTPUT_STATE_INVALID);
   power_state_ = power_state;
 }
 
@@ -281,7 +281,7 @@ void OutputConfigurator::Start(uint32 background_color_argb) {
   UpdateCachedOutputs();
   if (cached_outputs_.size() > 1 && background_color_argb)
     native_display_delegate_->SetBackgroundColor(background_color_argb);
-  const OutputState new_state = ChooseOutputState(power_state_);
+  const ui::OutputState new_state = ChooseOutputState(power_state_);
   const bool success = EnterStateOrFallBackToSoftwareMirroring(
       new_state, power_state_);
 
@@ -302,25 +302,26 @@ bool OutputConfigurator::ApplyProtections(const DisplayProtections& requests) {
     if (request_it != requests.end())
       all_desired = request_it->second;
     switch (it->type) {
-      case OUTPUT_TYPE_UNKNOWN:
+      case ui::OUTPUT_TYPE_UNKNOWN:
         return false;
       // DisplayPort, DVI, and HDMI all support HDCP.
-      case OUTPUT_TYPE_DISPLAYPORT:
-      case OUTPUT_TYPE_DVI:
-      case OUTPUT_TYPE_HDMI: {
-        HDCPState new_desired_state =
-            (all_desired & OUTPUT_PROTECTION_METHOD_HDCP) ?
-            HDCP_STATE_DESIRED : HDCP_STATE_UNDESIRED;
+      case ui::OUTPUT_TYPE_DISPLAYPORT:
+      case ui::OUTPUT_TYPE_DVI:
+      case ui::OUTPUT_TYPE_HDMI: {
+        ui::HDCPState new_desired_state =
+            (all_desired & ui::OUTPUT_PROTECTION_METHOD_HDCP)
+                ? ui::HDCP_STATE_DESIRED
+                : ui::HDCP_STATE_UNDESIRED;
         if (!native_display_delegate_->SetHDCPState(this_id, new_desired_state))
           return false;
         break;
       }
-      case OUTPUT_TYPE_INTERNAL:
-      case OUTPUT_TYPE_VGA:
-      case OUTPUT_TYPE_NETWORK:
+      case ui::OUTPUT_TYPE_INTERNAL:
+      case ui::OUTPUT_TYPE_VGA:
+      case ui::OUTPUT_TYPE_NETWORK:
         // No protections for these types. Do nothing.
         break;
-      case OUTPUT_TYPE_NONE:
+      case ui::OUTPUT_TYPE_NONE:
         NOTREACHED();
         break;
     }
@@ -373,27 +374,27 @@ bool OutputConfigurator::QueryOutputProtectionStatus(
       continue;
     *link_mask |= it->type;
     switch (it->type) {
-      case OUTPUT_TYPE_UNKNOWN:
+      case ui::OUTPUT_TYPE_UNKNOWN:
         return false;
       // DisplayPort, DVI, and HDMI all support HDCP.
-      case OUTPUT_TYPE_DISPLAYPORT:
-      case OUTPUT_TYPE_DVI:
-      case OUTPUT_TYPE_HDMI: {
-        HDCPState state;
+      case ui::OUTPUT_TYPE_DISPLAYPORT:
+      case ui::OUTPUT_TYPE_DVI:
+      case ui::OUTPUT_TYPE_HDMI: {
+        ui::HDCPState state;
         if (!native_display_delegate_->GetHDCPState(this_id, &state))
           return false;
-        if (state == HDCP_STATE_ENABLED)
-          enabled |= OUTPUT_PROTECTION_METHOD_HDCP;
+        if (state == ui::HDCP_STATE_ENABLED)
+          enabled |= ui::OUTPUT_PROTECTION_METHOD_HDCP;
         else
-          unfulfilled |= OUTPUT_PROTECTION_METHOD_HDCP;
+          unfulfilled |= ui::OUTPUT_PROTECTION_METHOD_HDCP;
         break;
       }
-      case OUTPUT_TYPE_INTERNAL:
-      case OUTPUT_TYPE_VGA:
-      case OUTPUT_TYPE_NETWORK:
+      case ui::OUTPUT_TYPE_INTERNAL:
+      case ui::OUTPUT_TYPE_VGA:
+      case ui::OUTPUT_TYPE_NETWORK:
         // No protections for these types. Do nothing.
         break;
-      case OUTPUT_TYPE_NONE:
+      case ui::OUTPUT_TYPE_NONE:
         NOTREACHED();
         break;
     }
@@ -436,7 +437,7 @@ bool OutputConfigurator::EnableOutputProtection(
   if (!ApplyProtections(protections))
     return false;
 
-  if (desired_method_mask == OUTPUT_PROTECTION_METHOD_NONE) {
+  if (desired_method_mask == ui::OUTPUT_PROTECTION_METHOD_NONE) {
     if (client_protection_requests_.find(client_id) !=
         client_protection_requests_.end()) {
       client_protection_requests_[client_id].erase(display_id);
@@ -470,7 +471,7 @@ bool OutputConfigurator::SetDisplayPower(DisplayPowerState power_state,
   native_display_delegate_->GrabServer();
   UpdateCachedOutputs();
 
-  const OutputState new_state = ChooseOutputState(power_state);
+  const ui::OutputState new_state = ChooseOutputState(power_state);
   bool attempted_change = false;
   bool success = false;
 
@@ -478,7 +479,7 @@ bool OutputConfigurator::SetDisplayPower(DisplayPowerState power_state,
       flags & kSetDisplayPowerOnlyIfSingleInternalDisplay;
   bool single_internal_display =
       cached_outputs_.size() == 1 &&
-      cached_outputs_[0].type == OUTPUT_TYPE_INTERNAL;
+      cached_outputs_[0].type == ui::OUTPUT_TYPE_INTERNAL;
   if (single_internal_display || !only_if_single_internal_display) {
     success = EnterStateOrFallBackToSoftwareMirroring(new_state, power_state);
     attempted_change = true;
@@ -495,15 +496,15 @@ bool OutputConfigurator::SetDisplayPower(DisplayPowerState power_state,
   return true;
 }
 
-bool OutputConfigurator::SetDisplayMode(OutputState new_state) {
+bool OutputConfigurator::SetDisplayMode(ui::OutputState new_state) {
   if (!configure_display_)
     return false;
 
   VLOG(1) << "SetDisplayMode: state=" << OutputStateToString(new_state);
   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)
+    // OUTPUT_STATE_DUAL_EXTENDED to OUTPUT_STATE_DUAL_EXTENDED.
+    if (mirroring_controller_ && new_state == ui::OUTPUT_STATE_DUAL_EXTENDED)
       mirroring_controller_->SetSoftwareMirroring(false);
     NotifyObservers(true, new_state);
     return true;
@@ -660,8 +661,8 @@ void OutputConfigurator::UpdateCachedOutputs() {
 
   // Set |mirror_mode| fields.
   if (cached_outputs_.size() == 2) {
-    bool one_is_internal = cached_outputs_[0].type == OUTPUT_TYPE_INTERNAL;
-    bool two_is_internal = cached_outputs_[1].type == OUTPUT_TYPE_INTERNAL;
+    bool one_is_internal = cached_outputs_[0].type == ui::OUTPUT_TYPE_INTERNAL;
+    bool two_is_internal = cached_outputs_[1].type == ui::OUTPUT_TYPE_INTERNAL;
     int internal_outputs = (one_is_internal ? 1 : 0) +
         (two_is_internal ? 1 : 0);
     DCHECK_LT(internal_outputs, 2);
@@ -766,7 +767,7 @@ void OutputConfigurator::ConfigureOutputs() {
 
   native_display_delegate_->GrabServer();
   UpdateCachedOutputs();
-  const OutputState new_state = ChooseOutputState(power_state_);
+  const ui::OutputState new_state = ChooseOutputState(power_state_);
   const bool success = EnterStateOrFallBackToSoftwareMirroring(
       new_state, power_state_);
   native_display_delegate_->UngrabServer();
@@ -775,7 +776,7 @@ void OutputConfigurator::ConfigureOutputs() {
 }
 
 void OutputConfigurator::NotifyObservers(bool success,
-                                         OutputState attempted_state) {
+                                         ui::OutputState attempted_state) {
   if (success) {
     FOR_EACH_OBSERVER(Observer, observers_,
                       OnDisplayModeChanged(cached_outputs_));
@@ -786,25 +787,25 @@ void OutputConfigurator::NotifyObservers(bool success,
 }
 
 bool OutputConfigurator::EnterStateOrFallBackToSoftwareMirroring(
-    OutputState output_state,
+    ui::OutputState output_state,
     DisplayPowerState power_state) {
   bool success = EnterState(output_state, power_state);
   if (mirroring_controller_) {
     bool enable_software_mirroring = false;
-    if (!success && output_state == STATE_DUAL_MIRROR) {
-      if (output_state_ != STATE_DUAL_EXTENDED || power_state_ != power_state)
-        EnterState(STATE_DUAL_EXTENDED, power_state);
+    if (!success && output_state == ui::OUTPUT_STATE_DUAL_MIRROR) {
+      if (output_state_ != ui::OUTPUT_STATE_DUAL_EXTENDED ||
+          power_state_ != power_state)
+        EnterState(ui::OUTPUT_STATE_DUAL_EXTENDED, power_state);
       enable_software_mirroring = success =
-          output_state_ == STATE_DUAL_EXTENDED;
+          output_state_ == ui::OUTPUT_STATE_DUAL_EXTENDED;
     }
     mirroring_controller_->SetSoftwareMirroring(enable_software_mirroring);
   }
   return success;
 }
 
-bool OutputConfigurator::EnterState(
-    OutputState output_state,
-    DisplayPowerState power_state) {
+bool OutputConfigurator::EnterState(ui::OutputState output_state,
+                                    DisplayPowerState power_state) {
   std::vector<bool> output_power;
   int num_on_outputs = GetOutputPower(
       cached_outputs_, power_state, &output_power);
@@ -816,18 +817,18 @@ bool OutputConfigurator::EnterState(
   std::vector<OutputSnapshot> updated_outputs = cached_outputs_;
 
   switch (output_state) {
-    case STATE_INVALID:
+    case ui::OUTPUT_STATE_INVALID:
       NOTREACHED() << "Ignoring request to enter invalid state with "
                    << updated_outputs.size() << " connected output(s)";
       return false;
-    case STATE_HEADLESS:
+    case ui::OUTPUT_STATE_HEADLESS:
       if (updated_outputs.size() != 0) {
         LOG(WARNING) << "Ignoring request to enter headless mode with "
                      << updated_outputs.size() << " connected output(s)";
         return false;
       }
       break;
-    case STATE_SINGLE: {
+    case ui::OUTPUT_STATE_SINGLE: {
       // If there are multiple outputs connected, only one should be turned on.
       if (updated_outputs.size() != 1 && num_on_outputs != 1) {
         LOG(WARNING) << "Ignoring request to enter single mode with "
@@ -862,7 +863,7 @@ bool OutputConfigurator::EnterState(
       }
       break;
     }
-    case STATE_DUAL_MIRROR: {
+    case ui::OUTPUT_STATE_DUAL_MIRROR: {
       if (updated_outputs.size() != 2 ||
           (num_on_outputs != 0 && num_on_outputs != 2)) {
         LOG(WARNING) << "Ignoring request to enter mirrored mode with "
@@ -898,7 +899,7 @@ bool OutputConfigurator::EnterState(
       }
       break;
     }
-    case STATE_DUAL_EXTENDED: {
+    case ui::OUTPUT_STATE_DUAL_EXTENDED: {
       if (updated_outputs.size() != 2 ||
           (num_on_outputs != 0 && num_on_outputs != 2)) {
         LOG(WARNING) << "Ignoring request to enter extended mode with "
@@ -993,8 +994,7 @@ bool OutputConfigurator::EnterState(
       // If we are trying to set mirror mode and one of the modesets fails,
       // then the two monitors will be mis-matched.  In this case, return
       // false to let the observers be aware.
-      if (output_state == STATE_DUAL_MIRROR &&
-          output_power[i] &&
+      if (output_state == ui::OUTPUT_STATE_DUAL_MIRROR && output_power[i] &&
           output.current_mode != output.mirror_mode)
         all_succeeded = false;
 
@@ -1008,19 +1008,19 @@ bool OutputConfigurator::EnterState(
   return all_succeeded;
 }
 
-OutputState OutputConfigurator::ChooseOutputState(
+ui::OutputState OutputConfigurator::ChooseOutputState(
     DisplayPowerState power_state) const {
   int num_on_outputs = GetOutputPower(cached_outputs_, power_state, NULL);
   switch (cached_outputs_.size()) {
     case 0:
-      return STATE_HEADLESS;
+      return ui::OUTPUT_STATE_HEADLESS;
     case 1:
-      return STATE_SINGLE;
+      return ui::OUTPUT_STATE_SINGLE;
     case 2: {
       if (num_on_outputs == 1) {
         // If only one output is currently turned on, return the "single"
         // state so that its native mode will be used.
-        return STATE_SINGLE;
+        return ui::OUTPUT_STATE_SINGLE;
       } else {
         // With either both outputs on or both outputs off, use one of the
         // dual modes.
@@ -1028,7 +1028,7 @@ OutputState OutputConfigurator::ChooseOutputState(
         for (size_t i = 0; i < cached_outputs_.size(); ++i) {
           // If display id isn't available, switch to extended mode.
           if (!cached_outputs_[i].has_display_id)
-            return STATE_DUAL_EXTENDED;
+            return ui::OUTPUT_STATE_DUAL_EXTENDED;
           display_ids.push_back(cached_outputs_[i].display_id);
         }
         return state_controller_->GetStateForDisplayIds(display_ids);
@@ -1037,7 +1037,7 @@ OutputState OutputConfigurator::ChooseOutputState(
     default:
       NOTREACHED();
   }
-  return STATE_INVALID;
+  return ui::OUTPUT_STATE_INVALID;
 }
 
 OutputConfigurator::CoordinateTransformation
diff --git a/chromeos/display/output_configurator.h b/chromeos/display/output_configurator.h
index 7432171..e6661e1 100644
--- a/chromeos/display/output_configurator.h
+++ b/chromeos/display/output_configurator.h
@@ -18,6 +18,7 @@
 #include "base/timer/timer.h"
 #include "chromeos/chromeos_export.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
+#include "ui/display/display_constants.h"
 
 // Forward declarations for Xlib and Xrandr.
 // This is so unused X definitions don't pollute the namespace.
@@ -28,40 +29,6 @@ typedef XID RRMode;
 
 namespace chromeos {
 
-// Used to describe the state of a multi-display configuration.
-enum OutputState {
-  STATE_INVALID,
-  STATE_HEADLESS,
-  STATE_SINGLE,
-  STATE_DUAL_MIRROR,
-  STATE_DUAL_EXTENDED,
-};
-
-// Video output types.
-enum OutputType {
-  OUTPUT_TYPE_NONE = 0,
-  OUTPUT_TYPE_UNKNOWN = 1 << 0,
-  OUTPUT_TYPE_INTERNAL = 1 << 1,
-  OUTPUT_TYPE_VGA = 1 << 2,
-  OUTPUT_TYPE_HDMI = 1 << 3,
-  OUTPUT_TYPE_DVI = 1 << 4,
-  OUTPUT_TYPE_DISPLAYPORT = 1 << 5,
-  OUTPUT_TYPE_NETWORK = 1 << 6,
-};
-
-// Content protection methods applied on video output.
-enum OutputProtectionMethod {
-  OUTPUT_PROTECTION_METHOD_NONE = 0,
-  OUTPUT_PROTECTION_METHOD_HDCP = 1 << 0,
-};
-
-// HDCP protection state.
-enum HDCPState {
-  HDCP_STATE_UNDESIRED,
-  HDCP_STATE_DESIRED,
-  HDCP_STATE_ENABLED
-};
-
 // This class interacts directly with the underlying Xrandr API to manipulate
 // CTRCs and Outputs.
 class CHROMEOS_EXPORT OutputConfigurator
@@ -127,7 +94,7 @@ class CHROMEOS_EXPORT OutputConfigurator
     bool is_aspect_preserving_scaling;
 
     // The type of output.
-    OutputType type;
+    ui::OutputType type;
 
     // Map from mode IDs to details about the corresponding modes.
     ModeInfoMap mode_infos;
@@ -160,7 +127,7 @@ class CHROMEOS_EXPORT OutputConfigurator
 
     // Called after a display mode change attempt failed. |failed_new_state| is
     // the new state which the system failed to enter.
-    virtual void OnDisplayModeChangeFailed(OutputState failed_new_state) {}
+    virtual void OnDisplayModeChangeFailed(ui::OutputState failed_new_state) {}
   };
 
   // Interface for classes that make decisions about which output state
@@ -170,7 +137,7 @@ class CHROMEOS_EXPORT OutputConfigurator
     virtual ~StateController() {}
 
     // Called when displays are detected.
-    virtual OutputState GetStateForDisplayIds(
+    virtual ui::OutputState GetStateForDisplayIds(
         const std::vector<int64>& display_ids) const = 0;
 
     // Queries the resolution (|width|x|height|) in pixels
@@ -245,10 +212,10 @@ class CHROMEOS_EXPORT OutputConfigurator
         const std::vector<OutputConfigurator::OutputSnapshot>& outputs) = 0;
 
     // Gets HDCP state of output.
-    virtual bool GetHDCPState(RROutput id, HDCPState* state) = 0;
+    virtual bool GetHDCPState(RROutput id, ui::HDCPState* state) = 0;
 
     // Sets HDCP state of output.
-    virtual bool SetHDCPState(RROutput id, HDCPState state) = 0;
+    virtual bool SetHDCPState(RROutput id, ui::HDCPState state) = 0;
   };
 
   class TouchscreenDelegate {
@@ -336,7 +303,7 @@ class CHROMEOS_EXPORT OutputConfigurator
   OutputConfigurator();
   virtual ~OutputConfigurator();
 
-  OutputState output_state() const { return output_state_; }
+  ui::OutputState output_state() const { return output_state_; }
   DisplayPowerState power_state() const { return power_state_; }
 
   void set_state_controller(StateController* controller) {
@@ -379,7 +346,7 @@ class CHROMEOS_EXPORT OutputConfigurator
   // Force switching the display mode to |new_state|. Returns false if
   // switching failed (possibly because |new_state| is invalid for the
   // current set of connected outputs).
-  bool SetDisplayMode(OutputState new_state);
+  bool SetDisplayMode(ui::OutputState new_state);
 
   // Called when an RRNotify event is received.  The implementation is
   // interested in the cases of RRNotify events which correspond to output
@@ -473,7 +440,7 @@ class CHROMEOS_EXPORT OutputConfigurator
   void ConfigureOutputs();
 
   // Notifies observers about an attempted state change.
-  void NotifyObservers(bool success, OutputState attempted_state);
+  void NotifyObservers(bool success, ui::OutputState attempted_state);
 
   // Switches to the state specified in |output_state| and |power_state|.
   // If the hardware mirroring failed and |mirroring_controller_| is set,
@@ -481,18 +448,17 @@ class CHROMEOS_EXPORT OutputConfigurator
   // to enable software based mirroring.
   // On success, updates |output_state_|, |power_state_|, and |cached_outputs_|
   // and returns true.
-  bool EnterStateOrFallBackToSoftwareMirroring(
-      OutputState output_state,
-      DisplayPowerState power_state);
+  bool EnterStateOrFallBackToSoftwareMirroring(ui::OutputState output_state,
+                                               DisplayPowerState power_state);
 
   // Switches to the state specified in |output_state| and |power_state|.
   // On success, updates |output_state_|, |power_state_|, and
   // |cached_outputs_| and returns true.
-  bool EnterState(OutputState output_state, DisplayPowerState power_state);
+  bool EnterState(ui::OutputState output_state, DisplayPowerState power_state);
 
   // Returns the output state that should be used with |cached_outputs_| while
   // in |power_state|.
-  OutputState ChooseOutputState(DisplayPowerState power_state) const;
+  ui::OutputState ChooseOutputState(DisplayPowerState power_state) const;
 
   // Computes the relevant transformation for mirror mode.
   // |output| is the output on which mirror mode is being applied.
@@ -545,7 +511,7 @@ class CHROMEOS_EXPORT OutputConfigurator
   int xrandr_event_base_;
 
   // The current display state.
-  OutputState output_state_;
+  ui::OutputState output_state_;
 
   // The current power state.
   DisplayPowerState power_state_;
diff --git a/chromeos/display/output_configurator_unittest.cc b/chromeos/display/output_configurator_unittest.cc
index 3b53fd9..b269c7b 100644
--- a/chromeos/display/output_configurator_unittest.cc
+++ b/chromeos/display/output_configurator_unittest.cc
@@ -76,7 +76,7 @@ std::string GetCTMAction(
 }
 
 // Returns a string describing a TestNativeDisplayDelegate::SetHDCPState() call.
-std::string GetSetHDCPStateAction(RROutput id, HDCPState state) {
+std::string GetSetHDCPStateAction(RROutput id, ui::HDCPState state) {
   return base::StringPrintf("set_hdcp(id=%lu,state=%d)", id, state);
 }
 
@@ -162,7 +162,7 @@ class TestNativeDisplayDelegate
   // Ownership of |log| remains with the caller.
   explicit TestNativeDisplayDelegate(ActionLogger* log)
       : max_configurable_pixels_(0),
-        hdcp_state_(HDCP_STATE_UNDESIRED),
+        hdcp_state_(ui::HDCP_STATE_UNDESIRED),
         log_(log) {}
   virtual ~TestNativeDisplayDelegate() {}
 
@@ -178,7 +178,7 @@ class TestNativeDisplayDelegate
     max_configurable_pixels_ = pixels;
   }
 
-  void set_hdcp_state(HDCPState state) { hdcp_state_ = state; }
+  void set_hdcp_state(ui::HDCPState state) { hdcp_state_ = state; }
 
   // OutputConfigurator::Delegate overrides:
   virtual void InitXRandRExtension(int* event_base) OVERRIDE {
@@ -235,12 +235,12 @@ class TestNativeDisplayDelegate
                              outputs.size() >= 1 ? outputs[0].crtc : 0,
                              outputs.size() >= 2 ? outputs[1].crtc : 0));
   }
-  virtual bool GetHDCPState(RROutput id, HDCPState* state) OVERRIDE {
+  virtual bool GetHDCPState(RROutput id, ui::HDCPState* state) OVERRIDE {
     *state = hdcp_state_;
     return true;
   }
 
-  virtual bool SetHDCPState(RROutput id, HDCPState state) OVERRIDE {
+  virtual bool SetHDCPState(RROutput id, ui::HDCPState state) OVERRIDE {
     log_->AppendAction(GetSetHDCPStateAction(id, state));
     return true;
   }
@@ -266,7 +266,7 @@ class TestNativeDisplayDelegate
   int  max_configurable_pixels_;
 
   // Result value of GetHDCPState().
-  HDCPState hdcp_state_;
+  ui::HDCPState hdcp_state_;
 
   ActionLogger* log_;  // Not owned.
 
@@ -290,13 +290,13 @@ class TestObserver : public OutputConfigurator::Observer {
       const {
     return latest_outputs_;
   }
-  OutputState latest_failed_state() const { return latest_failed_state_; }
+  ui::OutputState latest_failed_state() const { return latest_failed_state_; }
 
   void Reset() {
     num_changes_ = 0;
     num_failures_ = 0;
     latest_outputs_.clear();
-    latest_failed_state_ = STATE_INVALID;
+    latest_failed_state_ = ui::OUTPUT_STATE_INVALID;
   }
 
   // OutputConfigurator::Observer overrides:
@@ -306,7 +306,7 @@ class TestObserver : public OutputConfigurator::Observer {
     latest_outputs_ = outputs;
   }
 
-  virtual void OnDisplayModeChangeFailed(OutputState failed_new_state)
+  virtual void OnDisplayModeChangeFailed(ui::OutputState failed_new_state)
       OVERRIDE {
     num_failures_++;
     latest_failed_state_ = failed_new_state;
@@ -321,21 +321,23 @@ class TestObserver : public OutputConfigurator::Observer {
 
   // Parameters most recently passed to OnDisplayMode*().
   std::vector<OutputConfigurator::OutputSnapshot> latest_outputs_;
-  OutputState latest_failed_state_;
+  ui::OutputState latest_failed_state_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 class TestStateController : public OutputConfigurator::StateController {
  public:
-  TestStateController() : state_(STATE_DUAL_EXTENDED) {}
+  TestStateController() : state_(ui::OUTPUT_STATE_DUAL_EXTENDED) {}
   virtual ~TestStateController() {}
 
-  void set_state(OutputState state) { state_ = state; }
+  void set_state(ui::OutputState state) { state_ = state; }
 
   // OutputConfigurator::StateController overrides:
-  virtual OutputState GetStateForDisplayIds(
-      const std::vector<int64>& outputs) const OVERRIDE { return state_; }
+  virtual ui::OutputState GetStateForDisplayIds(
+      const std::vector<int64>& outputs) const OVERRIDE {
+    return state_;
+  }
   virtual bool GetResolutionForDisplayId(
       int64 display_id,
       int *width,
@@ -344,7 +346,7 @@ class TestStateController : public OutputConfigurator::StateController {
   }
 
  private:
-  OutputState state_;
+  ui::OutputState state_;
 
   DISALLOW_COPY_AND_ASSIGN(TestStateController);
 };
@@ -415,7 +417,7 @@ class OutputConfiguratorTest : public testing::Test {
     o->crtc = 10;
     o->current_mode = kSmallModeId;
     o->native_mode = kSmallModeId;
-    o->type = OUTPUT_TYPE_INTERNAL;
+    o->type = ui::OUTPUT_TYPE_INTERNAL;
     o->is_aspect_preserving_scaling = true;
     o->mode_infos[kSmallModeId] = small_mode_info;
     o->has_display_id = true;
@@ -427,7 +429,7 @@ class OutputConfiguratorTest : public testing::Test {
     o->crtc = 11;
     o->current_mode = kBigModeId;
     o->native_mode = kBigModeId;
-    o->type = OUTPUT_TYPE_HDMI;
+    o->type = ui::OUTPUT_TYPE_HDMI;
     o->is_aspect_preserving_scaling = true;
     o->mode_infos[kSmallModeId] = small_mode_info;
     o->mode_infos[kBigModeId] = big_mode_info;
@@ -577,7 +579,7 @@ TEST_F(OutputConfiguratorTest, ConnectSecondOutput) {
   // Connect a second output and check that the configurator enters
   // extended mode.
   observer_.Reset();
-  state_controller_.set_state(STATE_DUAL_EXTENDED);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
   const int kDualHeight =
       kSmallModeHeight + OutputConfigurator::kVerticalGap + kBigModeHeight;
@@ -602,7 +604,7 @@ TEST_F(OutputConfiguratorTest, ConnectSecondOutput) {
   EXPECT_EQ(1, observer_.num_changes());
 
   observer_.Reset();
-  EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
+  EXPECT_TRUE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_MIRROR));
   EXPECT_EQ(
       JoinActions(
           kGrab,
@@ -639,7 +641,7 @@ TEST_F(OutputConfiguratorTest, ConnectSecondOutput) {
 
   // Get rid of shared modes to force software mirroring.
   outputs_[1].mode_infos.erase(kSmallModeId);
-  state_controller_.set_state(STATE_DUAL_EXTENDED);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
   EXPECT_EQ(
       JoinActions(
@@ -661,24 +663,24 @@ TEST_F(OutputConfiguratorTest, ConnectSecondOutput) {
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
 
   observer_.Reset();
-  EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
+  EXPECT_TRUE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_MIRROR));
   EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
-  EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
-  // Setting STATE_DUAL_MIRROR should try to reconfigure.
+  // Setting OUTPUT_STATE_DUAL_MIRROR should try to reconfigure.
   observer_.Reset();
-  EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_EXTENDED));
+  EXPECT_TRUE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_EXTENDED));
   EXPECT_EQ(JoinActions(NULL), log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Set back to software mirror mode.
   observer_.Reset();
-  EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
+  EXPECT_TRUE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_MIRROR));
   EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
-  EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
@@ -703,7 +705,7 @@ TEST_F(OutputConfiguratorTest, ConnectSecondOutput) {
 TEST_F(OutputConfiguratorTest, SetDisplayPower) {
   InitWithSingleOutput();
 
-  state_controller_.set_state(STATE_DUAL_MIRROR);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
   observer_.Reset();
   UpdateOutputs(2, true);
   EXPECT_EQ(
@@ -742,7 +744,7 @@ TEST_F(OutputConfiguratorTest, SetDisplayPower) {
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(STATE_SINGLE, configurator_.output_state());
+  EXPECT_EQ(ui::OUTPUT_STATE_SINGLE, configurator_.output_state());
   EXPECT_EQ(1, observer_.num_changes());
 
   // When all displays are turned off, the framebuffer should switch back
@@ -762,7 +764,7 @@ TEST_F(OutputConfiguratorTest, SetDisplayPower) {
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(STATE_DUAL_MIRROR, configurator_.output_state());
+  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_MIRROR, configurator_.output_state());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
@@ -785,13 +787,13 @@ TEST_F(OutputConfiguratorTest, SetDisplayPower) {
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(STATE_DUAL_MIRROR, configurator_.output_state());
+  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_MIRROR, configurator_.output_state());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Get rid of shared modes to force software mirroring.
   outputs_[1].mode_infos.erase(kSmallModeId);
-  state_controller_.set_state(STATE_DUAL_MIRROR);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
   observer_.Reset();
   UpdateOutputs(2, true);
   const int kDualHeight =
@@ -813,7 +815,7 @@ TEST_F(OutputConfiguratorTest, SetDisplayPower) {
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
@@ -835,7 +837,7 @@ TEST_F(OutputConfiguratorTest, SetDisplayPower) {
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(STATE_SINGLE, configurator_.output_state());
+  EXPECT_EQ(ui::OUTPUT_STATE_SINGLE, configurator_.output_state());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
@@ -859,7 +861,7 @@ TEST_F(OutputConfiguratorTest, SetDisplayPower) {
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
@@ -884,7 +886,7 @@ TEST_F(OutputConfiguratorTest, SetDisplayPower) {
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 }
@@ -953,7 +955,7 @@ TEST_F(OutputConfiguratorTest, SuspendAndResume) {
 
   // If a second, external display is connected, the displays shouldn't be
   // powered back on before suspending.
-  state_controller_.set_state(STATE_DUAL_MIRROR);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
   UpdateOutputs(2, true);
   EXPECT_EQ(
       JoinActions(
@@ -1046,7 +1048,7 @@ TEST_F(OutputConfiguratorTest, StartWithTwoOutputs) {
   configurator_.Init(false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
-  state_controller_.set_state(STATE_DUAL_MIRROR);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
   configurator_.Start(0);
   EXPECT_EQ(
       JoinActions(
@@ -1072,29 +1074,29 @@ TEST_F(OutputConfiguratorTest, InvalidOutputStates) {
   configurator_.Init(false);
   configurator_.Start(0);
   observer_.Reset();
-  EXPECT_TRUE(configurator_.SetDisplayMode(STATE_HEADLESS));
-  EXPECT_FALSE(configurator_.SetDisplayMode(STATE_SINGLE));
-  EXPECT_FALSE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
-  EXPECT_FALSE(configurator_.SetDisplayMode(STATE_DUAL_EXTENDED));
+  EXPECT_TRUE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_HEADLESS));
+  EXPECT_FALSE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_SINGLE));
+  EXPECT_FALSE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_MIRROR));
+  EXPECT_FALSE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_EXTENDED));
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(3, observer_.num_failures());
 
   UpdateOutputs(1, true);
   observer_.Reset();
-  EXPECT_FALSE(configurator_.SetDisplayMode(STATE_HEADLESS));
-  EXPECT_TRUE(configurator_.SetDisplayMode(STATE_SINGLE));
-  EXPECT_FALSE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
-  EXPECT_FALSE(configurator_.SetDisplayMode(STATE_DUAL_EXTENDED));
+  EXPECT_FALSE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_HEADLESS));
+  EXPECT_TRUE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_SINGLE));
+  EXPECT_FALSE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_MIRROR));
+  EXPECT_FALSE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_EXTENDED));
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(3, observer_.num_failures());
 
-  state_controller_.set_state(STATE_DUAL_EXTENDED);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
   observer_.Reset();
-  EXPECT_FALSE(configurator_.SetDisplayMode(STATE_HEADLESS));
-  EXPECT_FALSE(configurator_.SetDisplayMode(STATE_SINGLE));
-  EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
-  EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_EXTENDED));
+  EXPECT_FALSE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_HEADLESS));
+  EXPECT_FALSE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_SINGLE));
+  EXPECT_TRUE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_MIRROR));
+  EXPECT_TRUE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_EXTENDED));
   EXPECT_EQ(2, observer_.num_changes());
   EXPECT_EQ(2, observer_.num_failures());
 }
@@ -1103,18 +1105,18 @@ TEST_F(OutputConfiguratorTest, GetOutputStateForDisplaysWithoutId) {
   outputs_[0].has_display_id = false;
   UpdateOutputs(2, false);
   configurator_.Init(false);
-  state_controller_.set_state(STATE_DUAL_MIRROR);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
   configurator_.Start(0);
-  EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
 }
 
 TEST_F(OutputConfiguratorTest, GetOutputStateForDisplaysWithId) {
   outputs_[0].has_display_id = true;
   UpdateOutputs(2, false);
   configurator_.Init(false);
-  state_controller_.set_state(STATE_DUAL_MIRROR);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
   configurator_.Start(0);
-  EXPECT_EQ(STATE_DUAL_MIRROR, configurator_.output_state());
+  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_MIRROR, configurator_.output_state());
 }
 
 TEST_F(OutputConfiguratorTest, AvoidUnnecessaryProbes) {
@@ -1135,7 +1137,7 @@ TEST_F(OutputConfiguratorTest, AvoidUnnecessaryProbes) {
 
   // Send an event stating that the second output is connected and check
   // that it gets updated.
-  state_controller_.set_state(STATE_DUAL_MIRROR);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
   UpdateOutputs(2, false);
   test_api_.SendOutputChangeEvent(
       outputs_[1].output, outputs_[1].crtc, outputs_[1].current_mode, true);
@@ -1264,7 +1266,7 @@ TEST_F(OutputConfiguratorTest, UpdateCachedOutputsEvenAfterFailure) {
 
   // After connecting a second output, check that it shows up in
   // |cached_outputs_| even if an invalid state is requested.
-  state_controller_.set_state(STATE_SINGLE);
+  state_controller_.set_state(ui::OUTPUT_STATE_SINGLE);
   UpdateOutputs(2, true);
   cached = &test_api_.cached_outputs();
   ASSERT_EQ(static_cast<size_t>(2), cached->size());
@@ -1290,10 +1292,10 @@ TEST_F(OutputConfiguratorTest, PanelFitting) {
   // The small mode should be added to the internal output when requesting
   // mirrored mode.
   UpdateOutputs(2, false);
-  state_controller_.set_state(STATE_DUAL_MIRROR);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
   configurator_.Init(true /* is_panel_fitting_enabled */);
   configurator_.Start(0);
-  EXPECT_EQ(STATE_DUAL_MIRROR, configurator_.output_state());
+  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_MIRROR, configurator_.output_state());
   EXPECT_EQ(
       JoinActions(
           kGrab,
@@ -1347,8 +1349,8 @@ TEST_F(OutputConfiguratorTest, OutputProtection) {
                                                         outputs_[0].display_id,
                                                         &link_mask,
                                                         &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_TYPE_INTERNAL), link_mask);
-  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_PROTECTION_METHOD_NONE),
+  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_TYPE_INTERNAL), link_mask);
+  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_PROTECTION_METHOD_NONE),
             protection_mask);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
@@ -1359,33 +1361,30 @@ TEST_F(OutputConfiguratorTest, OutputProtection) {
                                                         outputs_[1].display_id,
                                                         &link_mask,
                                                         &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_TYPE_HDMI),
-            link_mask);
-  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_PROTECTION_METHOD_NONE),
+  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_TYPE_HDMI), link_mask);
+  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_PROTECTION_METHOD_NONE),
             protection_mask);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
-  EXPECT_TRUE(
-      configurator_.EnableOutputProtection(id,
-                                           outputs_[1].display_id,
-                                           OUTPUT_PROTECTION_METHOD_HDCP));
-  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output, HDCP_STATE_DESIRED),
+  EXPECT_TRUE(configurator_.EnableOutputProtection(
+      id, outputs_[1].display_id, ui::OUTPUT_PROTECTION_METHOD_HDCP));
+  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output, ui::HDCP_STATE_DESIRED),
             log_->GetActionsAndClear());
 
   // Enable protection.
-  native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
+  native_display_delegate_->set_hdcp_state(ui::HDCP_STATE_ENABLED);
   EXPECT_TRUE(configurator_.QueryOutputProtectionStatus(id,
                                                         outputs_[1].display_id,
                                                         &link_mask,
                                                         &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_TYPE_HDMI), link_mask);
-  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_PROTECTION_METHOD_HDCP),
+  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_TYPE_HDMI), link_mask);
+  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_PROTECTION_METHOD_HDCP),
             protection_mask);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   // Protections should be disabled after unregister.
   configurator_.UnregisterOutputProtectionClient(id);
-  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output, HDCP_STATE_UNDESIRED),
+  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output, ui::HDCP_STATE_UNDESIRED),
             log_->GetActionsAndClear());
 }
 
@@ -1402,14 +1401,12 @@ TEST_F(OutputConfiguratorTest, OutputProtectionTwoClients) {
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
 
   // Clients never know state enableness for methods that they didn't request.
-  EXPECT_TRUE(
-      configurator_.EnableOutputProtection(client1,
-                                           outputs_[1].display_id,
-                                           OUTPUT_PROTECTION_METHOD_HDCP));
+  EXPECT_TRUE(configurator_.EnableOutputProtection(
+      client1, outputs_[1].display_id, ui::OUTPUT_PROTECTION_METHOD_HDCP));
   EXPECT_EQ(
-      GetSetHDCPStateAction(outputs_[1].output, HDCP_STATE_DESIRED).c_str(),
+      GetSetHDCPStateAction(outputs_[1].output, ui::HDCP_STATE_DESIRED).c_str(),
       log_->GetActionsAndClear());
-  native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
+  native_display_delegate_->set_hdcp_state(ui::HDCP_STATE_ENABLED);
 
   uint32_t link_mask = 0;
   uint32_t protection_mask = 0;
@@ -1417,31 +1414,27 @@ TEST_F(OutputConfiguratorTest, OutputProtectionTwoClients) {
                                                         outputs_[1].display_id,
                                                         &link_mask,
                                                         &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_TYPE_HDMI), link_mask);
-  EXPECT_EQ(OUTPUT_PROTECTION_METHOD_HDCP, protection_mask);
+  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_TYPE_HDMI), link_mask);
+  EXPECT_EQ(ui::OUTPUT_PROTECTION_METHOD_HDCP, protection_mask);
 
   EXPECT_TRUE(configurator_.QueryOutputProtectionStatus(client2,
                                                         outputs_[1].display_id,
                                                         &link_mask,
                                                         &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(OUTPUT_TYPE_HDMI), link_mask);
-  EXPECT_EQ(OUTPUT_PROTECTION_METHOD_NONE, protection_mask);
+  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_TYPE_HDMI), link_mask);
+  EXPECT_EQ(ui::OUTPUT_PROTECTION_METHOD_NONE, protection_mask);
 
   // Protections will be disabled only if no more clients request them.
-  EXPECT_TRUE(
-      configurator_.EnableOutputProtection(client2,
-                                           outputs_[1].display_id,
-                                           OUTPUT_PROTECTION_METHOD_NONE));
-  EXPECT_EQ(
-      GetSetHDCPStateAction(outputs_[1].output, HDCP_STATE_DESIRED).c_str(),
-      log_->GetActionsAndClear());
-  EXPECT_TRUE(
-      configurator_.EnableOutputProtection(client1,
-                                           outputs_[1].display_id,
-                                           OUTPUT_PROTECTION_METHOD_NONE));
+  EXPECT_TRUE(configurator_.EnableOutputProtection(
+      client2, outputs_[1].display_id, ui::OUTPUT_PROTECTION_METHOD_NONE));
   EXPECT_EQ(
-      GetSetHDCPStateAction(outputs_[1].output, HDCP_STATE_UNDESIRED).c_str(),
+      GetSetHDCPStateAction(outputs_[1].output, ui::HDCP_STATE_DESIRED).c_str(),
       log_->GetActionsAndClear());
+  EXPECT_TRUE(configurator_.EnableOutputProtection(
+      client1, outputs_[1].display_id, ui::OUTPUT_PROTECTION_METHOD_NONE));
+  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output, ui::HDCP_STATE_UNDESIRED)
+                .c_str(),
+            log_->GetActionsAndClear());
 }
 
 TEST_F(OutputConfiguratorTest, CTMForMultiScreens) {
@@ -1450,7 +1443,7 @@ TEST_F(OutputConfiguratorTest, CTMForMultiScreens) {
 
   UpdateOutputs(2, false);
   configurator_.Init(false);
-  state_controller_.set_state(STATE_DUAL_EXTENDED);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_EXTENDED);
   configurator_.Start(0);
 
   const int kDualHeight =
@@ -1507,13 +1500,13 @@ TEST_F(OutputConfiguratorTest, HandleConfigureCrtcFailure) {
 
   configurator_.Init(false);
 
-  // First test simply fails in STATE_SINGLE mode.   This is probably
+  // First test simply fails in OUTPUT_STATE_SINGLE mode.   This is probably
   // unrealistic but the want to make sure any assumptions don't
   // creep in.
   native_display_delegate_->set_max_configurable_pixels(
       outputs_[0].mode_infos[kFirstMode + 2].width *
       outputs_[0].mode_infos[kFirstMode + 2].height);
-  state_controller_.set_state(STATE_SINGLE);
+  state_controller_.set_state(ui::OUTPUT_STATE_SINGLE);
   UpdateOutputs(1, true);
 
   EXPECT_EQ(
@@ -1538,7 +1531,7 @@ TEST_F(OutputConfiguratorTest, HandleConfigureCrtcFailure) {
   native_display_delegate_->set_max_configurable_pixels(
       outputs_[0].mode_infos[kFirstMode + 3].width *
       outputs_[0].mode_infos[kFirstMode + 3].height);
-  state_controller_.set_state(STATE_DUAL_MIRROR);
+  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
   UpdateOutputs(2, true);
 
   EXPECT_EQ(
diff --git a/chromeos/display/touchscreen_delegate_x11.cc b/chromeos/display/touchscreen_delegate_x11.cc
index 44db4b5..37bb385 100644
--- a/chromeos/display/touchscreen_delegate_x11.cc
+++ b/chromeos/display/touchscreen_delegate_x11.cc
@@ -117,9 +117,9 @@ void TouchscreenDelegateX11::AssociateTouchscreens(
        it != no_match_touchscreen.end();
        it++) {
     for (size_t i = 0; i < outputs->size(); i++) {
-      if ((*outputs)[i].type != OUTPUT_TYPE_INTERNAL &&
+      if ((*outputs)[i].type != ui::OUTPUT_TYPE_INTERNAL &&
           (*outputs)[i].native_mode != None &&
-          (*outputs)[i].touch_device_id == None ) {
+          (*outputs)[i].touch_device_id == None) {
         (*outputs)[i].touch_device_id = *it;
         VLOG(2) << "Arbitrarily matching touchscreen "
                 << (*outputs)[i].touch_device_id << " to output #" << i;