Move chromeos/display/* to ui/display/chromeos

ui/display/chromeos/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 "ui/display/chromeos/output_configurator.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/Xrandr.h>
 
 #include "base/bind.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 "chromeos/display/native_display_delegate_x11.h"
-#include "chromeos/display/output_util.h"
-#include "chromeos/display/touchscreen_delegate_x11.h"
+#include "ui/display/chromeos/x11/display_util.h"
+#include "ui/display/chromeos/x11/native_display_delegate_x11.h"
+#include "ui/display/chromeos/x11/touchscreen_delegate_x11.h"
 
-namespace chromeos {
+namespace ui {
 
 namespace {
 
 // The delay to perform configuration after RRNotify.  See the comment
 // in |Dispatch()|.
 const int64 kConfigureDelayMs = 500;
 
 // Returns a string describing |state|.
-std::string DisplayPowerStateToString(DisplayPowerState state) {
+std::string DisplayPowerStateToString(chromeos::DisplayPowerState state) {
   switch (state) {
-    case DISPLAY_POWER_ALL_ON:
+    case chromeos::DISPLAY_POWER_ALL_ON:
       return "ALL_ON";
-    case DISPLAY_POWER_ALL_OFF:
+    case chromeos::DISPLAY_POWER_ALL_OFF:
       return "ALL_OFF";
-    case DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON:
+    case chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON:
       return "INTERNAL_OFF_EXTERNAL_ON";
-    case DISPLAY_POWER_INTERNAL_ON_EXTERNAL_OFF:
+    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 OutputStateToString(ui::OutputState state) {
+std::string OutputStateToString(OutputState state) {
   switch (state) {
-    case ui::OUTPUT_STATE_INVALID:
+    case OUTPUT_STATE_INVALID:
       return "INVALID";
-    case ui::OUTPUT_STATE_HEADLESS:
+    case OUTPUT_STATE_HEADLESS:
       return "HEADLESS";
-    case ui::OUTPUT_STATE_SINGLE:
+    case OUTPUT_STATE_SINGLE:
       return "SINGLE";
-    case ui::OUTPUT_STATE_DUAL_MIRROR:
+    case OUTPUT_STATE_DUAL_MIRROR:
       return "DUAL_MIRROR";
-    case ui::OUTPUT_STATE_DUAL_EXTENDED:
+    case OUTPUT_STATE_DUAL_EXTENDED:
       return "DUAL_EXTENDED";
   }
   NOTREACHED() << "Unknown state " << state;
   return "INVALID";
 }
 
 // Returns a string representation of OutputSnapshot.
 std::string OutputSnapshotToString(
     const OutputConfigurator::OutputSnapshot* output) {
   return base::StringPrintf(
       "[type=%d, output=%ld, crtc=%ld, mode=%ld, dim=%dx%d]",
       output->type,
       output->output,
       output->crtc,
       output->current_mode,
       static_cast<int>(output->width_mm),
       static_cast<int>(output->height_mm));
 }
 
 // Returns a string representation of ModeInfo.
 std::string ModeInfoToString(const OutputConfigurator::ModeInfo* mode) {
   return base::StringPrintf("[%dx%d %srate=%f]",
                             mode->width,
                             mode->height,
                             mode->interlaced ? "interlaced " : "",
                             mode->refresh_rate);
-
 }
 
 // Returns the number of outputs in |outputs| that should be turned on, per
 // |state|.  If |output_power| is non-NULL, it is updated to contain the
 // on/off state of each corresponding entry in |outputs|.
 int GetOutputPower(
     const std::vector<OutputConfigurator::OutputSnapshot>& outputs,
-    DisplayPowerState state,
+    chromeos::DisplayPowerState state,
     std::vector<bool>* output_power) {
   int num_on_outputs = 0;
   if (output_power)
     output_power->resize(outputs.size());
 
   for (size_t i = 0; i < outputs.size(); ++i) {
-    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);
+    bool internal = outputs[i].type == OUTPUT_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 (output_power)
       (*output_power)[i] = on;
     if (on)
       num_on_outputs++;
   }
   return num_on_outputs;
 }
 
 }  // namespace
 
@@ skipping 23 matching lines @@
       crtc(None),
       current_mode(None),
       native_mode(None),
       mirror_mode(None),
       selected_mode(None),
       x(0),
       y(0),
       width_mm(0),
       height_mm(0),
       is_aspect_preserving_scaling(false),
-      type(ui::OUTPUT_TYPE_UNKNOWN),
+      type(OUTPUT_TYPE_UNKNOWN),
       touch_device_id(0),
       display_id(0),
       has_display_id(false),
       index(0) {}
 
 OutputConfigurator::OutputSnapshot::~OutputSnapshot() {}
 
 bool OutputConfigurator::TestApi::TriggerConfigureTimeout() {
   if (configurator_->configure_timer_.get() &&
       configurator_->configure_timer_->IsRunning()) {
     configurator_->configure_timer_.reset();
     configurator_->ConfigureOutputs();
     return true;
   } else {
     return false;
   }
 }
 
 // static
 const OutputConfigurator::ModeInfo* OutputConfigurator::GetModeInfo(
     const OutputSnapshot& output,
     RRMode mode) {
   if (mode == None)
     return NULL;
 
   ModeInfoMap::const_iterator it = output.mode_infos.find(mode);
   if (it == output.mode_infos.end()) {
-    LOG(WARNING) << "Unable to find info about mode " << mode
-                 << " for output " << output.output;
+    LOG(WARNING) << "Unable to find info about mode " << mode << " for output "
+                 << output.output;
     return NULL;
   }
   return &it->second;
 }
 
 // static
 RRMode OutputConfigurator::FindOutputModeMatchingSize(
     const OutputSnapshot& output,
     int width,
     int height) {
   RRMode found = None;
   float best_rate = 0;
   bool non_interlaced_found = false;
   for (ModeInfoMap::const_iterator it = output.mode_infos.begin();
-       it != output.mode_infos.end(); ++it) {
+       it != output.mode_infos.end();
+       ++it) {
     RRMode mode = it->first;
     const ModeInfo& info = it->second;
 
     if (info.width == width && info.height == height) {
       if (info.interlaced) {
         if (non_interlaced_found)
           continue;
       } else {
         // Reset the best rate if the non interlaced is
         // found the first time.
         if (!non_interlaced_found)
           best_rate = info.refresh_rate;
         non_interlaced_found = true;
       }
       if (info.refresh_rate < best_rate)
         continue;
 
       found = mode;
       best_rate = info.refresh_rate;
     }
   }
   return found;
 }
 
 OutputConfigurator::OutputConfigurator()
     : state_controller_(NULL),
       mirroring_controller_(NULL),
       is_panel_fitting_enabled_(false),
       configure_display_(base::SysInfo::IsRunningOnChromeOS()),
-      output_state_(ui::OUTPUT_STATE_INVALID),
-      power_state_(DISPLAY_POWER_ALL_ON),
+      output_state_(OUTPUT_STATE_INVALID),
+      power_state_(chromeos::DISPLAY_POWER_ALL_ON),
       next_output_protection_client_id_(1) {}
 
 OutputConfigurator::~OutputConfigurator() {
   if (native_display_delegate_)
     native_display_delegate_->RemoveObserver(this);
 }
 
 void OutputConfigurator::SetNativeDisplayDelegateForTesting(
     scoped_ptr<NativeDisplayDelegate> delegate) {
   DCHECK(!native_display_delegate_);
 
   native_display_delegate_ = delegate.Pass();
   native_display_delegate_->AddObserver(this);
   configure_display_ = true;
 }
 
 void OutputConfigurator::SetTouchscreenDelegateForTesting(
     scoped_ptr<TouchscreenDelegate> delegate) {
   DCHECK(!touchscreen_delegate_);
 
   touchscreen_delegate_ = delegate.Pass();
 }
 
-void OutputConfigurator::SetInitialDisplayPower(DisplayPowerState power_state) {
-  DCHECK_EQ(output_state_, ui::OUTPUT_STATE_INVALID);
+void OutputConfigurator::SetInitialDisplayPower(
+    chromeos::DisplayPowerState power_state) {
+  DCHECK_EQ(output_state_, OUTPUT_STATE_INVALID);
   power_state_ = power_state;
 }
 
 void OutputConfigurator::Init(bool is_panel_fitting_enabled) {
   is_panel_fitting_enabled_ = is_panel_fitting_enabled;
   if (!configure_display_)
     return;
 
   if (!native_display_delegate_) {
     native_display_delegate_.reset(new NativeDisplayDelegateX11());
     native_display_delegate_->AddObserver(this);
   }
 
   if (!touchscreen_delegate_)
     touchscreen_delegate_.reset(new TouchscreenDelegateX11());
 }
 
 void OutputConfigurator::ForceInitialConfigure(uint32 background_color_argb) {
   if (!configure_display_)
     return;
 
   native_display_delegate_->GrabServer();
   native_display_delegate_->Initialize();
 
   UpdateCachedOutputs();
   if (cached_outputs_.size() > 1 && background_color_argb)
     native_display_delegate_->SetBackgroundColor(background_color_argb);
-  const ui::OutputState new_state = ChooseOutputState(power_state_);
-  const bool success = EnterStateOrFallBackToSoftwareMirroring(
-      new_state, power_state_);
+  const OutputState new_state = ChooseOutputState(power_state_);
+  const bool success =
+      EnterStateOrFallBackToSoftwareMirroring(new_state, power_state_);
 
   // Force the DPMS on chrome startup as the driver doesn't always detect
   // that all displays are on when signing out.
   native_display_delegate_->ForceDPMSOn();
   native_display_delegate_->UngrabServer();
   NotifyObservers(success, new_state);
 }
 
 bool OutputConfigurator::ApplyProtections(const DisplayProtections& requests) {
   for (std::vector<OutputSnapshot>::const_iterator it = cached_outputs_.begin();
-       it != cached_outputs_.end(); ++it) {
+       it != cached_outputs_.end();
+       ++it) {
     uint32_t all_desired = 0;
-    DisplayProtections::const_iterator request_it = requests.find(
-        it->display_id);
+    DisplayProtections::const_iterator request_it =
+        requests.find(it->display_id);
     if (request_it != requests.end())
       all_desired = request_it->second;
     switch (it->type) {
-      case ui::OUTPUT_TYPE_UNKNOWN:
+      case OUTPUT_TYPE_UNKNOWN:
         return false;
       // DisplayPort, DVI, and HDMI all support HDCP.
-      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;
+      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;
         if (!native_display_delegate_->SetHDCPState(*it, new_desired_state))
           return false;
         break;
       }
-      case ui::OUTPUT_TYPE_INTERNAL:
-      case ui::OUTPUT_TYPE_VGA:
-      case ui::OUTPUT_TYPE_NETWORK:
+      case OUTPUT_TYPE_INTERNAL:
+      case OUTPUT_TYPE_VGA:
+      case OUTPUT_TYPE_NETWORK:
         // No protections for these types. Do nothing.
         break;
-      case ui::OUTPUT_TYPE_NONE:
+      case OUTPUT_TYPE_NONE:
         NOTREACHED();
         break;
     }
   }
 
   return true;
 }
 
 OutputConfigurator::OutputProtectionClientId
 OutputConfigurator::RegisterOutputProtectionClient() {
   if (!configure_display_)
     return kInvalidClientId;
 
   return next_output_protection_client_id_++;
 }
 
 void OutputConfigurator::UnregisterOutputProtectionClient(
     OutputProtectionClientId client_id) {
   client_protection_requests_.erase(client_id);
 
   DisplayProtections protections;
   for (ProtectionRequests::const_iterator it =
            client_protection_requests_.begin();
        it != client_protection_requests_.end();
        ++it) {
     for (DisplayProtections::const_iterator it2 = it->second.begin();
-       it2 != it->second.end(); ++it2) {
+         it2 != it->second.end();
+         ++it2) {
       protections[it2->first] |= it2->second;
     }
   }
 
   ApplyProtections(protections);
 }
 
 bool OutputConfigurator::QueryOutputProtectionStatus(
     OutputProtectionClientId client_id,
     int64 display_id,
     uint32_t* link_mask,
     uint32_t* protection_mask) {
   if (!configure_display_)
     return false;
 
   uint32_t enabled = 0;
   uint32_t unfulfilled = 0;
   *link_mask = 0;
   for (std::vector<OutputSnapshot>::const_iterator it = cached_outputs_.begin();
-       it != cached_outputs_.end(); ++it) {
+       it != cached_outputs_.end();
+       ++it) {
     if (it->display_id != display_id)
       continue;
     *link_mask |= it->type;
     switch (it->type) {
-      case ui::OUTPUT_TYPE_UNKNOWN:
+      case OUTPUT_TYPE_UNKNOWN:
         return false;
       // DisplayPort, DVI, and HDMI all support HDCP.
-      case ui::OUTPUT_TYPE_DISPLAYPORT:
-      case ui::OUTPUT_TYPE_DVI:
-      case ui::OUTPUT_TYPE_HDMI: {
-        ui::HDCPState state;
+      case OUTPUT_TYPE_DISPLAYPORT:
+      case OUTPUT_TYPE_DVI:
+      case OUTPUT_TYPE_HDMI: {
+        HDCPState state;
         if (!native_display_delegate_->GetHDCPState(*it, &state))
           return false;
-        if (state == ui::HDCP_STATE_ENABLED)
-          enabled |= ui::OUTPUT_PROTECTION_METHOD_HDCP;
+        if (state == HDCP_STATE_ENABLED)
+          enabled |= OUTPUT_PROTECTION_METHOD_HDCP;
         else
-          unfulfilled |= ui::OUTPUT_PROTECTION_METHOD_HDCP;
+          unfulfilled |= OUTPUT_PROTECTION_METHOD_HDCP;
         break;
       }
-      case ui::OUTPUT_TYPE_INTERNAL:
-      case ui::OUTPUT_TYPE_VGA:
-      case ui::OUTPUT_TYPE_NETWORK:
+      case OUTPUT_TYPE_INTERNAL:
+      case OUTPUT_TYPE_VGA:
+      case OUTPUT_TYPE_NETWORK:
         // No protections for these types. Do nothing.
         break;
-      case ui::OUTPUT_TYPE_NONE:
+      case OUTPUT_TYPE_NONE:
         NOTREACHED();
         break;
     }
   }
 
   // Don't reveal protections requested by other clients.
   ProtectionRequests::iterator it = client_protection_requests_.find(client_id);
   if (it != client_protection_requests_.end()) {
     uint32_t requested_mask = 0;
     if (it->second.find(display_id) != it->second.end())
@@ skipping 11 matching lines @@
     uint32_t desired_method_mask) {
   if (!configure_display_)
     return false;
 
   DisplayProtections protections;
   for (ProtectionRequests::const_iterator it =
            client_protection_requests_.begin();
        it != client_protection_requests_.end();
        ++it) {
     for (DisplayProtections::const_iterator it2 = it->second.begin();
-       it2 != it->second.end(); ++it2) {
+         it2 != it->second.end();
+         ++it2) {
       if (it->first == client_id && it2->first == display_id)
         continue;
       protections[it2->first] |= it2->second;
     }
   }
   protections[display_id] |= desired_method_mask;
 
   if (!ApplyProtections(protections))
     return false;
 
-  if (desired_method_mask == ui::OUTPUT_PROTECTION_METHOD_NONE) {
+  if (desired_method_mask == OUTPUT_PROTECTION_METHOD_NONE) {
     if (client_protection_requests_.find(client_id) !=
         client_protection_requests_.end()) {
       client_protection_requests_[client_id].erase(display_id);
       if (client_protection_requests_[client_id].size() == 0)
         client_protection_requests_.erase(client_id);
     }
   } else {
     client_protection_requests_[client_id][display_id] = desired_method_mask;
   }
 
   return true;
 }
 
 void OutputConfigurator::PrepareForExit() {
   configure_display_ = false;
 }
 
-bool OutputConfigurator::SetDisplayPower(DisplayPowerState power_state,
-                                         int flags) {
+bool OutputConfigurator::SetDisplayPower(
+    chromeos::DisplayPowerState power_state,
+    int flags) {
   if (!configure_display_)
     return false;
 
   VLOG(1) << "SetDisplayPower: power_state="
           << DisplayPowerStateToString(power_state) << " flags=" << flags
           << ", configure timer="
           << ((configure_timer_.get() && configure_timer_->IsRunning()) ?
-              "Running" : "Stopped");
+                  "Running" : "Stopped");
   if (power_state == power_state_ && !(flags & kSetDisplayPowerForceProbe))
     return true;
 
   native_display_delegate_->GrabServer();
   UpdateCachedOutputs();
 
-  const ui::OutputState new_state = ChooseOutputState(power_state);
+  const OutputState new_state = ChooseOutputState(power_state);
   bool attempted_change = false;
   bool success = false;
 
   bool only_if_single_internal_display =
       flags & kSetDisplayPowerOnlyIfSingleInternalDisplay;
   bool single_internal_display =
       cached_outputs_.size() == 1 &&
-      cached_outputs_[0].type == ui::OUTPUT_TYPE_INTERNAL;
+      cached_outputs_[0].type == OUTPUT_TYPE_INTERNAL;
   if (single_internal_display || !only_if_single_internal_display) {
     success = EnterStateOrFallBackToSoftwareMirroring(new_state, power_state);
     attempted_change = true;
 
     // 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.
-    if (success && power_state != DISPLAY_POWER_ALL_OFF)
+    if (success && power_state != chromeos::DISPLAY_POWER_ALL_OFF)
       native_display_delegate_->ForceDPMSOn();
   }
 
   native_display_delegate_->UngrabServer();
   if (attempted_change)
     NotifyObservers(success, new_state);
   return true;
 }
 
-bool OutputConfigurator::SetDisplayMode(ui::OutputState new_state) {
+bool OutputConfigurator::SetDisplayMode(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
     // OUTPUT_STATE_DUAL_EXTENDED to OUTPUT_STATE_DUAL_EXTENDED.
-    if (mirroring_controller_ && new_state == ui::OUTPUT_STATE_DUAL_EXTENDED)
+    if (mirroring_controller_ && new_state == OUTPUT_STATE_DUAL_EXTENDED)
       mirroring_controller_->SetSoftwareMirroring(false);
     NotifyObservers(true, new_state);
     return true;
   }
 
   native_display_delegate_->GrabServer();
   UpdateCachedOutputs();
-  const bool success = EnterStateOrFallBackToSoftwareMirroring(
-      new_state, power_state_);
+  const bool success =
+      EnterStateOrFallBackToSoftwareMirroring(new_state, power_state_);
   native_display_delegate_->UngrabServer();
 
   NotifyObservers(success, new_state);
   return success;
 }
 
 void OutputConfigurator::OnConfigurationChanged() {
   // Configure outputs with |kConfigureDelayMs| delay,
   // so that time-consuming ConfigureOutputs() won't be called multiple times.
   if (configure_timer_.get()) {
@@ skipping 15 matching lines @@
 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
   // internal display connected, switch to the all-on state before
   // suspending.  This shouldn't be very noticeable to the user since the
   // backlight is off at this point, and doing this lets us resume directly
   // into the "on" state, which greatly reduces resume times.
-  if (power_state_ == DISPLAY_POWER_ALL_OFF) {
-    SetDisplayPower(DISPLAY_POWER_ALL_ON,
+  if (power_state_ == chromeos::DISPLAY_POWER_ALL_OFF) {
+    SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
                     kSetDisplayPowerOnlyIfSingleInternalDisplay);
 
     // We need to make sure that the monitor configuration we just did actually
     // completes before we return, because otherwise the X message could be
     // racing with the HandleSuspendReadiness message.
     native_display_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::UpdateCachedOutputs() {
   cached_outputs_ = native_display_delegate_->GetOutputs();
   touchscreen_delegate_->AssociateTouchscreens(&cached_outputs_);
 
   // Set |selected_mode| fields.
   for (size_t i = 0; i < cached_outputs_.size(); ++i) {
     OutputSnapshot* output = &cached_outputs_[i];
     if (output->has_display_id) {
       int width = 0, height = 0;
-      if (state_controller_ &&
-          state_controller_->GetResolutionForDisplayId(
-              output->display_id, &width, &height)) {
+      if (state_controller_ && state_controller_->GetResolutionForDisplayId(
+                                   output->display_id, &width, &height)) {
         output->selected_mode =
             FindOutputModeMatchingSize(*output, width, height);
       }
     }
     // Fall back to native mode.
     if (output->selected_mode == None)
       output->selected_mode = output->native_mode;
   }
 
   // Set |mirror_mode| fields.
   if (cached_outputs_.size() == 2) {
-    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);
+    bool one_is_internal = cached_outputs_[0].type == OUTPUT_TYPE_INTERNAL;
+    bool two_is_internal = cached_outputs_[1].type == OUTPUT_TYPE_INTERNAL;
+    int internal_outputs =
+        (one_is_internal ? 1 : 0) + (two_is_internal ? 1 : 0);
     DCHECK_LT(internal_outputs, 2);
-    LOG_IF(WARNING, internal_outputs == 2)
-        << "Two internal outputs detected.";
+    LOG_IF(WARNING, internal_outputs == 2) << "Two internal outputs detected.";
 
     bool can_mirror = false;
     for (int attempt = 0; !can_mirror && attempt < 2; ++attempt) {
       // Try preserving external output's aspect ratio on the first attempt.
       // If that fails, fall back to the highest matching resolution.
       bool preserve_aspect = attempt == 0;
 
       if (internal_outputs == 1) {
         if (one_is_internal) {
-          can_mirror = FindMirrorMode(&cached_outputs_[0], &cached_outputs_[1],
-              is_panel_fitting_enabled_, preserve_aspect);
+          can_mirror = FindMirrorMode(&cached_outputs_[0],
+                                      &cached_outputs_[1],
+                                      is_panel_fitting_enabled_,
+                                      preserve_aspect);
         } else {
           DCHECK(two_is_internal);
-          can_mirror = FindMirrorMode(&cached_outputs_[1], &cached_outputs_[0],
-              is_panel_fitting_enabled_, preserve_aspect);
+          can_mirror = FindMirrorMode(&cached_outputs_[1],
+                                      &cached_outputs_[0],
+                                      is_panel_fitting_enabled_,
+                                      preserve_aspect);
         }
       } else {  // if (internal_outputs == 0)
         // No panel fitting for external outputs, so fall back to exact match.
-        can_mirror = FindMirrorMode(&cached_outputs_[0], &cached_outputs_[1],
-                                    false, preserve_aspect);
+        can_mirror = FindMirrorMode(
+            &cached_outputs_[0], &cached_outputs_[1], false, preserve_aspect);
         if (!can_mirror && preserve_aspect) {
           // FindMirrorMode() will try to preserve aspect ratio of what it
           // thinks is external display, so if it didn't succeed with one, maybe
           // it will succeed with the other.  This way we will have the correct
           // aspect ratio on at least one of them.
-          can_mirror = FindMirrorMode(&cached_outputs_[1], &cached_outputs_[0],
-                                      false, preserve_aspect);
+          can_mirror = FindMirrorMode(
+              &cached_outputs_[1], &cached_outputs_[0], false, preserve_aspect);
         }
       }
     }
   }
 }
 
 bool OutputConfigurator::FindMirrorMode(OutputSnapshot* internal_output,
                                         OutputSnapshot* external_output,
                                         bool try_panel_fitting,
                                         bool preserve_aspect) {
   const ModeInfo* internal_native_info =
       GetModeInfo(*internal_output, internal_output->native_mode);
   const ModeInfo* external_native_info =
       GetModeInfo(*external_output, external_output->native_mode);
   if (!internal_native_info || !external_native_info)
     return false;
 
   // Check if some external output resolution can be mirrored on internal.
   // Prefer the modes in the order that X sorts them, assuming this is the order
   // in which they look better on the monitor.
   for (ModeInfoMap::const_iterator external_it =
-       external_output->mode_infos.begin();
-       external_it != external_output->mode_infos.end(); ++external_it) {
+           external_output->mode_infos.begin();
+       external_it != external_output->mode_infos.end();
+       ++external_it) {
     const ModeInfo& external_info = external_it->second;
     bool is_native_aspect_ratio =
         external_native_info->width * external_info.height ==
         external_native_info->height * external_info.width;
     if (preserve_aspect && !is_native_aspect_ratio)
       continue;  // Allow only aspect ratio preserving modes for mirroring.
 
     // Try finding an exact match.
     for (ModeInfoMap::const_iterator internal_it =
-         internal_output->mode_infos.begin();
-         internal_it != internal_output->mode_infos.end(); ++internal_it) {
+             internal_output->mode_infos.begin();
+         internal_it != internal_output->mode_infos.end();
+         ++internal_it) {
       const ModeInfo& internal_info = internal_it->second;
       if (internal_info.width == external_info.width &&
           internal_info.height == external_info.height &&
           internal_info.interlaced == external_info.interlaced) {
         internal_output->mirror_mode = internal_it->first;
         external_output->mirror_mode = external_it->first;
         return true;  // Mirror mode found.
       }
     }
 
     // Try to create a matching internal output mode by panel fitting.
     if (try_panel_fitting) {
       // We can downscale by 1.125, and upscale indefinitely. Downscaling looks
       // ugly, so, can fit == can upscale. Also, internal panels don't support
       // fitting interlaced modes.
-      bool can_fit =
-          internal_native_info->width >= external_info.width &&
-          internal_native_info->height >= external_info.height &&
-          !external_info.interlaced;
+      bool can_fit = internal_native_info->width >= external_info.width &&
+                     internal_native_info->height >= external_info.height &&
+                     !external_info.interlaced;
       if (can_fit) {
         RRMode mode = external_it->first;
         native_display_delegate_->AddMode(*internal_output, mode);
         internal_output->mode_infos.insert(std::make_pair(mode, external_info));
         internal_output->mirror_mode = mode;
         external_output->mirror_mode = mode;
         return true;  // Mirror mode created.
       }
     }
   }
 
   return false;
 }
 
 void OutputConfigurator::ConfigureOutputs() {
   configure_timer_.reset();
 
   if (!configure_display_)
     return;
 
   native_display_delegate_->GrabServer();
   UpdateCachedOutputs();
-  const ui::OutputState new_state = ChooseOutputState(power_state_);
-  const bool success = EnterStateOrFallBackToSoftwareMirroring(
-      new_state, power_state_);
+  const OutputState new_state = ChooseOutputState(power_state_);
+  const bool success =
+      EnterStateOrFallBackToSoftwareMirroring(new_state, power_state_);
   native_display_delegate_->UngrabServer();
 
   NotifyObservers(success, new_state);
 }
 
 void OutputConfigurator::NotifyObservers(bool success,
-                                         ui::OutputState attempted_state) {
+                                         OutputState attempted_state) {
   if (success) {
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      OnDisplayModeChanged(cached_outputs_));
+    FOR_EACH_OBSERVER(
+        Observer, observers_, OnDisplayModeChanged(cached_outputs_));
   } else {
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      OnDisplayModeChangeFailed(attempted_state));
+    FOR_EACH_OBSERVER(
+        Observer, observers_, OnDisplayModeChangeFailed(attempted_state));
   }
 }
 
 bool OutputConfigurator::EnterStateOrFallBackToSoftwareMirroring(
-    ui::OutputState output_state,
-    DisplayPowerState power_state) {
+    OutputState output_state,
+    chromeos::DisplayPowerState power_state) {
   bool success = EnterState(output_state, power_state);
   if (mirroring_controller_) {
     bool enable_software_mirroring = false;
-    if (!success && output_state == ui::OUTPUT_STATE_DUAL_MIRROR) {
-      if (output_state_ != ui::OUTPUT_STATE_DUAL_EXTENDED ||
+    if (!success && output_state == OUTPUT_STATE_DUAL_MIRROR) {
+      if (output_state_ != OUTPUT_STATE_DUAL_EXTENDED ||
           power_state_ != power_state)
-        EnterState(ui::OUTPUT_STATE_DUAL_EXTENDED, power_state);
+        EnterState(OUTPUT_STATE_DUAL_EXTENDED, power_state);
       enable_software_mirroring = success =
-          output_state_ == ui::OUTPUT_STATE_DUAL_EXTENDED;
+          output_state_ == OUTPUT_STATE_DUAL_EXTENDED;
     }
     mirroring_controller_->SetSoftwareMirroring(enable_software_mirroring);
   }
   return success;
 }
 
-bool OutputConfigurator::EnterState(ui::OutputState output_state,
-                                    DisplayPowerState power_state) {
+bool OutputConfigurator::EnterState(OutputState output_state,
+                                    chromeos::DisplayPowerState power_state) {
   std::vector<bool> output_power;
-  int num_on_outputs = GetOutputPower(
-      cached_outputs_, power_state, &output_power);
+  int num_on_outputs =
+      GetOutputPower(cached_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 = cached_outputs_;
 
   switch (output_state) {
-    case ui::OUTPUT_STATE_INVALID:
+    case OUTPUT_STATE_INVALID:
       NOTREACHED() << "Ignoring request to enter invalid state with "
                    << updated_outputs.size() << " connected output(s)";
       return false;
-    case ui::OUTPUT_STATE_HEADLESS:
+    case 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 ui::OUTPUT_STATE_SINGLE: {
+    case 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 "
                      << updated_outputs.size() << " connected outputs and "
                      << num_on_outputs << " turned on";
         return false;
       }
 
       for (size_t i = 0; i < updated_outputs.size(); ++i) {
         OutputSnapshot* output = &updated_outputs[i];
@@ skipping 14 matching lines @@
                     << ", i=" << i
                     << ", output=" << OutputSnapshotToString(output)
                     << ", mode_info=" << ModeInfoToString(mode_info);
           }
           width = mode_info->width;
           height = mode_info->height;
         }
       }
       break;
     }
-    case ui::OUTPUT_STATE_DUAL_MIRROR: {
+    case 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 "
                      << updated_outputs.size() << " connected output(s) and "
                      << num_on_outputs << " turned on";
         return false;
       }
 
       if (!updated_outputs[0].mirror_mode)
         return false;
@@ skipping 15 matching lines @@
           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);
           }
         }
       }
       break;
     }
-    case ui::OUTPUT_STATE_DUAL_EXTENDED: {
+    case 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 "
                      << updated_outputs.size() << " connected output(s) and "
                      << num_on_outputs << " turned on";
         return false;
       }
 
       for (size_t i = 0; i < updated_outputs.size(); ++i) {
         OutputSnapshot* output = &updated_outputs[i];
@@ skipping 21 matching lines @@
     }
   }
 
   // Finally, apply the desired changes.
   DCHECK_EQ(cached_outputs_.size(), updated_outputs.size());
   bool all_succeeded = true;
   if (!updated_outputs.empty()) {
     native_display_delegate_->CreateFrameBuffer(width, height, updated_outputs);
     for (size_t i = 0; i < updated_outputs.size(); ++i) {
       const OutputSnapshot& output = updated_outputs[i];
-      bool configure_succeeded =false;
+      bool configure_succeeded = false;
 
       while (true) {
-        if (native_display_delegate_->Configure(output,
-                                                output.current_mode,
-                                                output.x,
-                                                output.y)) {
+        if (native_display_delegate_->Configure(
+                output, output.current_mode, output.x, output.y)) {
           configure_succeeded = true;
           break;
         }
 
         LOG(WARNING) << "Unable to configure CRTC " << output.crtc << ":"
                      << " mode=" << output.current_mode
-                     << " output=" << output.output
-                     << " x=" << output.x
+                     << " output=" << output.output << " x=" << output.x
                      << " y=" << output.y;
 
         const ModeInfo* mode_info = GetModeInfo(output, output.current_mode);
         if (!mode_info)
           break;
 
         // Find the mode with the next-best resolution and see if that can
         // be set.
         int best_mode_pixels = 0;
 
         int current_mode_pixels = mode_info->width * mode_info->height;
         for (ModeInfoMap::const_iterator it = output.mode_infos.begin();
-             it != output.mode_infos.end(); it++) {
+             it != output.mode_infos.end();
+             it++) {
           int pixel_count = it->second.width * it->second.height;
           if ((pixel_count < current_mode_pixels) &&
               (pixel_count > best_mode_pixels)) {
             updated_outputs[i].current_mode = it->first;
             best_mode_pixels = pixel_count;
           }
         }
 
         if (best_mode_pixels == 0)
           break;
       }
 
       if (configure_succeeded) {
         if (output.touch_device_id)
           touchscreen_delegate_->ConfigureCTM(output.touch_device_id,
                                               output.transform);
         cached_outputs_[i] = updated_outputs[i];
       } else {
         all_succeeded = false;
       }
 
       // 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 == ui::OUTPUT_STATE_DUAL_MIRROR && output_power[i] &&
+      if (output_state == OUTPUT_STATE_DUAL_MIRROR && output_power[i] &&
           output.current_mode != output.mirror_mode)
         all_succeeded = false;
-
     }
   }
 
-  if (all_succeeded)  {
+  if (all_succeeded) {
     output_state_ = output_state;
     power_state_ = power_state;
   }
   return all_succeeded;
 }
 
-ui::OutputState OutputConfigurator::ChooseOutputState(
-    DisplayPowerState power_state) const {
+OutputState OutputConfigurator::ChooseOutputState(
+    chromeos::DisplayPowerState power_state) const {
   int num_on_outputs = GetOutputPower(cached_outputs_, power_state, NULL);
   switch (cached_outputs_.size()) {
     case 0:
-      return ui::OUTPUT_STATE_HEADLESS;
+      return OUTPUT_STATE_HEADLESS;
     case 1:
-      return ui::OUTPUT_STATE_SINGLE;
+      return 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 ui::OUTPUT_STATE_SINGLE;
+        return OUTPUT_STATE_SINGLE;
       } else {
         // With either both outputs on or both outputs off, use one of the
         // dual modes.
         std::vector<int64> display_ids;
         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 ui::OUTPUT_STATE_DUAL_EXTENDED;
+            return OUTPUT_STATE_DUAL_EXTENDED;
           display_ids.push_back(cached_outputs_[i].display_id);
         }
         return state_controller_->GetStateForDisplayIds(display_ids);
       }
     }
     default:
       NOTREACHED();
   }
-  return ui::OUTPUT_STATE_INVALID;
+  return OUTPUT_STATE_INVALID;
 }
 
 OutputConfigurator::CoordinateTransformation
 OutputConfigurator::GetMirrorModeCTM(
     const OutputConfigurator::OutputSnapshot& output) {
   CoordinateTransformation ctm;  // Default to identity
   const ModeInfo* native_mode_info = GetModeInfo(output, output.native_mode);
   const ModeInfo* mirror_mode_info = GetModeInfo(output, output.mirror_mode);
 
-  if (!native_mode_info || !mirror_mode_info ||
-      native_mode_info->height == 0 || mirror_mode_info->height == 0 ||
-      native_mode_info->width == 0 || mirror_mode_info->width == 0)
+  if (!native_mode_info || !mirror_mode_info || native_mode_info->height == 0 ||
+      mirror_mode_info->height == 0 || native_mode_info->width == 0 ||
+      mirror_mode_info->width == 0)
     return ctm;
 
   float native_mode_ar = static_cast<float>(native_mode_info->width) /
-      static_cast<float>(native_mode_info->height);
+                         static_cast<float>(native_mode_info->height);
   float mirror_mode_ar = static_cast<float>(mirror_mode_info->width) /
-      static_cast<float>(mirror_mode_info->height);
+                         static_cast<float>(mirror_mode_info->height);
 
   if (mirror_mode_ar > native_mode_ar) {  // Letterboxing
     ctm.x_scale = 1.0;
     ctm.x_offset = 0.0;
     ctm.y_scale = mirror_mode_ar / native_mode_ar;
     ctm.y_offset = (native_mode_ar / mirror_mode_ar - 1.0) * 0.5;
     return ctm;
   }
   if (native_mode_ar > mirror_mode_ar) {  // Pillarboxing
     ctm.y_scale = 1.0;
@@ skipping 44 matching lines @@
   ctm.y_offset = static_cast<float>(output.y) / (framebuffer_height - 1);
   return ctm;
 }
 
 float OutputConfigurator::GetMirroredDisplayAreaRatio(
     const OutputConfigurator::OutputSnapshot& output) {
   float area_ratio = 1.0f;
   const ModeInfo* native_mode_info = GetModeInfo(output, output.native_mode);
   const ModeInfo* mirror_mode_info = GetModeInfo(output, output.mirror_mode);
 
-  if (!native_mode_info || !mirror_mode_info ||
-      native_mode_info->height == 0 || mirror_mode_info->height == 0 ||
-      native_mode_info->width == 0 || mirror_mode_info->width == 0)
+  if (!native_mode_info || !mirror_mode_info || native_mode_info->height == 0 ||
+      mirror_mode_info->height == 0 || native_mode_info->width == 0 ||
+      mirror_mode_info->width == 0)
     return area_ratio;
 
   float width_ratio = static_cast<float>(mirror_mode_info->width) /
-      static_cast<float>(native_mode_info->width);
+                      static_cast<float>(native_mode_info->width);
   float height_ratio = static_cast<float>(mirror_mode_info->height) /
-      static_cast<float>(native_mode_info->height);
+                       static_cast<float>(native_mode_info->height);
 
   area_ratio = width_ratio * height_ratio;
   return area_ratio;
 }
 
-}  // namespace chromeos
+}  // namespace ui