Fix namespace for src/ui/display/.

ui/display/fake_display_delegate.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/display/fake_display_delegate.h"
 
 #include <string>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 38 matching lines @@
 
   int64_t id = GenerateDisplayID(kReservedManufacturerID, kProductCodeHash,
                                  ++next_display_id_);
 
   FakeDisplaySnapshot::Builder builder;
   builder.SetId(id).SetNativeMode(display_size);
 
   return AddDisplay(builder.Build()) ? id : kInvalidDisplayId;
 }
 
-bool FakeDisplayDelegate::AddDisplay(
-    std::unique_ptr<ui::DisplaySnapshot> display) {
+bool FakeDisplayDelegate::AddDisplay(std::unique_ptr<DisplaySnapshot> display) {
   DCHECK(display);
 
   int64_t display_id = display->display_id();
   // Check there is no existing display with the same id.
   for (auto& existing_display : displays_) {
     if (existing_display->display_id() == display_id) {
       LOG(ERROR) << "Display with id " << display_id << " already exists";
       return false;
     }
   }
@@ skipping 36 matching lines @@
   }
 
   initialized_ = true;
 }
 
 void FakeDisplayDelegate::GrabServer() {}
 
 void FakeDisplayDelegate::UngrabServer() {}
 
 void FakeDisplayDelegate::TakeDisplayControl(
-    const ui::DisplayControlCallback& callback) {
+    const DisplayControlCallback& callback) {
   callback.Run(false);
 }
 
 void FakeDisplayDelegate::RelinquishDisplayControl(
-    const ui::DisplayControlCallback& callback) {
+    const DisplayControlCallback& callback) {
   callback.Run(false);
 }
 
 void FakeDisplayDelegate::SyncWithServer() {}
 
 void FakeDisplayDelegate::SetBackgroundColor(uint32_t color_argb) {}
 
 void FakeDisplayDelegate::ForceDPMSOn() {}
 
-void FakeDisplayDelegate::GetDisplays(const ui::GetDisplaysCallback& callback) {
-  std::vector<ui::DisplaySnapshot*> displays;
+void FakeDisplayDelegate::GetDisplays(const GetDisplaysCallback& callback) {
+  std::vector<DisplaySnapshot*> displays;
   for (auto& display : displays_)
     displays.push_back(display.get());
   callback.Run(displays);
 }
 
-void FakeDisplayDelegate::AddMode(const ui::DisplaySnapshot& output,
-                                  const ui::DisplayMode* mode) {}
+void FakeDisplayDelegate::AddMode(const DisplaySnapshot& output,
+                                  const DisplayMode* mode) {}
 
-void FakeDisplayDelegate::Configure(const ui::DisplaySnapshot& output,
-                                    const ui::DisplayMode* mode,
+void FakeDisplayDelegate::Configure(const DisplaySnapshot& output,
+                                    const DisplayMode* mode,
                                     const gfx::Point& origin,
-                                    const ui::ConfigureCallback& callback) {
+                                    const ConfigureCallback& callback) {
   bool configure_success = false;
 
   if (!mode) {
     // This is a request to turn off the display.
     configure_success = true;
   } else {
     // Check that |mode| is appropriate for the display snapshot.
     for (const auto& existing_mode : output.modes()) {
       if (existing_mode.get() == mode) {
         configure_success = true;
         break;
       }
     }
   }
 
   configure_callbacks_.push(base::Bind(callback, configure_success));
 
   // Start the timer if it's not already running. If there are multiple queued
   // configuration requests then ConfigureDone() will handle starting the
   // next request.
   if (!configure_timer_.IsRunning()) {
     configure_timer_.Start(
         FROM_HERE, base::TimeDelta::FromMilliseconds(kConfigureDisplayDelayMs),
         this, &FakeDisplayDelegate::ConfigureDone);
   }
 }
 
 void FakeDisplayDelegate::CreateFrameBuffer(const gfx::Size& size) {}
 
-void FakeDisplayDelegate::GetHDCPState(
-    const ui::DisplaySnapshot& output,
-    const ui::GetHDCPStateCallback& callback) {
-  callback.Run(false, ui::HDCP_STATE_UNDESIRED);
+void FakeDisplayDelegate::GetHDCPState(const DisplaySnapshot& output,
+                                       const GetHDCPStateCallback& callback) {
+  callback.Run(false, HDCP_STATE_UNDESIRED);
 }
 
-void FakeDisplayDelegate::SetHDCPState(
-    const ui::DisplaySnapshot& output,
-    ui::HDCPState state,
-    const ui::SetHDCPStateCallback& callback) {
+void FakeDisplayDelegate::SetHDCPState(const DisplaySnapshot& output,
+                                       HDCPState state,
+                                       const SetHDCPStateCallback& callback) {
   callback.Run(false);
 }
 
-std::vector<ui::ColorCalibrationProfile>
+std::vector<ColorCalibrationProfile>
 FakeDisplayDelegate::GetAvailableColorCalibrationProfiles(
-    const ui::DisplaySnapshot& output) {
-  return std::vector<ui::ColorCalibrationProfile>();
+    const DisplaySnapshot& output) {
+  return std::vector<ColorCalibrationProfile>();
 }
 
 bool FakeDisplayDelegate::SetColorCalibrationProfile(
-    const ui::DisplaySnapshot& output,
-    ui::ColorCalibrationProfile new_profile) {
+    const DisplaySnapshot& output,
+    ColorCalibrationProfile new_profile) {
   return false;
 }
 
 bool FakeDisplayDelegate::SetColorCorrection(
-    const ui::DisplaySnapshot& output,
-    const std::vector<ui::GammaRampRGBEntry>& degamma_lut,
-    const std::vector<ui::GammaRampRGBEntry>& gamma_lut,
+    const DisplaySnapshot& output,
+    const std::vector<GammaRampRGBEntry>& degamma_lut,
+    const std::vector<GammaRampRGBEntry>& gamma_lut,
     const std::vector<float>& correction_matrix) {
   return false;
 }
 
-void FakeDisplayDelegate::AddObserver(ui::NativeDisplayObserver* observer) {
+void FakeDisplayDelegate::AddObserver(NativeDisplayObserver* observer) {
   observers_.AddObserver(observer);
 }
 
-void FakeDisplayDelegate::RemoveObserver(ui::NativeDisplayObserver* observer) {
+void FakeDisplayDelegate::RemoveObserver(NativeDisplayObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 FakeDisplayController* FakeDisplayDelegate::GetFakeDisplayController() {
   return this;
 }
 
 bool FakeDisplayDelegate::InitializeFromSpecString(const std::string& str) {
   // Start without any displays.
   if (str == "none")
     return true;
 
   // Split on commas and parse each display string.
   for (const std::string& part : base::SplitString(
            str, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     int64_t id = GenerateDisplayID(kReservedManufacturerID, kProductCodeHash,
                                    next_display_id_);
-    std::unique_ptr<ui::DisplaySnapshot> snapshot =
+    std::unique_ptr<DisplaySnapshot> snapshot =
         FakeDisplaySnapshot::CreateFromSpec(id, part);
     if (snapshot) {
       AddDisplay(std::move(snapshot));
       next_display_id_++;
     } else {
       LOG(ERROR) << "Failed to parse display \"" << part << "\"";
       return false;
     }
   }
 
   return true;
 }
 
 void FakeDisplayDelegate::OnConfigurationChanged() {
   if (!initialized_)
     return;
 
-  for (ui::NativeDisplayObserver& observer : observers_)
+  for (NativeDisplayObserver& observer : observers_)
     observer.OnConfigurationChanged();
 }
 
 void FakeDisplayDelegate::ConfigureDone() {
   DCHECK(!configure_callbacks_.empty());
   configure_callbacks_.front().Run();
   configure_callbacks_.pop();
 
   // If there are more configuration requests waiting then restart the timer.
   if (!configure_callbacks_.empty()) {
     configure_timer_.Start(
         FROM_HERE, base::TimeDelta::FromMilliseconds(kConfigureDisplayDelayMs),
         this, &FakeDisplayDelegate::ConfigureDone);
   }
 }
 
 }  // namespace display