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

ui/display/chromeos/output_configurator_unittest.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 <cmath>
 #include <cstdarg>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
-#include "chromeos/display/native_display_delegate.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/display/chromeos/native_display_delegate.h"
 
-namespace chromeos {
+namespace ui {
 
 namespace {
 
 // Strings returned by TestNativeDisplayDelegate::GetActionsAndClear() to
 // describe various actions that were performed.
 const char kInitXRandR[] = "init";
 const char kGrab[] = "grab";
 const char kUngrab[] = "ungrab";
 const char kSync[] = "sync";
 const char kForceDPMS[] = "dpms";
@@ skipping 14 matching lines @@
   return base::StringPrintf("add_mode(output=%lu,mode=%lu)", output, mode);
 }
 
 // Returns a string describing a TestNativeDisplayDelegate::Configure()
 // call.
 std::string GetCrtcAction(RRCrtc crtc,
                           int x,
                           int y,
                           RRMode mode,
                           RROutput output) {
-  return base::StringPrintf("crtc(crtc=%lu,x=%d,y=%d,mode=%lu,output=%lu)",
-                            crtc, x, y, mode, output);
+  return base::StringPrintf(
+      "crtc(crtc=%lu,x=%d,y=%d,mode=%lu,output=%lu)", crtc, x, y, mode, output);
 }
 
 // Returns a string describing a TestNativeDisplayDelegate::CreateFramebuffer()
 // call.
 std::string GetFramebufferAction(int width,
                                  int height,
                                  RRCrtc crtc1,
                                  RRCrtc crtc2) {
   return base::StringPrintf(
       "framebuffer(width=%d,height=%d,crtc1=%lu,crtc2=%lu)",
-      width, height, crtc1, crtc2);
+      width,
+      height,
+      crtc1,
+      crtc2);
 }
 
 // Returns a string describing a TestNativeDisplayDelegate::ConfigureCTM() call.
 std::string GetCTMAction(
     int device_id,
     const OutputConfigurator::CoordinateTransformation& ctm) {
-  return base::StringPrintf("ctm(id=%d,transform=(%f,%f,%f,%f))", device_id,
-      ctm.x_scale, ctm.x_offset, ctm.y_scale, ctm.y_offset);
+  return base::StringPrintf("ctm(id=%d,transform=(%f,%f,%f,%f))",
+                            device_id,
+                            ctm.x_scale,
+                            ctm.x_offset,
+                            ctm.y_scale,
+                            ctm.y_offset);
 }
 
 // Returns a string describing a TestNativeDisplayDelegate::SetHDCPState() call.
-std::string GetSetHDCPStateAction(RROutput id, ui::HDCPState state) {
+std::string GetSetHDCPStateAction(RROutput id, HDCPState state) {
   return base::StringPrintf("set_hdcp(id=%lu,state=%d)", id, state);
 }
 
 // Joins a sequence of strings describing actions (e.g. kScreenDim) such
 // that they can be compared against a string returned by
 // ActionLogger::GetActionsAndClear().  The list of actions must be
 // terminated by a NULL pointer.
 std::string JoinActions(const char* action, ...) {
   std::string actions;
 
@@ skipping 62 matching lines @@
   std::map<int, OutputConfigurator::CoordinateTransformation> ctms_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTouchscreenDelegate);
 };
 
 class TestNativeDisplayDelegate : public NativeDisplayDelegate {
  public:
   // Ownership of |log| remains with the caller.
   explicit TestNativeDisplayDelegate(ActionLogger* log)
       : max_configurable_pixels_(0),
-        hdcp_state_(ui::HDCP_STATE_UNDESIRED),
+        hdcp_state_(HDCP_STATE_UNDESIRED),
         log_(log) {}
   virtual ~TestNativeDisplayDelegate() {}
 
   const std::vector<OutputConfigurator::OutputSnapshot>& outputs() const {
     return outputs_;
   }
   void set_outputs(
       const std::vector<OutputConfigurator::OutputSnapshot>& outputs) {
     outputs_ = outputs;
   }
 
   void set_max_configurable_pixels(int pixels) {
     max_configurable_pixels_ = pixels;
   }
 
-  void set_hdcp_state(ui::HDCPState state) { hdcp_state_ = state; }
+  void set_hdcp_state(HDCPState state) { hdcp_state_ = state; }
 
   // OutputConfigurator::Delegate overrides:
-  virtual void Initialize() OVERRIDE {
-    log_->AppendAction(kInitXRandR);
-  }
+  virtual void Initialize() OVERRIDE { log_->AppendAction(kInitXRandR); }
   virtual void GrabServer() OVERRIDE { log_->AppendAction(kGrab); }
   virtual void UngrabServer() OVERRIDE { log_->AppendAction(kUngrab); }
   virtual void SyncWithServer() OVERRIDE { log_->AppendAction(kSync); }
   virtual void SetBackgroundColor(uint32 color_argb) OVERRIDE {
     log_->AppendAction(GetBackgroundAction(color_argb));
   }
   virtual void ForceDPMSOn() OVERRIDE { log_->AppendAction(kForceDPMS); }
   virtual std::vector<OutputConfigurator::OutputSnapshot> GetOutputs()
       OVERRIDE {
     return outputs_;
   }
   virtual void AddMode(const OutputConfigurator::OutputSnapshot& output,
                        RRMode mode) OVERRIDE {
     log_->AppendAction(GetAddOutputModeAction(output.output, mode));
   }
   virtual bool Configure(const OutputConfigurator::OutputSnapshot& output,
                          RRMode mode,
                          int x,
                          int y) OVERRIDE {
     log_->AppendAction(GetCrtcAction(output.crtc, x, y, mode, output.output));
 
     if (max_configurable_pixels_ == 0)
       return true;
 
-    OutputConfigurator::OutputSnapshot* snapshot = GetOutputFromId(
-        output.output);
+    OutputConfigurator::OutputSnapshot* snapshot =
+        GetOutputFromId(output.output);
     if (!snapshot)
       return false;
 
     const OutputConfigurator::ModeInfo* mode_info =
         OutputConfigurator::GetModeInfo(*snapshot, mode);
     if (!mode_info)
       return false;
 
     return mode_info->width * mode_info->height <= max_configurable_pixels_;
-
   }
   virtual void CreateFrameBuffer(
       int width,
       int height,
       const std::vector<OutputConfigurator::OutputSnapshot>& outputs) OVERRIDE {
     log_->AppendAction(
         GetFramebufferAction(width,
                              height,
                              outputs.size() >= 1 ? outputs[0].crtc : 0,
                              outputs.size() >= 2 ? outputs[1].crtc : 0));
   }
   virtual bool GetHDCPState(const OutputConfigurator::OutputSnapshot& output,
-                            ui::HDCPState* state) OVERRIDE {
+                            HDCPState* state) OVERRIDE {
     *state = hdcp_state_;
     return true;
   }
 
   virtual bool SetHDCPState(const OutputConfigurator::OutputSnapshot& output,
-                            ui::HDCPState state) OVERRIDE {
+                            HDCPState state) OVERRIDE {
     log_->AppendAction(GetSetHDCPStateAction(output.output, state));
     return true;
   }
 
   virtual void AddObserver(NativeDisplayObserver* observer) OVERRIDE {}
 
   virtual void RemoveObserver(NativeDisplayObserver* observer) OVERRIDE {}
 
  private:
   OutputConfigurator::OutputSnapshot* GetOutputFromId(RROutput output_id) {
     for (unsigned int i = 0; i < outputs_.size(); i++) {
       if (outputs_[i].output == output_id)
         return &outputs_[i];
     }
     return NULL;
   }
 
   // Outputs to be returned by GetOutputs().
   std::vector<OutputConfigurator::OutputSnapshot> outputs_;
 
   // |max_configurable_pixels_| represents the maximum number of pixels that
   // Configure will support.  Tests can use this to force Configure
   // to fail if attempting to set a resolution that is higher than what
   // a device might support under a given circumstance.
   // A value of 0 means that no limit is enforced and Configure will
   // return success regardless of the resolution.
-  int  max_configurable_pixels_;
+  int max_configurable_pixels_;
 
   // Result value of GetHDCPState().
-  ui::HDCPState hdcp_state_;
+  HDCPState hdcp_state_;
 
   ActionLogger* log_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(TestNativeDisplayDelegate);
 };
 
 class TestObserver : public OutputConfigurator::Observer {
  public:
   explicit TestObserver(OutputConfigurator* configurator)
       : configurator_(configurator) {
     Reset();
     configurator_->AddObserver(this);
   }
-  virtual ~TestObserver() {
-    configurator_->RemoveObserver(this);
-  }
+  virtual ~TestObserver() { configurator_->RemoveObserver(this); }
 
   int num_changes() const { return num_changes_; }
   int num_failures() const { return num_failures_; }
   const std::vector<OutputConfigurator::OutputSnapshot>& latest_outputs()
       const {
     return latest_outputs_;
   }
-  ui::OutputState latest_failed_state() const { return latest_failed_state_; }
+  OutputState latest_failed_state() const { return latest_failed_state_; }
 
   void Reset() {
     num_changes_ = 0;
     num_failures_ = 0;
     latest_outputs_.clear();
-    latest_failed_state_ = ui::OUTPUT_STATE_INVALID;
+    latest_failed_state_ = OUTPUT_STATE_INVALID;
   }
 
   // OutputConfigurator::Observer overrides:
   virtual void OnDisplayModeChanged(
       const std::vector<OutputConfigurator::OutputSnapshot>& outputs) OVERRIDE {
     num_changes_++;
     latest_outputs_ = outputs;
   }
 
-  virtual void OnDisplayModeChangeFailed(ui::OutputState failed_new_state)
+  virtual void OnDisplayModeChangeFailed(OutputState failed_new_state)
       OVERRIDE {
     num_failures_++;
     latest_failed_state_ = failed_new_state;
   }
 
  private:
   OutputConfigurator* configurator_;  // Not owned.
 
   // Number of times that OnDisplayMode*() has been called.
   int num_changes_;
   int num_failures_;
 
   // Parameters most recently passed to OnDisplayMode*().
   std::vector<OutputConfigurator::OutputSnapshot> latest_outputs_;
-  ui::OutputState latest_failed_state_;
+  OutputState latest_failed_state_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 class TestStateController : public OutputConfigurator::StateController {
  public:
-  TestStateController() : state_(ui::OUTPUT_STATE_DUAL_EXTENDED) {}
+  TestStateController() : state_(OUTPUT_STATE_DUAL_EXTENDED) {}
   virtual ~TestStateController() {}
 
-  void set_state(ui::OutputState state) { state_ = state; }
+  void set_state(OutputState state) { state_ = state; }
 
   // OutputConfigurator::StateController overrides:
-  virtual ui::OutputState GetStateForDisplayIds(
+  virtual OutputState GetStateForDisplayIds(
       const std::vector<int64>& outputs) const OVERRIDE {
     return state_;
   }
-  virtual bool GetResolutionForDisplayId(
-      int64 display_id,
-      int *width,
-      int *height) const OVERRIDE {
+  virtual bool GetResolutionForDisplayId(int64 display_id,
+                                         int* width,
+                                         int* height) const OVERRIDE {
     return false;
   }
 
  private:
-  ui::OutputState state_;
+  OutputState state_;
 
   DISALLOW_COPY_AND_ASSIGN(TestStateController);
 };
 
 class TestMirroringController
     : public OutputConfigurator::SoftwareMirroringController {
  public:
   TestMirroringController() : software_mirroring_enabled_(false) {}
   virtual ~TestMirroringController() {}
 
@@ skipping 16 matching lines @@
   // Predefined modes that can be used by outputs.
   static const RRMode kSmallModeId;
   static const int kSmallModeWidth;
   static const int kSmallModeHeight;
 
   static const RRMode kBigModeId;
   static const int kBigModeWidth;
   static const int kBigModeHeight;
 
   OutputConfiguratorTest()
-      : observer_(&configurator_),
-        test_api_(&configurator_) {
-  }
+      : observer_(&configurator_), test_api_(&configurator_) {}
   virtual ~OutputConfiguratorTest() {}
 
   virtual void SetUp() OVERRIDE {
     log_.reset(new ActionLogger());
 
     native_display_delegate_ = new TestNativeDisplayDelegate(log_.get());
     configurator_.SetNativeDisplayDelegateForTesting(
         scoped_ptr<NativeDisplayDelegate>(native_display_delegate_));
 
     touchscreen_delegate_ = new TestTouchscreenDelegate(log_.get());
@@ skipping 10 matching lines @@
 
     OutputConfigurator::ModeInfo big_mode_info;
     big_mode_info.width = kBigModeWidth;
     big_mode_info.height = kBigModeHeight;
 
     OutputConfigurator::OutputSnapshot* o = &outputs_[0];
     o->output = 1;
     o->crtc = 10;
     o->current_mode = kSmallModeId;
     o->native_mode = kSmallModeId;
-    o->type = ui::OUTPUT_TYPE_INTERNAL;
+    o->type = OUTPUT_TYPE_INTERNAL;
     o->is_aspect_preserving_scaling = true;
     o->mode_infos[kSmallModeId] = small_mode_info;
     o->has_display_id = true;
     o->display_id = 123;
     o->index = 0;
 
     o = &outputs_[1];
     o->output = 2;
     o->crtc = 11;
     o->current_mode = kBigModeId;
     o->native_mode = kBigModeId;
-    o->type = ui::OUTPUT_TYPE_HDMI;
+    o->type = OUTPUT_TYPE_HDMI;
     o->is_aspect_preserving_scaling = true;
     o->mode_infos[kSmallModeId] = small_mode_info;
     o->mode_infos[kBigModeId] = big_mode_info;
     o->has_display_id = true;
     o->display_id = 456;
     o->index = 1;
 
     UpdateOutputs(2, false);
   }
 
@@ skipping 38 matching lines @@
         log_->GetActionsAndClear());
   }
 
   base::MessageLoop message_loop_;
   TestStateController state_controller_;
   TestMirroringController mirroring_controller_;
   OutputConfigurator configurator_;
   TestObserver observer_;
   scoped_ptr<ActionLogger> log_;
   TestNativeDisplayDelegate* native_display_delegate_;  // not owned
-  TestTouchscreenDelegate* touchscreen_delegate_;  // not owned
+  TestTouchscreenDelegate* touchscreen_delegate_;       // not owned
   OutputConfigurator::TestApi test_api_;
 
   OutputConfigurator::OutputSnapshot outputs_[2];
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OutputConfiguratorTest);
 };
 
 const RRMode OutputConfiguratorTest::kSmallModeId = 20;
 const int OutputConfiguratorTest::kSmallModeWidth = 1366;
@@ skipping 24 matching lines @@
   output.mode_infos[20] = OutputConfigurator::ModeInfo(1024, 768, true, 60.0);
   // Mixed.
   output.mode_infos[21] = OutputConfigurator::ModeInfo(1024, 600, true, 60.0);
   output.mode_infos[22] = OutputConfigurator::ModeInfo(1024, 600, false, 40.0);
   output.mode_infos[23] = OutputConfigurator::ModeInfo(1024, 600, false, 50.0);
   // Just one interlaced mode.
   output.mode_infos[24] = OutputConfigurator::ModeInfo(640, 480, true, 60.0);
   // Refresh rate not available.
   output.mode_infos[25] = OutputConfigurator::ModeInfo(320, 200, false, 0.0);
 
-  EXPECT_EQ(11u, OutputConfigurator::FindOutputModeMatchingSize(output,
-                                                                1920, 1200));
+  EXPECT_EQ(11u,
+            OutputConfigurator::FindOutputModeMatchingSize(output, 1920, 1200));
 
   // Should pick highest refresh rate.
-  EXPECT_EQ(13u, OutputConfigurator::FindOutputModeMatchingSize(output,
-                                                                1920, 1080));
+  EXPECT_EQ(13u,
+            OutputConfigurator::FindOutputModeMatchingSize(output, 1920, 1080));
 
   // Should pick non-interlaced mode.
-  EXPECT_EQ(17u, OutputConfigurator::FindOutputModeMatchingSize(output,
-                                                                1280, 720));
+  EXPECT_EQ(17u,
+            OutputConfigurator::FindOutputModeMatchingSize(output, 1280, 720));
 
   // Interlaced only. Should pick one with the highest refresh rate in
   // interlaced mode.
-  EXPECT_EQ(20u, OutputConfigurator::FindOutputModeMatchingSize(output,
-                                                                1024, 768));
+  EXPECT_EQ(20u,
+            OutputConfigurator::FindOutputModeMatchingSize(output, 1024, 768));
 
   // Mixed: Should pick one with the highest refresh rate in
   // interlaced mode.
-  EXPECT_EQ(23u, OutputConfigurator::FindOutputModeMatchingSize(output,
-                                                                1024, 600));
+  EXPECT_EQ(23u,
+            OutputConfigurator::FindOutputModeMatchingSize(output, 1024, 600));
 
   // Just one interlaced mode.
-  EXPECT_EQ(24u, OutputConfigurator::FindOutputModeMatchingSize(output,
-                                                                640, 480));
+  EXPECT_EQ(24u,
+            OutputConfigurator::FindOutputModeMatchingSize(output, 640, 480));
 
   // Refresh rate not available.
-  EXPECT_EQ(25u, OutputConfigurator::FindOutputModeMatchingSize(output,
-                                                                320, 200));
+  EXPECT_EQ(25u,
+            OutputConfigurator::FindOutputModeMatchingSize(output, 320, 200));
 
   // No mode found.
-  EXPECT_EQ(0u, OutputConfigurator::FindOutputModeMatchingSize(output,
-                                                               1440, 900));
+  EXPECT_EQ(0u,
+            OutputConfigurator::FindOutputModeMatchingSize(output, 1440, 900));
 }
 
 TEST_F(OutputConfiguratorTest, ConnectSecondOutput) {
   InitWithSingleOutput();
 
   // Connect a second output and check that the configurator enters
   // extended mode.
   observer_.Reset();
-  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_EXTENDED);
+  state_controller_.set_state(OUTPUT_STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
   const int kDualHeight =
       kSmallModeHeight + OutputConfigurator::kVerticalGap + kBigModeHeight;
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(
               kBigModeWidth, kDualHeight, outputs_[0].crtc, outputs_[1].crtc)
               .c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           GetCrtcAction(outputs_[1].crtc,
                         0,
                         kSmallModeHeight + OutputConfigurator::kVerticalGap,
                         kBigModeId,
                         outputs_[1].output).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   observer_.Reset();
-  EXPECT_TRUE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_MIRROR));
+  EXPECT_TRUE(configurator_.SetDisplayMode(OUTPUT_STATE_DUAL_MIRROR));
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(kSmallModeWidth,
                                kSmallModeHeight,
                                outputs_[0].crtc,
                                outputs_[1].crtc).c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           GetCrtcAction(
@@ skipping 15 matching lines @@
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
   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(ui::OUTPUT_STATE_DUAL_EXTENDED);
+  state_controller_.set_state(OUTPUT_STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(
               kBigModeWidth, kDualHeight, outputs_[0].crtc, outputs_[1].crtc)
               .c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           GetCrtcAction(outputs_[1].crtc,
                         0,
                         kSmallModeHeight + OutputConfigurator::kVerticalGap,
                         kBigModeId,
                         outputs_[1].output).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
 
   observer_.Reset();
-  EXPECT_TRUE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_MIRROR));
+  EXPECT_TRUE(configurator_.SetDisplayMode(OUTPUT_STATE_DUAL_MIRROR));
   EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
-  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_EQ(OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Setting OUTPUT_STATE_DUAL_MIRROR should try to reconfigure.
   observer_.Reset();
-  EXPECT_TRUE(configurator_.SetDisplayMode(ui::OUTPUT_STATE_DUAL_EXTENDED));
+  EXPECT_TRUE(configurator_.SetDisplayMode(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(ui::OUTPUT_STATE_DUAL_MIRROR));
+  EXPECT_TRUE(configurator_.SetDisplayMode(OUTPUT_STATE_DUAL_MIRROR));
   EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
-  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_EQ(OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Disconnect the second output.
   observer_.Reset();
   UpdateOutputs(1, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(
               kSmallModeWidth, kSmallModeHeight, outputs_[0].crtc, 0).c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 }
 
 TEST_F(OutputConfiguratorTest, SetDisplayPower) {
   InitWithSingleOutput();
 
-  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
+  state_controller_.set_state(OUTPUT_STATE_DUAL_MIRROR);
   observer_.Reset();
   UpdateOutputs(2, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(kSmallModeWidth,
                                kSmallModeHeight,
                                outputs_[0].crtc,
                                outputs_[1].crtc).c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           GetCrtcAction(
               outputs_[1].crtc, 0, 0, kSmallModeId, outputs_[1].output).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Turning off the internal display should switch the external display to
   // its native mode.
   observer_.Reset();
-  configurator_.SetDisplayPower(DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
-                                OutputConfigurator::kSetDisplayPowerNoFlags);
+  configurator_.SetDisplayPower(
+      chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
+      OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(
               kBigModeWidth, kBigModeHeight, outputs_[0].crtc, outputs_[1].crtc)
               .c_str(),
           GetCrtcAction(outputs_[0].crtc, 0, 0, 0, outputs_[0].output).c_str(),
           GetCrtcAction(outputs_[1].crtc, 0, 0, kBigModeId, outputs_[1].output)
               .c_str(),
           kForceDPMS,
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(ui::OUTPUT_STATE_SINGLE, configurator_.output_state());
+  EXPECT_EQ(OUTPUT_STATE_SINGLE, configurator_.output_state());
   EXPECT_EQ(1, observer_.num_changes());
 
   // When all displays are turned off, the framebuffer should switch back
   // to the mirrored size.
   observer_.Reset();
-  configurator_.SetDisplayPower(DISPLAY_POWER_ALL_OFF,
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(kSmallModeWidth,
                                kSmallModeHeight,
                                outputs_[0].crtc,
                                outputs_[1].crtc).c_str(),
           GetCrtcAction(outputs_[0].crtc, 0, 0, 0, outputs_[0].output).c_str(),
           GetCrtcAction(outputs_[1].crtc, 0, 0, 0, outputs_[1].output).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_MIRROR, configurator_.output_state());
+  EXPECT_EQ(OUTPUT_STATE_DUAL_MIRROR, configurator_.output_state());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Turn all displays on and check that mirroring is still used.
   observer_.Reset();
-  configurator_.SetDisplayPower(DISPLAY_POWER_ALL_ON,
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(kSmallModeWidth,
                                kSmallModeHeight,
                                outputs_[0].crtc,
                                outputs_[1].crtc).c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           GetCrtcAction(
               outputs_[1].crtc, 0, 0, kSmallModeId, outputs_[1].output).c_str(),
           kForceDPMS,
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_MIRROR, configurator_.output_state());
+  EXPECT_EQ(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(ui::OUTPUT_STATE_DUAL_MIRROR);
+  state_controller_.set_state(OUTPUT_STATE_DUAL_MIRROR);
   observer_.Reset();
   UpdateOutputs(2, true);
   const int kDualHeight =
       kSmallModeHeight + OutputConfigurator::kVerticalGap + kBigModeHeight;
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(
               kBigModeWidth, kDualHeight, outputs_[0].crtc, outputs_[1].crtc)
               .c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           GetCrtcAction(outputs_[1].crtc,
                         0,
                         kSmallModeHeight + OutputConfigurator::kVerticalGap,
                         kBigModeId,
                         outputs_[1].output).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_EQ(OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Turning off the internal display should switch the external display to
   // its native mode.
   observer_.Reset();
-  configurator_.SetDisplayPower(DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
-                                OutputConfigurator::kSetDisplayPowerNoFlags);
+  configurator_.SetDisplayPower(
+      chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
+      OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(
               kBigModeWidth, kBigModeHeight, outputs_[0].crtc, outputs_[1].crtc)
               .c_str(),
           GetCrtcAction(outputs_[0].crtc, 0, 0, 0, outputs_[0].output).c_str(),
           GetCrtcAction(outputs_[1].crtc, 0, 0, kBigModeId, outputs_[1].output)
               .c_str(),
           kForceDPMS,
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(ui::OUTPUT_STATE_SINGLE, configurator_.output_state());
+  EXPECT_EQ(OUTPUT_STATE_SINGLE, configurator_.output_state());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // When all displays are turned off, the framebuffer should switch back
   // to the extended + software mirroring.
   observer_.Reset();
-  configurator_.SetDisplayPower(DISPLAY_POWER_ALL_OFF,
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(
               kBigModeWidth, kDualHeight, outputs_[0].crtc, outputs_[1].crtc)
               .c_str(),
           GetCrtcAction(outputs_[0].crtc, 0, 0, 0, outputs_[0].output).c_str(),
           GetCrtcAction(outputs_[1].crtc,
                         0,
                         kSmallModeHeight + OutputConfigurator::kVerticalGap,
                         0,
                         outputs_[1].output).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_EQ(OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Turn all displays on and check that mirroring is still used.
   observer_.Reset();
-  configurator_.SetDisplayPower(DISPLAY_POWER_ALL_ON,
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(
               kBigModeWidth, kDualHeight, outputs_[0].crtc, outputs_[1].crtc)
               .c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           GetCrtcAction(outputs_[1].crtc,
                         0,
                         kSmallModeHeight + OutputConfigurator::kVerticalGap,
                         kBigModeId,
                         outputs_[1].output).c_str(),
           kForceDPMS,
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_EQ(OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
   EXPECT_EQ(1, observer_.num_changes());
 }
 
 TEST_F(OutputConfiguratorTest, SuspendAndResume) {
   InitWithSingleOutput();
 
   // No preparation is needed before suspending when the display is already
   // on.  The configurator should still reprobe on resume in case a display
   // was connected while suspended.
   configurator_.SuspendDisplays();
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   configurator_.ResumeDisplays();
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(
               kSmallModeWidth, kSmallModeHeight, outputs_[0].crtc, 0).c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           kForceDPMS,
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
 
   // Now turn the display off before suspending and check that the
   // configurator turns it back on and syncs with the server.
-  configurator_.SetDisplayPower(DISPLAY_POWER_ALL_OFF,
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(
               kSmallModeWidth, kSmallModeHeight, outputs_[0].crtc, 0).c_str(),
           GetCrtcAction(outputs_[0].crtc, 0, 0, 0, outputs_[0].output).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
@@ skipping 20 matching lines @@
               kSmallModeWidth, kSmallModeHeight, outputs_[0].crtc, 0).c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           kForceDPMS,
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
 
   // If a second, external display is connected, the displays shouldn't be
   // powered back on before suspending.
-  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
+  state_controller_.set_state(OUTPUT_STATE_DUAL_MIRROR);
   UpdateOutputs(2, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(kSmallModeWidth,
                                kSmallModeHeight,
                                outputs_[0].crtc,
                                outputs_[1].crtc).c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           GetCrtcAction(
               outputs_[1].crtc, 0, 0, kSmallModeId, outputs_[1].output).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
 
-  configurator_.SetDisplayPower(DISPLAY_POWER_ALL_OFF,
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(kSmallModeWidth,
                                kSmallModeHeight,
                                outputs_[0].crtc,
                                outputs_[1].crtc).c_str(),
           GetCrtcAction(outputs_[0].crtc, 0, 0, 0, outputs_[0].output).c_str(),
           GetCrtcAction(outputs_[1].crtc, 0, 0, 0, outputs_[1].output).c_str(),
@@ skipping 24 matching lines @@
   UpdateOutputs(0, false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   configurator_.Init(false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   configurator_.ForceInitialConfigure(0);
   EXPECT_EQ(JoinActions(kGrab, kInitXRandR, kForceDPMS, kUngrab, NULL),
             log_->GetActionsAndClear());
 
   // Not much should happen when the display power state is changed while
   // no displays are connected.
-  configurator_.SetDisplayPower(DISPLAY_POWER_ALL_OFF,
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
-  configurator_.SetDisplayPower(DISPLAY_POWER_ALL_ON,
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(JoinActions(kGrab, kForceDPMS, kUngrab, NULL),
             log_->GetActionsAndClear());
 
   // Connect an external display and check that it's configured correctly.
   outputs_[0] = outputs_[1];
   UpdateOutputs(1, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(
               kBigModeWidth, kBigModeHeight, outputs_[0].crtc, 0).c_str(),
           GetCrtcAction(outputs_[0].crtc, 0, 0, kBigModeId, outputs_[0].output)
               .c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
 }
 
 TEST_F(OutputConfiguratorTest, StartWithTwoOutputs) {
   UpdateOutputs(2, false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   configurator_.Init(false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
-  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
+  state_controller_.set_state(OUTPUT_STATE_DUAL_MIRROR);
   configurator_.ForceInitialConfigure(0);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           kInitXRandR,
           GetFramebufferAction(kSmallModeWidth,
                                kSmallModeHeight,
                                outputs_[0].crtc,
                                outputs_[1].crtc).c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kSmallModeId, outputs_[0].output).c_str(),
           GetCrtcAction(
               outputs_[1].crtc, 0, 0, kSmallModeId, outputs_[1].output).c_str(),
           kForceDPMS,
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
 }
 
 TEST_F(OutputConfiguratorTest, InvalidOutputStates) {
   UpdateOutputs(0, false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   configurator_.Init(false);
   configurator_.ForceInitialConfigure(0);
   observer_.Reset();
-  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_TRUE(configurator_.SetDisplayMode(OUTPUT_STATE_HEADLESS));
+  EXPECT_FALSE(configurator_.SetDisplayMode(OUTPUT_STATE_SINGLE));
+  EXPECT_FALSE(configurator_.SetDisplayMode(OUTPUT_STATE_DUAL_MIRROR));
+  EXPECT_FALSE(configurator_.SetDisplayMode(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(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_FALSE(configurator_.SetDisplayMode(OUTPUT_STATE_HEADLESS));
+  EXPECT_TRUE(configurator_.SetDisplayMode(OUTPUT_STATE_SINGLE));
+  EXPECT_FALSE(configurator_.SetDisplayMode(OUTPUT_STATE_DUAL_MIRROR));
+  EXPECT_FALSE(configurator_.SetDisplayMode(OUTPUT_STATE_DUAL_EXTENDED));
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(3, observer_.num_failures());
 
-  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_EXTENDED);
+  state_controller_.set_state(OUTPUT_STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
   observer_.Reset();
-  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_FALSE(configurator_.SetDisplayMode(OUTPUT_STATE_HEADLESS));
+  EXPECT_FALSE(configurator_.SetDisplayMode(OUTPUT_STATE_SINGLE));
+  EXPECT_TRUE(configurator_.SetDisplayMode(OUTPUT_STATE_DUAL_MIRROR));
+  EXPECT_TRUE(configurator_.SetDisplayMode(OUTPUT_STATE_DUAL_EXTENDED));
   EXPECT_EQ(2, observer_.num_changes());
   EXPECT_EQ(2, observer_.num_failures());
 }
 
 TEST_F(OutputConfiguratorTest, GetOutputStateForDisplaysWithoutId) {
   outputs_[0].has_display_id = false;
   UpdateOutputs(2, false);
   configurator_.Init(false);
-  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
+  state_controller_.set_state(OUTPUT_STATE_DUAL_MIRROR);
   configurator_.ForceInitialConfigure(0);
-  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_EQ(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(ui::OUTPUT_STATE_DUAL_MIRROR);
+  state_controller_.set_state(OUTPUT_STATE_DUAL_MIRROR);
   configurator_.ForceInitialConfigure(0);
-  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_MIRROR, configurator_.output_state());
+  EXPECT_EQ(OUTPUT_STATE_DUAL_MIRROR, configurator_.output_state());
 }
 
 TEST_F(OutputConfiguratorTest, UpdateCachedOutputsEvenAfterFailure) {
   InitWithSingleOutput();
   const std::vector<OutputConfigurator::OutputSnapshot>* cached =
       &configurator_.cached_outputs();
   ASSERT_EQ(static_cast<size_t>(1), cached->size());
   EXPECT_EQ(outputs_[0].current_mode, (*cached)[0].current_mode);
 
   // After connecting a second output, check that it shows up in
   // |cached_outputs_| even if an invalid state is requested.
-  state_controller_.set_state(ui::OUTPUT_STATE_SINGLE);
+  state_controller_.set_state(OUTPUT_STATE_SINGLE);
   UpdateOutputs(2, true);
   cached = &configurator_.cached_outputs();
   ASSERT_EQ(static_cast<size_t>(2), cached->size());
   EXPECT_EQ(outputs_[0].current_mode, (*cached)[0].current_mode);
   EXPECT_EQ(outputs_[1].current_mode, (*cached)[1].current_mode);
 }
 
 TEST_F(OutputConfiguratorTest, PanelFitting) {
   // Configure the internal display to support only the big mode and the
   // external display to support only the small mode.
   outputs_[0].current_mode = kBigModeId;
   outputs_[0].native_mode = kBigModeId;
   outputs_[0].mode_infos.clear();
-  outputs_[0].mode_infos[kBigModeId] = OutputConfigurator::ModeInfo(
-      kBigModeWidth, kBigModeHeight, false, 60.0);
+  outputs_[0].mode_infos[kBigModeId] =
+      OutputConfigurator::ModeInfo(kBigModeWidth, kBigModeHeight, false, 60.0);
 
   outputs_[1].current_mode = kSmallModeId;
   outputs_[1].native_mode = kSmallModeId;
   outputs_[1].mode_infos.clear();
   outputs_[1].mode_infos[kSmallModeId] = OutputConfigurator::ModeInfo(
       kSmallModeWidth, kSmallModeHeight, false, 60.0);
 
   // The small mode should be added to the internal output when requesting
   // mirrored mode.
   UpdateOutputs(2, false);
-  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_MIRROR);
+  state_controller_.set_state(OUTPUT_STATE_DUAL_MIRROR);
   configurator_.Init(true /* is_panel_fitting_enabled */);
   configurator_.ForceInitialConfigure(0);
-  EXPECT_EQ(ui::OUTPUT_STATE_DUAL_MIRROR, configurator_.output_state());
+  EXPECT_EQ(OUTPUT_STATE_DUAL_MIRROR, configurator_.output_state());
   EXPECT_EQ(
       JoinActions(
           kGrab,
           kInitXRandR,
           GetAddOutputModeAction(outputs_[0].output, kSmallModeId).c_str(),
           GetFramebufferAction(kSmallModeWidth,
                                kSmallModeHeight,
                                outputs_[0].crtc,
                                outputs_[1].crtc).c_str(),
           GetCrtcAction(
@@ skipping 29 matching lines @@
 
   OutputConfigurator::OutputProtectionClientId id =
       configurator_.RegisterOutputProtectionClient();
   EXPECT_NE(0u, id);
 
   // One output.
   UpdateOutputs(1, true);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
   uint32_t link_mask = 0;
   uint32_t protection_mask = 0;
-  EXPECT_TRUE(configurator_.QueryOutputProtectionStatus(id,
-                                                        outputs_[0].display_id,
-                                                        &link_mask,
-                                                        &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_TYPE_INTERNAL), link_mask);
-  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_PROTECTION_METHOD_NONE),
+  EXPECT_TRUE(configurator_.QueryOutputProtectionStatus(
+      id, 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),
             protection_mask);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   // Two outputs.
   UpdateOutputs(2, true);
   EXPECT_NE(kNoActions, log_->GetActionsAndClear());
-  EXPECT_TRUE(configurator_.QueryOutputProtectionStatus(id,
-                                                        outputs_[1].display_id,
-                                                        &link_mask,
-                                                        &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_TYPE_HDMI), link_mask);
-  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_PROTECTION_METHOD_NONE),
+  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_NONE),
             protection_mask);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   EXPECT_TRUE(configurator_.EnableOutputProtection(
-      id, outputs_[1].display_id, ui::OUTPUT_PROTECTION_METHOD_HDCP));
-  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output, ui::HDCP_STATE_DESIRED),
+      id, outputs_[1].display_id, OUTPUT_PROTECTION_METHOD_HDCP));
+  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output, HDCP_STATE_DESIRED),
             log_->GetActionsAndClear());
 
   // Enable protection.
-  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>(ui::OUTPUT_TYPE_HDMI), link_mask);
-  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_PROTECTION_METHOD_HDCP),
+  native_display_delegate_->set_hdcp_state(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),
             protection_mask);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   // Protections should be disabled after unregister.
   configurator_.UnregisterOutputProtectionClient(id);
-  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output, ui::HDCP_STATE_UNDESIRED),
+  EXPECT_EQ(GetSetHDCPStateAction(outputs_[1].output, HDCP_STATE_UNDESIRED),
             log_->GetActionsAndClear());
 }
 
 TEST_F(OutputConfiguratorTest, OutputProtectionTwoClients) {
   OutputConfigurator::OutputProtectionClientId client1 =
       configurator_.RegisterOutputProtectionClient();
   OutputConfigurator::OutputProtectionClientId client2 =
       configurator_.RegisterOutputProtectionClient();
   EXPECT_NE(client1, client2);
 
   configurator_.Init(false);
   configurator_.ForceInitialConfigure(0);
   UpdateOutputs(2, true);
   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, ui::OUTPUT_PROTECTION_METHOD_HDCP));
+      client1, outputs_[1].display_id, OUTPUT_PROTECTION_METHOD_HDCP));
   EXPECT_EQ(
-      GetSetHDCPStateAction(outputs_[1].output, ui::HDCP_STATE_DESIRED).c_str(),
+      GetSetHDCPStateAction(outputs_[1].output, HDCP_STATE_DESIRED).c_str(),
       log_->GetActionsAndClear());
-  native_display_delegate_->set_hdcp_state(ui::HDCP_STATE_ENABLED);
+  native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
 
   uint32_t link_mask = 0;
   uint32_t protection_mask = 0;
-  EXPECT_TRUE(configurator_.QueryOutputProtectionStatus(client1,
-                                                        outputs_[1].display_id,
-                                                        &link_mask,
-                                                        &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(
+      client1, 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_TRUE(configurator_.QueryOutputProtectionStatus(client2,
-                                                        outputs_[1].display_id,
-                                                        &link_mask,
-                                                        &protection_mask));
-  EXPECT_EQ(static_cast<uint32_t>(ui::OUTPUT_TYPE_HDMI), link_mask);
-  EXPECT_EQ(ui::OUTPUT_PROTECTION_METHOD_NONE, 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);
 
   // Protections will be disabled only if no more clients request them.
   EXPECT_TRUE(configurator_.EnableOutputProtection(
-      client2, outputs_[1].display_id, ui::OUTPUT_PROTECTION_METHOD_NONE));
+      client2, outputs_[1].display_id, OUTPUT_PROTECTION_METHOD_NONE));
   EXPECT_EQ(
-      GetSetHDCPStateAction(outputs_[1].output, ui::HDCP_STATE_DESIRED).c_str(),
+      GetSetHDCPStateAction(outputs_[1].output, 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());
+      client1, outputs_[1].display_id, OUTPUT_PROTECTION_METHOD_NONE));
+  EXPECT_EQ(
+      GetSetHDCPStateAction(outputs_[1].output, HDCP_STATE_UNDESIRED).c_str(),
+      log_->GetActionsAndClear());
 }
 
 TEST_F(OutputConfiguratorTest, CTMForMultiScreens) {
   outputs_[0].touch_device_id = 1;
   outputs_[1].touch_device_id = 2;
 
   UpdateOutputs(2, false);
   configurator_.Init(false);
-  state_controller_.set_state(ui::OUTPUT_STATE_DUAL_EXTENDED);
+  state_controller_.set_state(OUTPUT_STATE_DUAL_EXTENDED);
   configurator_.ForceInitialConfigure(0);
 
   const int kDualHeight =
       kSmallModeHeight + OutputConfigurator::kVerticalGap + kBigModeHeight;
   const int kDualWidth = kBigModeWidth;
 
   OutputConfigurator::CoordinateTransformation ctm1 =
       touchscreen_delegate_->GetCTM(1);
   OutputConfigurator::CoordinateTransformation ctm2 =
       touchscreen_delegate_->GetCTM(2);
@@ skipping 19 matching lines @@
   // also the mode that we are requesting the output_configurator
   // to choose.  The test will be setup so that this mode will fail
   // and it will have to choose the next best option.
   const int kFirstMode = 11;
 
   // Give the mode_info lists a few reasonable modes.
   for (unsigned int i = 0; i < arraysize(outputs_); i++) {
     outputs_[i].mode_infos.clear();
 
     int current_mode = kFirstMode;
-    outputs_[i].mode_infos[current_mode++] = OutputConfigurator::ModeInfo(
-        2560, 1600, false, 60.0);
-    outputs_[i].mode_infos[current_mode++] = OutputConfigurator::ModeInfo(
-        1024, 768, false, 60.0);
-    outputs_[i].mode_infos[current_mode++] = OutputConfigurator::ModeInfo(
-        1280, 720, false, 60.0);
-    outputs_[i].mode_infos[current_mode++] = OutputConfigurator::ModeInfo(
-        1920, 1080, false, 60.0);
-    outputs_[i].mode_infos[current_mode++] = OutputConfigurator::ModeInfo(
-        1920, 1080, false, 40.0);
+    outputs_[i].mode_infos[current_mode++] =
+        OutputConfigurator::ModeInfo(2560, 1600, false, 60.0);
+    outputs_[i].mode_infos[current_mode++] =
+        OutputConfigurator::ModeInfo(1024, 768, false, 60.0);
+    outputs_[i].mode_infos[current_mode++] =
+        OutputConfigurator::ModeInfo(1280, 720, false, 60.0);
+    outputs_[i].mode_infos[current_mode++] =
+        OutputConfigurator::ModeInfo(1920, 1080, false, 60.0);
+    outputs_[i].mode_infos[current_mode++] =
+        OutputConfigurator::ModeInfo(1920, 1080, false, 40.0);
 
     outputs_[i].current_mode = kFirstMode;
     outputs_[i].native_mode = kFirstMode;
   }
 
   configurator_.Init(false);
 
   // 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(ui::OUTPUT_STATE_SINGLE);
+  state_controller_.set_state(OUTPUT_STATE_SINGLE);
   UpdateOutputs(1, true);
 
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(2560, 1600, outputs_[0].crtc, 0).c_str(),
           GetCrtcAction(outputs_[0].crtc, 0, 0, kFirstMode, outputs_[0].output)
               .c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kFirstMode + 3, outputs_[0].output)
               .c_str(),
           GetCrtcAction(
               outputs_[0].crtc, 0, 0, kFirstMode + 2, outputs_[0].output)
               .c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
 
   // This test should attempt to configure a mirror mode that will not succeed
   // and should end up in extended mode.
   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(ui::OUTPUT_STATE_DUAL_MIRROR);
+  state_controller_.set_state(OUTPUT_STATE_DUAL_MIRROR);
   UpdateOutputs(2, true);
 
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(outputs_[0].mode_infos[kFirstMode].width,
                                outputs_[0].mode_infos[kFirstMode].height,
                                outputs_[0].crtc,
                                outputs_[1].crtc).c_str(),
           GetCrtcAction(outputs_[0].crtc, 0, 0, kFirstMode, outputs_[0].output)
@@ skipping 34 matching lines @@
                         0,
                         outputs_[1].mode_infos[kFirstMode].height +
                             OutputConfigurator::kVerticalGap,
                         kFirstMode + 3,
                         outputs_[1].output).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
 }
 
-}  // namespace chromeos
+}  // namespace ui