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

chrome/browser/chromeos/display/display_preferences.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/chromeos/display/display_preferences.h"
 
 #include <stddef.h>
 
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/display_pref_util.h"
 #include "ash/display/display_util.h"
 #include "ash/display/json_converter.h"
 #include "ash/shell.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/user_manager/user_manager.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
-#include "ui/gfx/display.h"
+#include "ui/display/display.h"
 #include "ui/gfx/geometry/insets.h"
-#include "ui/gfx/screen.h"
 #include "url/url_canon.h"
 #include "url/url_util.h"
 
 namespace chromeos {
 namespace {
 
 const char kInsetsTopKey[] = "insets_top";
 const char kInsetsLeftKey[] = "insets_left";
 const char kInsetsBottomKey[] = "insets_bottom";
 const char kInsetsRightKey[] = "insets_right";
@@ skipping 102 matching lines @@
 
 void LoadDisplayProperties() {
   PrefService* local_state = g_browser_process->local_state();
   const base::DictionaryValue* properties = local_state->GetDictionary(
       prefs::kDisplayProperties);
   for (base::DictionaryValue::Iterator it(*properties);
        !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* dict_value = nullptr;
     if (!it.value().GetAsDictionary(&dict_value) || dict_value == nullptr)
       continue;
-    int64_t id = gfx::Display::kInvalidDisplayID;
+    int64_t id = display::Display::kInvalidDisplayID;
     if (!base::StringToInt64(it.key(), &id) ||
-        id == gfx::Display::kInvalidDisplayID) {
+        id == display::Display::kInvalidDisplayID) {
       continue;
     }
-    gfx::Display::Rotation rotation = gfx::Display::ROTATE_0;
+    display::Display::Rotation rotation = display::Display::ROTATE_0;
     float ui_scale = 1.0f;
     const gfx::Insets* insets_to_set = nullptr;
 
     int rotation_value = 0;
     if (dict_value->GetInteger("rotation", &rotation_value)) {
-      rotation = static_cast<gfx::Display::Rotation>(rotation_value);
+      rotation = static_cast<display::Display::Rotation>(rotation_value);
     }
     int ui_scale_value = 0;
     if (dict_value->GetInteger("ui-scale", &ui_scale_value))
       ui_scale = static_cast<float>(ui_scale_value) / 1000.0f;
 
     int width = 0, height = 0;
     dict_value->GetInteger("width", &width);
     dict_value->GetInteger("height", &height);
     gfx::Size resolution_in_pixels(width, height);
 
@@ skipping 22 matching lines @@
 
 void LoadDisplayRotationState() {
   PrefService* local_state = g_browser_process->local_state();
   const base::DictionaryValue* properties =
       local_state->GetDictionary(prefs::kDisplayRotationLock);
 
   bool rotation_lock = false;
   if (!properties->GetBoolean("lock", &rotation_lock))
     return;
 
-  int rotation = gfx::Display::ROTATE_0;
+  int rotation = display::Display::ROTATE_0;
   if (!properties->GetInteger("orientation", &rotation))
     return;
 
-  GetDisplayManager()->RegisterDisplayRotationProperties(rotation_lock,
-      static_cast<gfx::Display::Rotation>(rotation));
+  GetDisplayManager()->RegisterDisplayRotationProperties(
+      rotation_lock, static_cast<display::Display::Rotation>(rotation));
 }
 
 void StoreDisplayLayoutPref(const display::DisplayIdList& list,
                             const display::DisplayLayout& display_layout) {
   std::string name = ash::DisplayIdListToString(list);
 
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate update(local_state, prefs::kSecondaryDisplays);
   base::DictionaryValue* pref_data = update.Get();
   std::unique_ptr<base::Value> layout_value(new base::DictionaryValue());
@@ skipping 21 matching lines @@
 
 void StoreCurrentDisplayProperties() {
   ash::DisplayManager* display_manager = GetDisplayManager();
   PrefService* local_state = g_browser_process->local_state();
 
   DictionaryPrefUpdate update(local_state, prefs::kDisplayProperties);
   base::DictionaryValue* pref_data = update.Get();
 
   size_t num = display_manager->GetNumDisplays();
   for (size_t i = 0; i < num; ++i) {
-    const gfx::Display& display = display_manager->GetDisplayAt(i);
+    const display::Display& display = display_manager->GetDisplayAt(i);
     int64_t id = display.id();
     ash::DisplayInfo info = display_manager->GetDisplayInfo(id);
 
     std::unique_ptr<base::DictionaryValue> property_value(
         new base::DictionaryValue());
     // Don't save the display preference in unified mode because its
     // size and modes can change depending on the combination of displays.
     if (display_manager->IsInUnifiedMode())
       continue;
-    property_value->SetInteger(
-        "rotation",
-        static_cast<int>(info.GetRotation(gfx::Display::ROTATION_SOURCE_USER)));
+    property_value->SetInteger("rotation",
+                               static_cast<int>(info.GetRotation(
+                                   display::Display::ROTATION_SOURCE_USER)));
     property_value->SetInteger(
         "ui-scale", static_cast<int>(info.configured_ui_scale() * 1000));
 
     ash::DisplayMode mode;
     if (!display.IsInternal() &&
         display_manager->GetSelectedModeForDisplayId(id, &mode) &&
         !mode.native) {
       property_value->SetInteger("width", mode.size.width());
       property_value->SetInteger("height", mode.size.height());
       property_value->SetInteger(
@@ skipping 76 matching lines @@
   if (!UserCanSaveDisplayPreference() ||
       !ash::Shell::GetInstance()->ShouldSaveDisplaySettings()) {
     return;
   }
 
   StoreCurrentDisplayLayoutPrefs();
   StoreCurrentDisplayProperties();
 }
 
 void StoreDisplayRotationPrefs(bool rotation_lock) {
-  if (!gfx::Display::HasInternalDisplay())
+  if (!display::Display::HasInternalDisplay())
     return;
 
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate update(local_state, prefs::kDisplayRotationLock);
   base::DictionaryValue* pref_data = update.Get();
   pref_data->SetBoolean("lock", rotation_lock);
-  gfx::Display::Rotation rotation =
+  display::Display::Rotation rotation =
       GetDisplayManager()
-          ->GetDisplayInfo(gfx::Display::InternalDisplayId())
-          .GetRotation(gfx::Display::ROTATION_SOURCE_ACCELEROMETER);
+          ->GetDisplayInfo(display::Display::InternalDisplayId())
+          .GetRotation(display::Display::ROTATION_SOURCE_ACCELEROMETER);
   pref_data->SetInteger("orientation", static_cast<int>(rotation));
 }
 
 void LoadDisplayPreferences(bool first_run_after_boot) {
   LoadDisplayLayouts();
   LoadDisplayProperties();
   LoadDisplayRotationState();
   if (!first_run_after_boot) {
     PrefService* local_state = g_browser_process->local_state();
     // Restore DisplayPowerState:
@@ skipping 11 matching lines @@
                                    const display::DisplayLayout& layout) {
   StoreDisplayLayoutPref(list, layout);
 }
 
 // Stores the given |power_state|.
 void StoreDisplayPowerStateForTest(DisplayPowerState power_state) {
   StoreDisplayPowerState(power_state);
 }
 
 }  // namespace chromeos