Rename gfx::Display/Screen to display::Display/Screen in chrome

chrome/browser/extensions/display_info_provider_chromeos.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 "chrome/browser/extensions/display_info_provider_chromeos.h"
 
 #include <stdint.h>
 
 #include "ash/display/display_configuration_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/resolution_notification_controller.h"
 #include "ash/shell.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chromeos/display/display_preferences.h"
 #include "extensions/common/api/system_display.h"
+#include "ui/display/display.h"
 #include "ui/display/manager/display_layout.h"
-#include "ui/gfx/display.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace extensions {
 
 using api::system_display::Bounds;
 using api::system_display::DisplayUnitInfo;
 using api::system_display::DisplayProperties;
 using api::system_display::Insets;
 
 namespace {
 
 // Maximum allowed bounds origin absolute value.
 const int kMaxBoundsOrigin = 200 * 1000;
 
 // Checks if the given integer value is valid display rotation in degrees.
 bool IsValidRotationValue(int rotation) {
   return rotation == 0 || rotation == 90 || rotation == 180 || rotation == 270;
 }
 
 // Converts integer integer value in degrees to Rotation enum value.
-gfx::Display::Rotation DegreesToRotation(int degrees) {
+display::Display::Rotation DegreesToRotation(int degrees) {
   DCHECK(IsValidRotationValue(degrees));
   switch (degrees) {
     case 0:
-      return gfx::Display::ROTATE_0;
+      return display::Display::ROTATE_0;
     case 90:
-      return gfx::Display::ROTATE_90;
+      return display::Display::ROTATE_90;
     case 180:
-      return gfx::Display::ROTATE_180;
+      return display::Display::ROTATE_180;
     case 270:
-      return gfx::Display::ROTATE_270;
+      return display::Display::ROTATE_270;
     default:
-      return gfx::Display::ROTATE_0;
+      return display::Display::ROTATE_0;
   }
 }
 
 // Checks if the given point is over the radius vector described by it's end
 // point |vector|. The point is over a vector if it's on its positive (left)
 // side. The method sees a point on the same line as the vector as being over
 // the vector.
 bool PointIsOverRadiusVector(const gfx::Point& point,
                              const gfx::Point& vector) {
   // |point| is left of |vector| if its radius vector's scalar product with a
@@ skipping 115 matching lines @@
   ash::Shell::GetInstance()
       ->display_configuration_controller()
       ->SetDisplayLayout(std::move(layout), true /* user_action */);
 }
 
 // Validates that parameters passed to the SetInfo function are valid for the
 // desired display and the current display manager state.
 // Returns whether the parameters are valid. On failure |error| is set to the
 // error message.
 bool ValidateParamsForDisplay(const DisplayProperties& info,
-                              const gfx::Display& display,
+                              const display::Display& display,
                               ash::DisplayManager* display_manager,
                               int64_t primary_display_id,
                               std::string* error) {
   int64_t id = display.id();
   bool is_primary =
       id == primary_display_id || (info.is_primary && *info.is_primary);
 
   // If mirroring source id is set, a display with the given id should exist,
   // and if should not be the same as the target display's id.
   if (info.mirroring_source_id && !info.mirroring_source_id->empty()) {
     int64_t mirroring_id;
     if (!base::StringToInt64(*info.mirroring_source_id, &mirroring_id) ||
         display_manager->GetDisplayForId(mirroring_id).id() ==
-            gfx::Display::kInvalidDisplayID) {
+            display::Display::kInvalidDisplayID) {
       *error = "Display " + *info.mirroring_source_id + " not found.";
       return false;
     }
 
     if (*info.mirroring_source_id == base::Int64ToString(id)) {
       *error = "Not allowed to mirror self.";
       return false;
     }
   }
 
@@ skipping 80 matching lines @@
     if (new_mode.IsEquivalent(current_mode)) {
       *error = "Display mode mataches crrent mode.";
       return false;
     }
 
     if (!display_manager->SetDisplayMode(id, new_mode)) {
       *error = "Unable to set the display mode.";
       return false;
     }
 
-    if (!gfx::Display::IsInternalDisplayId(id)) {
+    if (!display::Display::IsInternalDisplayId(id)) {
       // For external displays, show a notification confirming the resolution
       // change.
       ash::Shell::GetInstance()
           ->resolution_notification_controller()
           ->PrepareNotification(id, current_mode, new_mode,
                                 base::Bind(&chromeos::StoreDisplayPrefs));
     }
   }
   return true;
 }
 
 // Gets the display with the provided string id.
-gfx::Display GetTargetDisplay(const std::string& display_id_str,
-                              ash::DisplayManager* manager) {
+display::Display GetTargetDisplay(const std::string& display_id_str,
+                                  ash::DisplayManager* manager) {
   int64_t display_id;
   if (!base::StringToInt64(display_id_str, &display_id)) {
     // This should return invalid display.
-    return gfx::Display();
+    return display::Display();
   }
   return manager->GetDisplayForId(display_id);
 }
 
 extensions::api::system_display::DisplayMode GetDisplayMode(
     ash::DisplayManager* display_manager,
     const ash::DisplayInfo& display_info,
     const ash::DisplayMode& display_mode) {
   extensions::api::system_display::DisplayMode result;
 
-  bool is_internal = gfx::Display::HasInternalDisplay() &&
-                     gfx::Display::InternalDisplayId() == display_info.id();
+  bool is_internal = display::Display::HasInternalDisplay() &&
+                     display::Display::InternalDisplayId() == display_info.id();
   gfx::Size size_dip = display_mode.GetSizeInDIP(is_internal);
   result.width = size_dip.width();
   result.height = size_dip.height();
   result.width_in_native_pixels = display_mode.size.width();
   result.height_in_native_pixels = display_mode.size.height();
   result.ui_scale = display_mode.ui_scale;
   result.device_scale_factor = display_mode.device_scale_factor;
   result.is_native = display_mode.native;
   result.is_selected = display_mode.IsEquivalent(
       display_manager->GetActiveModeForDisplayId(display_info.id()));
   return result;
 }
 
 }  // namespace
 
 DisplayInfoProviderChromeOS::DisplayInfoProviderChromeOS() {
 }
 
 DisplayInfoProviderChromeOS::~DisplayInfoProviderChromeOS() {
 }
 
 bool DisplayInfoProviderChromeOS::SetInfo(const std::string& display_id_str,
                                           const DisplayProperties& info,
                                           std::string* error) {
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   ash::DisplayConfigurationController* display_configuration_controller =
       ash::Shell::GetInstance()->display_configuration_controller();
 
-  const gfx::Display target = GetTargetDisplay(display_id_str, display_manager);
+  const display::Display target =
+      GetTargetDisplay(display_id_str, display_manager);
 
-  if (target.id() == gfx::Display::kInvalidDisplayID) {
+  if (target.id() == display::Display::kInvalidDisplayID) {
     *error = "Display not found.";
     return false;
   }
 
   int64_t display_id = target.id();
-  const gfx::Display& primary = gfx::Screen::GetScreen()->GetPrimaryDisplay();
+  const display::Display& primary =
+      display::Screen::GetScreen()->GetPrimaryDisplay();
 
   if (!ValidateParamsForDisplay(
           info, target, display_manager, primary.id(), error)) {
     return false;
   }
 
   // Process 'isPrimary' parameter.
   if (info.is_primary && *info.is_primary && target.id() != primary.id()) {
     display_configuration_controller->SetPrimaryDisplayId(
         display_id, true /* user_action */);
@@ skipping 12 matching lines @@
                                        gfx::Insets(info.overscan->top,
                                                    info.overscan->left,
                                                    info.overscan->bottom,
                                                    info.overscan->right));
   }
 
   // Process 'rotation' parameter.
   if (info.rotation) {
     display_configuration_controller->SetDisplayRotation(
         display_id, DegreesToRotation(*info.rotation),
-        gfx::Display::ROTATION_SOURCE_ACTIVE, true /* user_action */);
+        display::Display::ROTATION_SOURCE_ACTIVE, true /* user_action */);
   }
 
   // Process new display origin parameters.
   gfx::Point new_bounds_origin = target.bounds().origin();
   if (info.bounds_origin_x)
     new_bounds_origin.set_x(*info.bounds_origin_x);
   if (info.bounds_origin_y)
     new_bounds_origin.set_y(*info.bounds_origin_y);
 
   if (new_bounds_origin != target.bounds().origin()) {
     gfx::Rect target_bounds = target.bounds();
     target_bounds.Offset(new_bounds_origin.x() - target.bounds().x(),
                          new_bounds_origin.y() - target.bounds().y());
     UpdateDisplayLayout(
         primary.bounds(), primary.id(), target_bounds, target.id());
   }
 
   return true;
 }
 
 void DisplayInfoProviderChromeOS::UpdateDisplayUnitInfoForPlatform(
-    const gfx::Display& display,
+    const display::Display& display,
     extensions::api::system_display::DisplayUnitInfo* unit) {
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   unit->name = display_manager->GetDisplayNameForId(display.id());
   if (display_manager->IsInMirrorMode()) {
     unit->mirroring_source_id =
         base::Int64ToString(display_manager->mirroring_display_id());
   }
 
   const ash::DisplayInfo& display_info =
@@ skipping 21 matching lines @@
   ash::Shell::GetInstance()->display_manager()->SetUnifiedDesktopEnabled(
       enable);
 }
 
 DisplayUnitInfoList DisplayInfoProviderChromeOS::GetAllDisplaysInfo() {
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   if (!display_manager->IsInUnifiedMode())
     return DisplayInfoProvider::GetAllDisplaysInfo();
 
-  std::vector<gfx::Display> displays =
+  std::vector<display::Display> displays =
       display_manager->software_mirroring_display_list();
   CHECK_GT(displays.size(), 0u);
 
   // Use first display as primary.
   int64_t primary_id = displays[0].id();
   DisplayUnitInfoList all_displays;
-  for (const gfx::Display& display : displays) {
+  for (const display::Display& display : displays) {
     api::system_display::DisplayUnitInfo unit =
         CreateDisplayUnitInfo(display, primary_id);
     UpdateDisplayUnitInfoForPlatform(display, &unit);
     all_displays.push_back(std::move(unit));
   }
   return all_displays;
 }
 
 // static
 DisplayInfoProvider* DisplayInfoProvider::Create() {
   return new DisplayInfoProviderChromeOS();
 }
 
 }  // namespace extensions