Fix namespace for src/ui/display/.

ui/display/manager/chromeos/display_configurator.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/display/manager/chromeos/display_configurator.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "ui/display/display.h"
 #include "ui/display/display_switches.h"
 #include "ui/display/manager/chromeos/apply_content_protection_task.h"
 #include "ui/display/manager/chromeos/display_layout_manager.h"
 #include "ui/display/manager/chromeos/display_snapshot_virtual.h"
 #include "ui/display/manager/chromeos/display_util.h"
 #include "ui/display/manager/chromeos/update_display_configuration_task.h"
 #include "ui/display/types/display_mode.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/native_display_delegate.h"
 #include "ui/display/util/display_util.h"
 
-namespace ui {
+namespace display {
 
 namespace {
 
 typedef std::vector<const DisplayMode*> DisplayModeList;
 
 // The EDID specification marks the top bit of the manufacturer id as reserved.
 const int16_t kReservedManufacturerID = static_cast<int16_t>(1 << 15);
 
 struct DisplayState {
   DisplaySnapshot* display = nullptr;  // Not owned.
@@ skipping 765 matching lines @@
     }
   } else {
     client_protection_requests_[client_id][display_id] = desired_method_mask;
   }
 
   callback.Run(true);
   if (!content_protection_tasks_.empty())
     content_protection_tasks_.front().Run();
 }
 
-std::vector<ui::ColorCalibrationProfile>
+std::vector<ColorCalibrationProfile>
 DisplayConfigurator::GetAvailableColorCalibrationProfiles(int64_t display_id) {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableDisplayColorCalibration)) {
     for (const DisplaySnapshot* display : cached_displays_) {
       if (display->display_id() == display_id &&
           IsPhysicalDisplayType(display->type())) {
         return native_display_delegate_->GetAvailableColorCalibrationProfiles(
             *display);
       }
     }
   }
 
-  return std::vector<ui::ColorCalibrationProfile>();
+  return std::vector<ColorCalibrationProfile>();
 }
 
 bool DisplayConfigurator::SetColorCalibrationProfile(
     int64_t display_id,
-    ui::ColorCalibrationProfile new_profile) {
+    ColorCalibrationProfile new_profile) {
   for (const DisplaySnapshot* display : cached_displays_) {
     if (display->display_id() == display_id &&
         IsPhysicalDisplayType(display->type())) {
       return native_display_delegate_->SetColorCalibrationProfile(*display,
                                                                   new_profile);
     }
   }
 
   return false;
 }
@@ skipping 308 matching lines @@
 }
 
 void DisplayConfigurator::NotifyPowerStateObservers() {
   for (Observer& observer : observers_)
     observer.OnPowerStateChanged(current_power_state_);
 }
 
 int64_t DisplayConfigurator::AddVirtualDisplay(const gfx::Size& display_size) {
   if (last_virtual_display_id_ == 0xff) {
     LOG(WARNING) << "Exceeded virtual display id limit";
-    return display::kInvalidDisplayId;
+    return kInvalidDisplayId;
   }
 
-  DisplaySnapshotVirtual* virtual_snapshot = new DisplaySnapshotVirtual(
-      display::GenerateDisplayID(kReservedManufacturerID, 0x0,
-                                 ++last_virtual_display_id_),
-      display_size);
+  DisplaySnapshotVirtual* virtual_snapshot =
+      new DisplaySnapshotVirtual(GenerateDisplayID(kReservedManufacturerID, 0x0,
+                                                   ++last_virtual_display_id_),
+                                 display_size);
   virtual_display_snapshots_.push_back(virtual_snapshot);
   ConfigureDisplays();
 
   return virtual_snapshot->display_id();
 }
 
 bool DisplayConfigurator::RemoveVirtualDisplay(int64_t display_id) {
   bool display_found = false;
   for (auto it = virtual_display_snapshots_.begin();
        it != virtual_display_snapshots_.end(); ++it) {
@@ skipping 13 matching lines @@
     max_display_id = std::max(max_display_id, display->display_id());
   last_virtual_display_id_ = max_display_id & 0xff;
 
   return true;
 }
 
 bool DisplayConfigurator::IsDisplayOn() const {
   return current_power_state_ != chromeos::DISPLAY_POWER_ALL_OFF;
 }
 
-}  // namespace ui
+}  // namespace display