Eliminate ash::internal namespace

chrome/browser/ui/webui/options/chromeos/display_options_handler.cc

 // Copyright (c) 2012 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 "chrome/browser/ui/webui/options/chromeos/display_options_handler.h"
 
 #include <string>
 
 #include "ash/display/display_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/output_configurator_animation.h"
 #include "ash/display/resolution_notification_controller.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/display/display_preferences.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/ash_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 
-using ash::internal::DisplayManager;
+using ash::DisplayManager;
 
 namespace chromeos {
 namespace options {
 namespace {
 
 DisplayManager* GetDisplayManager() {
   return ash::Shell::GetInstance()->display_manager();
 }
 
 int64 GetDisplayId(const base::ListValue* args) {
   // Assumes the display ID is specified as the first argument.
   std::string id_value;
   if (!args->GetString(0, &id_value)) {
     LOG(ERROR) << "Can't find ID";
     return gfx::Display::kInvalidDisplayID;
   }
 
   int64 display_id = gfx::Display::kInvalidDisplayID;
   if (!base::StringToInt64(id_value, &display_id)) {
     LOG(ERROR) << "Invalid display id: " << id_value;
     return gfx::Display::kInvalidDisplayID;
   }
 
   return display_id;
 }
 
-bool CompareDisplayMode(ash::internal::DisplayMode d1,
-                        ash::internal::DisplayMode d2) {
+bool CompareDisplayMode(ash::DisplayMode d1, ash::DisplayMode d2) {
   if (d1.size.GetArea() == d2.size.GetArea())
     return d1.refresh_rate < d2.refresh_rate;
   return d1.size.GetArea() < d2.size.GetArea();
 }
 
 base::string16 GetColorProfileName(ui::ColorCalibrationProfile profile) {
   switch (profile) {
     case ui::COLOR_PROFILE_STANDARD:
       return l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_DISPLAY_OPTIONS_COLOR_PROFILE_STANDARD);
@@ skipping 127 matching lines @@
 
 void DisplayOptionsHandler::SendDisplayInfo(
     const std::vector<gfx::Display>& displays) {
   DisplayManager* display_manager = GetDisplayManager();
   base::FundamentalValue mirroring(display_manager->IsMirrored());
 
   int64 primary_id = ash::Shell::GetScreen()->GetPrimaryDisplay().id();
   base::ListValue js_displays;
   for (size_t i = 0; i < displays.size(); ++i) {
     const gfx::Display& display = displays[i];
-    const ash::internal::DisplayInfo& display_info =
+    const ash::DisplayInfo& display_info =
         display_manager->GetDisplayInfo(display.id());
     const gfx::Rect& bounds = display.bounds();
     base::DictionaryValue* js_display = new base::DictionaryValue();
     js_display->SetString("id", base::Int64ToString(display.id()));
     js_display->SetInteger("x", bounds.x());
     js_display->SetInteger("y", bounds.y());
     js_display->SetInteger("width", bounds.width());
     js_display->SetInteger("height", bounds.height());
     js_display->SetString("name",
                           display_manager->GetDisplayNameForId(display.id()));
     js_display->SetBoolean("isPrimary", display.id() == primary_id);
     js_display->SetBoolean("isInternal", display.IsInternal());
     js_display->SetInteger("orientation",
                            static_cast<int>(display_info.rotation()));
-    std::vector<ash::internal::DisplayMode> display_modes;
+    std::vector<ash::DisplayMode> display_modes;
     std::vector<float> ui_scales;
     if (display.IsInternal()) {
       ui_scales = DisplayManager::GetScalesForDisplay(display_info);
       gfx::SizeF base_size = display_info.bounds_in_native().size();
       base_size.Scale(1.0f / display_info.device_scale_factor());
       if (display_info.rotation() == gfx::Display::ROTATE_90 ||
           display_info.rotation() == gfx::Display::ROTATE_270) {
         float tmp = base_size.width();
         base_size.set_width(base_size.height());
         base_size.set_height(tmp);
       }
       for (size_t i = 0; i < ui_scales.size(); ++i) {
         gfx::SizeF new_size = base_size;
         new_size.Scale(ui_scales[i]);
-        display_modes.push_back(ash::internal::DisplayMode(
+        display_modes.push_back(ash::DisplayMode(
             gfx::ToFlooredSize(new_size), -1.0f, false, false));
       }
     } else {
       for (size_t i = 0; i < display_info.display_modes().size(); ++i)
         display_modes.push_back(display_info.display_modes()[i]);
     }
     std::sort(display_modes.begin(), display_modes.end(), CompareDisplayMode);
 
     base::ListValue* js_resolutions = new base::ListValue();
     gfx::Size current_size = display_info.bounds_in_native().size();
@@ skipping 138 matching lines @@
   double height = 0.0f;
   if (!args->GetDouble(1, &width) || width == 0.0f) {
     LOG(ERROR) << "Can't find new width";
     return;
   }
   if (!args->GetDouble(2, &height) || height == 0.0f) {
     LOG(ERROR) << "Can't find new height";
     return;
   }
 
-  const ash::internal::DisplayInfo& display_info =
+  const ash::DisplayInfo& display_info =
       GetDisplayManager()->GetDisplayInfo(display_id);
   gfx::Insets current_overscan = display_info.GetOverscanInsetsInPixel();
   gfx::Size new_resolution = gfx::ToFlooredSize(gfx::SizeF(width, height));
   new_resolution.Enlarge(current_overscan.width(), current_overscan.height());
   gfx::Size old_resolution = display_info.bounds_in_native().size();
   bool has_new_resolution = false;
   bool has_old_resolution = false;
   for (size_t i = 0; i < display_info.display_modes().size(); ++i) {
-    ash::internal::DisplayMode display_mode = display_info.display_modes()[i];
+    ash::DisplayMode display_mode = display_info.display_modes()[i];
     if (display_mode.size == new_resolution)
       has_new_resolution = true;
     if (display_mode.size == old_resolution)
       has_old_resolution = true;
   }
   if (!has_new_resolution) {
     LOG(ERROR) << "No new resolution " << new_resolution.ToString()
                << " is found in the display info " << display_info.ToString();
     return;
   }
@@ skipping 58 matching lines @@
     return;
   }
 
   GetDisplayManager()->SetColorCalibrationProfile(
       display_id, static_cast<ui::ColorCalibrationProfile>(profile_id));
   SendAllDisplayInfo();
 }
 
 }  // namespace options
 }  // namespace chromeos