Fix namespace for src/ui/display/.

ash/display/display_color_manager_chromeos.cc

 // Copyright 2015 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 "ash/display/display_color_manager_chromeos.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 130 matching lines @@
   }
 
   VLOG(1) << "ICC file successfully parsed";
   qcms_profile_release(display_profile);
   return data;
 }
 
 }  // namespace
 
 DisplayColorManager::DisplayColorManager(
-    ui::DisplayConfigurator* configurator,
+    display::DisplayConfigurator* configurator,
     base::SequencedWorkerPool* blocking_pool)
     : configurator_(configurator),
       blocking_pool_(blocking_pool),
       weak_ptr_factory_(this) {
   configurator_->AddObserver(this);
 }
 
 DisplayColorManager::~DisplayColorManager() {
   configurator_->RemoveObserver(this);
 }
 
 void DisplayColorManager::OnDisplayModeChanged(
-    const ui::DisplayConfigurator::DisplayStateList& display_states) {
-  for (const ui::DisplaySnapshot* state : display_states) {
+    const display::DisplayConfigurator::DisplayStateList& display_states) {
+  for (const display::DisplaySnapshot* state : display_states) {
     // Ensure we always reset the configuration before setting a new one.
     configurator_->SetColorCorrection(
-        state->display_id(), std::vector<ui::GammaRampRGBEntry>(),
-        std::vector<ui::GammaRampRGBEntry>(), std::vector<float>());
+        state->display_id(), std::vector<display::GammaRampRGBEntry>(),
+        std::vector<display::GammaRampRGBEntry>(), std::vector<float>());
 
     if (calibration_map_[state->product_id()]) {
       ApplyDisplayColorCalibration(state->display_id(), state->product_id());
     } else {
-      if (state->product_id() != ui::DisplaySnapshot::kInvalidProductID)
+      if (state->product_id() != display::DisplaySnapshot::kInvalidProductID)
         LoadCalibrationForDisplay(state);
     }
   }
 }
 
 void DisplayColorManager::ApplyDisplayColorCalibration(int64_t display_id,
                                                        int64_t product_id) {
   if (calibration_map_.find(product_id) != calibration_map_.end()) {
     ColorCalibrationData* data = calibration_map_[product_id].get();
     if (!configurator_->SetColorCorrection(display_id, data->degamma_lut,
                                            data->gamma_lut,
                                            data->correction_matrix))
       LOG(WARNING) << "Error applying color correction data";
   }
 }
 
 void DisplayColorManager::LoadCalibrationForDisplay(
-    const ui::DisplaySnapshot* display) {
+    const display::DisplaySnapshot* display) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (display->display_id() == display::kInvalidDisplayId) {
     LOG(WARNING) << "Trying to load calibration data for invalid display id";
     return;
   }
 
   quirks::QuirksManager::Get()->RequestIccProfilePath(
       display->product_id(),
       base::Bind(&DisplayColorManager::FinishLoadCalibrationForDisplay,
                  weak_ptr_factory_.GetWeakPtr(), display->display_id(),
                  display->product_id(), display->has_color_correction_matrix(),
                  display->type()));
 }
 
 void DisplayColorManager::FinishLoadCalibrationForDisplay(
     int64_t display_id,
     int64_t product_id,
     bool has_color_correction_matrix,
-    ui::DisplayConnectionType type,
+    display::DisplayConnectionType type,
     const base::FilePath& path,
     bool file_downloaded) {
   DCHECK(thread_checker_.CalledOnValidThread());
   std::string product_string = quirks::IdToHexString(product_id);
   if (path.empty()) {
     VLOG(1) << "No ICC file found with product id: " << product_string
             << " for display id: " << display_id;
     return;
   }
 
-  if (file_downloaded && type == ui::DISPLAY_CONNECTION_TYPE_INTERNAL) {
+  if (file_downloaded && type == display::DISPLAY_CONNECTION_TYPE_INTERNAL) {
     VLOG(1) << "Downloaded ICC file with product id: " << product_string
             << " for internal display id: " << display_id
             << ". Profile will be applied on next startup.";
     return;
   }
 
   VLOG(1) << "Loading ICC file " << path.value()
           << " for display id: " << display_id
           << " with product id: " << product_string;
 
@@ skipping 13 matching lines @@
     calibration_map_[product_id] = std::move(data);
     ApplyDisplayColorCalibration(display_id, product_id);
   }
 }
 
 DisplayColorManager::ColorCalibrationData::ColorCalibrationData() {}
 
 DisplayColorManager::ColorCalibrationData::~ColorCalibrationData() {}
 
 }  // namespace ash