Fix namespace for src/ui/display/.

ui/ozone/platform/drm/host/drm_display_host_manager.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/ozone/platform/drm/host/drm_display_host_manager.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <xf86drm.h>
 
@@ skipping 159 matching lines @@
   DCHECK(!delegate_);
   delegate_ = delegate;
 }
 
 void DrmDisplayHostManager::RemoveDelegate(DrmNativeDisplayDelegate* delegate) {
   DCHECK_EQ(delegate_, delegate);
   delegate_ = nullptr;
 }
 
 void DrmDisplayHostManager::TakeDisplayControl(
-    const DisplayControlCallback& callback) {
+    const display::DisplayControlCallback& callback) {
   if (display_control_change_pending_) {
     LOG(ERROR) << "TakeDisplayControl called while change already pending";
     callback.Run(false);
     return;
   }
 
   if (!display_externally_controlled_) {
     LOG(ERROR) << "TakeDisplayControl called while display already owned";
     callback.Run(true);
     return;
   }
 
   take_display_control_callback_ = callback;
   display_control_change_pending_ = true;
 
   if (!proxy_->GpuTakeDisplayControl())
     GpuTookDisplayControl(false);
 }
 
 void DrmDisplayHostManager::RelinquishDisplayControl(
-    const DisplayControlCallback& callback) {
+    const display::DisplayControlCallback& callback) {
   if (display_control_change_pending_) {
     LOG(ERROR)
         << "RelinquishDisplayControl called while change already pending";
     callback.Run(false);
     return;
   }
 
   if (display_externally_controlled_) {
     LOG(ERROR) << "RelinquishDisplayControl called while display not owned";
     callback.Run(true);
     return;
   }
 
   relinquish_display_control_callback_ = callback;
   display_control_change_pending_ = true;
 
   if (!proxy_->GpuRelinquishDisplayControl())
     GpuRelinquishedDisplayControl(false);
 }
 
 void DrmDisplayHostManager::UpdateDisplays(
-    const GetDisplaysCallback& callback) {
+    const display::GetDisplaysCallback& callback) {
   get_displays_callback_ = callback;
   if (!proxy_->GpuRefreshNativeDisplays()) {
     get_displays_callback_.Reset();
     RunUpdateDisplaysCallback(callback);
   }
 }
 
 void DrmDisplayHostManager::OnDeviceEvent(const DeviceEvent& event) {
   if (event.device_type() != DeviceEvent::DISPLAY)
     return;
@@ skipping 155 matching lines @@
                                                  bool status) {
   DrmDisplayHost* display = GetDisplay(display_id);
   if (display)
     display->OnDisplayConfigured(status);
   else
     LOG(ERROR) << "Couldn't find display with id=" << display_id;
 }
 
 void DrmDisplayHostManager::GpuReceivedHDCPState(int64_t display_id,
                                                  bool status,
-                                                 HDCPState state) {
+                                                 display::HDCPState state) {
   DrmDisplayHost* display = GetDisplay(display_id);
   if (display)
     display->OnHDCPStateReceived(status, state);
   else
     LOG(ERROR) << "Couldn't find display with id=" << display_id;
 }
 
 void DrmDisplayHostManager::GpuUpdatedHDCPState(int64_t display_id,
                                                 bool status) {
   DrmDisplayHost* display = GetDisplay(display_id);
@@ skipping 37 matching lines @@
     display_externally_controlled_ = true;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(relinquish_display_control_callback_, status));
   relinquish_display_control_callback_.Reset();
   display_control_change_pending_ = false;
 }
 
 void DrmDisplayHostManager::RunUpdateDisplaysCallback(
-    const GetDisplaysCallback& callback) const {
-  std::vector<DisplaySnapshot*> snapshots;
+    const display::GetDisplaysCallback& callback) const {
+  std::vector<display::DisplaySnapshot*> snapshots;
   for (const auto& display : displays_)
     snapshots.push_back(display->snapshot());
 
   callback.Run(snapshots);
 }
 
 void DrmDisplayHostManager::NotifyDisplayDelegate() const {
   if (delegate_)
     delegate_->OnConfigurationChanged();
 }
 
 }  // namespace ui