Fix namespace for src/ui/display/.

ui/ozone/platform/drm/gpu/drm_device.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/gpu/drm_device.h"
 
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <xf86drm.h>
@@ skipping 165 matching lines @@
   memset(&destroy, 0, sizeof(destroy));
   destroy.blob_id = id;
   ret = drmIoctl(fd, DRM_IOCTL_MODE_DESTROYPROPBLOB, &destroy);
   return ret < 0 ? -errno : ret;
 }
 
 using ScopedDrmColorLutPtr = std::unique_ptr<DrmColorLut, base::FreeDeleter>;
 using ScopedDrmColorCtmPtr = std::unique_ptr<DrmColorCtm, base::FreeDeleter>;
 
 ScopedDrmColorLutPtr CreateLutBlob(
-    const std::vector<GammaRampRGBEntry>& source) {
+    const std::vector<display::GammaRampRGBEntry>& source) {
   TRACE_EVENT0("drm", "CreateLutBlob");
   if (source.empty())
     return nullptr;
 
   ScopedDrmColorLutPtr lut(
       static_cast<DrmColorLut*>(malloc(sizeof(DrmColorLut) * source.size())));
   DrmColorLut* p = lut.get();
   for (size_t i = 0; i < source.size(); ++i) {
     p[i].red = source[i].r;
     p[i].green = source[i].g;
@@ skipping 47 matching lines @@
     LOG(ERROR) << "Error updating property: " << base::safe_strerror(res)
                << " for property " << property_name;
   } else {
     success = true;
   }
   if (blob_id != 0)
     DestroyPropertyBlob(fd, blob_id);
   return success;
 }
 
-std::vector<GammaRampRGBEntry> ResampleLut(
-    const std::vector<GammaRampRGBEntry>& lut_in,
+std::vector<display::GammaRampRGBEntry> ResampleLut(
+    const std::vector<display::GammaRampRGBEntry>& lut_in,
     size_t desired_size) {
   TRACE_EVENT1("drm", "ResampleLut", "desired_size", desired_size);
   if (lut_in.empty())
-    return std::vector<GammaRampRGBEntry>();
+    return std::vector<display::GammaRampRGBEntry>();
 
   if (lut_in.size() == desired_size)
     return lut_in;
 
-  std::vector<GammaRampRGBEntry> result;
+  std::vector<display::GammaRampRGBEntry> result;
   result.resize(desired_size);
 
   for (size_t i = 0; i < desired_size; ++i) {
     size_t base_index = lut_in.size() * i / desired_size;
     size_t remaining = lut_in.size() * i % desired_size;
     if (base_index < lut_in.size() - 1) {
       result[i].r = lut_in[base_index].r +
                     (lut_in[base_index + 1].r - lut_in[base_index].r) *
                         remaining / desired_size;
       result[i].g = lut_in[base_index].g +
@@ skipping 417 matching lines @@
   DCHECK(file_.IsValid());
   return (drmSetMaster(file_.GetPlatformFile()) == 0);
 }
 
 bool DrmDevice::DropMaster() {
   TRACE_EVENT1("drm", "DrmDevice::DropMaster", "path", device_path_.value());
   DCHECK(file_.IsValid());
   return (drmDropMaster(file_.GetPlatformFile()) == 0);
 }
 
-bool DrmDevice::SetGammaRamp(uint32_t crtc_id,
-                             const std::vector<GammaRampRGBEntry>& lut) {
+bool DrmDevice::SetGammaRamp(
+    uint32_t crtc_id,
+    const std::vector<display::GammaRampRGBEntry>& lut) {
   ScopedDrmCrtcPtr crtc = GetCrtc(crtc_id);
   size_t gamma_size = static_cast<size_t>(crtc->gamma_size);
 
   if (gamma_size == 0 && lut.empty())
     return true;
 
   if (gamma_size == 0) {
     LOG(ERROR) << "Gamma table not supported";
     return false;
   }
@@ skipping 28 matching lines @@
   }
 
   DCHECK(file_.IsValid());
   TRACE_EVENT0("drm", "DrmDevice::SetGamma");
   return (drmModeCrtcSetGamma(file_.GetPlatformFile(), crtc_id, r.size(), &r[0],
                               &g[0], &b[0]) == 0);
 }
 
 bool DrmDevice::SetColorCorrection(
     uint32_t crtc_id,
-    const std::vector<GammaRampRGBEntry>& degamma_lut,
-    const std::vector<GammaRampRGBEntry>& gamma_lut,
+    const std::vector<display::GammaRampRGBEntry>& degamma_lut,
+    const std::vector<display::GammaRampRGBEntry>& gamma_lut,
     const std::vector<float>& correction_matrix) {
   ScopedDrmObjectPropertyPtr crtc_props(drmModeObjectGetProperties(
       file_.GetPlatformFile(), crtc_id, DRM_MODE_OBJECT_CRTC));
   uint64_t degamma_lut_size = 0;
   uint64_t gamma_lut_size = 0;
 
   for (uint32_t i = 0; i < crtc_props->count_props; ++i) {
     ScopedDrmPropertyPtr property(
         drmModeGetProperty(file_.GetPlatformFile(), crtc_props->props[i]));
     if (property && !strcmp(property->name, "DEGAMMA_LUT_SIZE")) {
@@ skipping 48 matching lines @@
               reinterpret_cast<unsigned char*>(ctm_blob_data.get()),
               sizeof(DrmColorCtm)))
         return false;
     }
   }
 
   return true;
 }
 
 }  // namespace ui