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

ash/system/chromeos/tray_display.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 "ash/system/chromeos/tray_display.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "ash/display/display_manager.h"
 #include "ash/display/screen_orientation_controller_chromeos.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/shell.h"
 #include "ash/system/chromeos/devicetype_utils.h"
 #include "ash/system/system_notifier.h"
 #include "ash/system/tray/actionable_view.h"
 #include "ash/system/tray/fixed_sized_image_view.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/tray_constants.h"
 #include "ash/system/tray/tray_notification_view.h"
 #include "base/bind.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
-#include "ui/gfx/display.h"
+#include "ui/display/display.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notification_delegate.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/box_layout.h"
 
 using message_center::Notification;
 
 namespace ash {
 namespace {
 
 DisplayManager* GetDisplayManager() {
   return Shell::GetInstance()->display_manager();
 }
 
 base::string16 GetDisplayName(int64_t display_id) {
   return base::UTF8ToUTF16(
       GetDisplayManager()->GetDisplayNameForId(display_id));
 }
 
 base::string16 GetDisplaySize(int64_t display_id) {
   DisplayManager* display_manager = GetDisplayManager();
 
-  const gfx::Display* display = &display_manager->GetDisplayForId(display_id);
+  const display::Display* display =
+      &display_manager->GetDisplayForId(display_id);
 
   // We don't show display size for mirrored display. Fallback
   // to empty string if this happens on release build.
   bool mirroring = display_manager->mirroring_display_id() == display_id;
   DCHECK(!mirroring);
   if (mirroring)
     return base::string16();
 
   DCHECK(display->is_valid());
   return base::UTF8ToUTF16(display->size().ToString());
@@ skipping 21 matching lines @@
 
   return l10n_util::GetStringFUTF16(
       IDS_ASH_STATUS_TRAY_DISPLAY_SINGLE_DISPLAY,
       GetDisplayName(display_id),
       display_data);
 }
 
 base::string16 GetAllDisplayInfo() {
   DisplayManager* display_manager = GetDisplayManager();
   std::vector<base::string16> lines;
-  int64_t internal_id = gfx::Display::kInvalidDisplayID;
+  int64_t internal_id = display::Display::kInvalidDisplayID;
   // Make sure to show the internal display first.
   if (!display_manager->IsInUnifiedMode() &&
-      gfx::Display::IsInternalDisplayId(display_manager->first_display_id())) {
+      display::Display::IsInternalDisplayId(
+          display_manager->first_display_id())) {
     internal_id = display_manager->first_display_id();
     lines.push_back(GetDisplayInfoLine(internal_id));
   }
 
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     int64_t id = display_manager->GetDisplayAt(i).id();
     if (id == internal_id)
       continue;
     lines.push_back(GetDisplayInfoLine(id));
   }
@@ skipping 73 matching lines @@
     return true;
   }
 
   // Returns the name of the currently connected external display.
   // This should not be used when the external display is used for
   // mirroring.
   static base::string16 GetExternalDisplayName() {
     DisplayManager* display_manager = GetDisplayManager();
     DCHECK(!display_manager->IsInMirrorMode());
 
-    int64_t external_id = gfx::Display::kInvalidDisplayID;
+    int64_t external_id = display::Display::kInvalidDisplayID;
     for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
       int64_t id = display_manager->GetDisplayAt(i).id();
-      if (!gfx::Display::IsInternalDisplayId(id)) {
+      if (!display::Display::IsInternalDisplayId(id)) {
         external_id = id;
         break;
       }
     }
 
-    if (external_id == gfx::Display::kInvalidDisplayID) {
+    if (external_id == display::Display::kInvalidDisplayID) {
       return l10n_util::GetStringUTF16(
           IDS_ASH_STATUS_TRAY_UNKNOWN_DISPLAY_NAME);
     }
 
     // The external display name may have an annotation of "(width x height)" in
     // case that the display is rotated or its resolution is changed.
     base::string16 name = GetDisplayName(external_id);
     const DisplayInfo& display_info =
         display_manager->GetDisplayInfo(external_id);
-    if (display_info.GetActiveRotation() != gfx::Display::ROTATE_0 ||
+    if (display_info.GetActiveRotation() != display::Display::ROTATE_0 ||
         display_info.configured_ui_scale() != 1.0f ||
         !display_info.overscan_insets_in_dip().IsEmpty()) {
       name = l10n_util::GetStringFUTF16(
           IDS_ASH_STATUS_TRAY_DISPLAY_ANNOTATED_NAME,
           name, GetDisplaySize(external_id));
     } else if (display_info.overscan_insets_in_dip().IsEmpty() &&
                display_info.has_overscan()) {
       name = l10n_util::GetStringFUTF16(
           IDS_ASH_STATUS_TRAY_DISPLAY_ANNOTATED_NAME,
           name, l10n_util::GetStringUTF16(
               IDS_ASH_STATUS_TRAY_DISPLAY_ANNOTATION_OVERSCAN));
     }
 
     return name;
   }
 
   static base::string16 GetTrayDisplayMessage(
       base::string16* additional_message_out) {
     DisplayManager* display_manager = GetDisplayManager();
     if (display_manager->GetNumDisplays() > 1) {
-      if (gfx::Display::HasInternalDisplay()) {
+      if (display::Display::HasInternalDisplay()) {
         return l10n_util::GetStringFUTF16(
             IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED, GetExternalDisplayName());
       }
       return l10n_util::GetStringUTF16(
           IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED_NO_INTERNAL);
     }
 
     if (display_manager->IsInMirrorMode()) {
-      if (gfx::Display::HasInternalDisplay()) {
+      if (display::Display::HasInternalDisplay()) {
         return l10n_util::GetStringFUTF16(
             IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING,
             GetDisplayName(display_manager->mirroring_display_id()));
       }
       return l10n_util::GetStringUTF16(
           IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING_NO_INTERNAL);
     }
 
     if (display_manager->IsInUnifiedMode())
       return l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_DISPLAY_UNIFIED);
 
-    int64_t primary_id = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
-    if (gfx::Display::HasInternalDisplay() &&
-        !(gfx::Display::IsInternalDisplayId(primary_id))) {
+    int64_t primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
+    if (display::Display::HasInternalDisplay() &&
+        !(display::Display::IsInternalDisplayId(primary_id))) {
       if (additional_message_out) {
         *additional_message_out = ash::SubstituteChromeOSDeviceType(
             IDS_ASH_STATUS_TRAY_DISPLAY_DOCKED_DESCRIPTION);
       }
       return l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_DISPLAY_DOCKED);
     }
 
     return base::string16();
   }
 
  private:
   bool ShouldShowFirstDisplayInfo() const {
     const int64_t first_display_id = GetDisplayManager()->first_display_id();
 
     const DisplayInfo& display_info =
         GetDisplayManager()->GetDisplayInfo(first_display_id);
-    return (display_info.GetActiveRotation() != gfx::Display::ROTATE_0 &&
+    return (display_info.GetActiveRotation() != display::Display::ROTATE_0 &&
             (display_info.active_rotation_source() !=
-                 gfx::Display::ROTATION_SOURCE_ACCELEROMETER ||
-             !gfx::Display::IsInternalDisplayId(first_display_id))) ||
+                 display::Display::ROTATION_SOURCE_ACCELEROMETER ||
+             !display::Display::IsInternalDisplayId(first_display_id))) ||
            display_info.configured_ui_scale() != 1.0f ||
            !display_info.overscan_insets_in_dip().IsEmpty() ||
            display_info.has_overscan();
   }
 
   // Overridden from ActionableView.
   bool PerformAction(const ui::Event& event) override {
     OpenSettings();
     return true;
   }
@@ skipping 59 matching lines @@
         old_iter->second.configured_ui_scale()) {
       *additional_message_out = l10n_util::GetStringFUTF16(
           IDS_ASH_STATUS_TRAY_DISPLAY_RESOLUTION_CHANGED,
           GetDisplayName(iter->first), GetDisplaySize(iter->first));
       return true;
     }
     if (iter->second.GetActiveRotation() !=
         old_iter->second.GetActiveRotation()) {
       int rotation_text_id = 0;
       switch (iter->second.GetActiveRotation()) {
-        case gfx::Display::ROTATE_0:
+        case display::Display::ROTATE_0:
           rotation_text_id = IDS_ASH_STATUS_TRAY_DISPLAY_STANDARD_ORIENTATION;
           break;
-        case gfx::Display::ROTATE_90:
+        case display::Display::ROTATE_90:
           rotation_text_id = IDS_ASH_STATUS_TRAY_DISPLAY_ORIENTATION_90;
           break;
-        case gfx::Display::ROTATE_180:
+        case display::Display::ROTATE_180:
           rotation_text_id = IDS_ASH_STATUS_TRAY_DISPLAY_ORIENTATION_180;
           break;
-        case gfx::Display::ROTATE_270:
+        case display::Display::ROTATE_270:
           rotation_text_id = IDS_ASH_STATUS_TRAY_DISPLAY_ORIENTATION_270;
           break;
       }
       *additional_message_out = l10n_util::GetStringFUTF16(
           IDS_ASH_STATUS_TRAY_DISPLAY_ROTATED, GetDisplayName(iter->first),
           l10n_util::GetStringUTF16(rotation_text_id));
       return true;
     }
   }
 
@@ skipping 74 matching lines @@
 bool TrayDisplay::GetAccessibleStateForTesting(ui::AXViewState* state) {
   views::View* view = default_;
   if (view) {
     view->GetAccessibleState(state);
     return true;
   }
   return false;
 }
 
 }  // namespace ash