Relocate reuseable portions of ash/display/display_util.*

chrome/browser/chromeos/display/display_preferences_unittest.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 <stdint.h>
 
 #include <string>
 #include <utility>
@@ skipping 19 matching lines @@
 #include "chrome/browser/chromeos/display/display_configuration_observer.h"
 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/prefs/testing_pref_service.h"
 #include "ui/display/chromeos/display_configurator.h"
 #include "ui/display/manager/display_layout_builder.h"
 #include "ui/display/manager/display_layout_store.h"
+#include "ui/display/manager/display_manager_utilities.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/vector3d_f.h"
 #include "ui/message_center/message_center.h"
 
 using ash::ResolutionNotificationController;
 
 namespace chromeos {
 namespace {
 const char kPrimaryIdKey[] = "primary-id";
 const char kMirroredKey[] = "mirrored";
@@ skipping 52 matching lines @@
         .WillRepeatedly(testing::Return(false));
   }
 
   // Do not use the implementation of display_preferences.cc directly to avoid
   // notifying the update to the system.
   void StoreDisplayLayoutPrefForList(
       const display::DisplayIdList& list,
       display::DisplayPlacement::Position position,
       int offset,
       int64_t primary_id) {
-    std::string name = ash::DisplayIdListToString(list);
+    std::string name = ui::DisplayIdListToString(list);
     DictionaryPrefUpdate update(&local_state_, prefs::kSecondaryDisplays);
     display::DisplayLayout display_layout;
     display_layout.placement_list.emplace_back(position, offset);
     display_layout.primary_id = primary_id;
 
     DCHECK(!name.empty());
 
     base::DictionaryValue* pref_data = update.Get();
     std::unique_ptr<base::Value> layout_value(new base::DictionaryValue());
     if (pref_data->HasKey(name)) {
       base::Value* value = nullptr;
       if (pref_data->Get(name, &value) && value != nullptr)
         layout_value.reset(value->DeepCopy());
     }
     if (ash::DisplayLayoutToJson(display_layout, layout_value.get()))
       pref_data->Set(name, layout_value.release());
   }
 
   void StoreDisplayPropertyForList(const display::DisplayIdList& list,
                                    std::string key,
                                    std::unique_ptr<base::Value> value) {
-    std::string name = ash::DisplayIdListToString(list);
+    std::string name = ui::DisplayIdListToString(list);
 
     DictionaryPrefUpdate update(&local_state_, prefs::kSecondaryDisplays);
     base::DictionaryValue* pref_data = update.Get();
 
     if (pref_data->HasKey(name)) {
       base::Value* layout_value = nullptr;
       pref_data->Get(name, &layout_value);
       if (layout_value)
         static_cast<base::DictionaryValue*>(layout_value)
             ->Set(key, std::move(value));
@@ skipping 832 matching lines @@
 
   UpdateDisplay("200x200,100x100");
   display::DisplayIdList list = display_manager->GetCurrentDisplayIdList();
   EXPECT_EQ(
       "400x200",
       display::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
 
   const base::DictionaryValue* secondary_displays =
       local_state()->GetDictionary(prefs::kSecondaryDisplays);
   const base::DictionaryValue* new_value = nullptr;
-  EXPECT_TRUE(secondary_displays->GetDictionary(
-      ash::DisplayIdListToString(list), &new_value));
+  EXPECT_TRUE(secondary_displays->GetDictionary(ui::DisplayIdListToString(list),
+                                                &new_value));
 
   display::DisplayLayout stored_layout;
   EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
   EXPECT_TRUE(stored_layout.default_unified);
   EXPECT_FALSE(stored_layout.mirrored);
 
   const base::DictionaryValue* displays =
       local_state()->GetDictionary(prefs::kDisplayProperties);
   int64_t unified_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   EXPECT_FALSE(
       displays->GetDictionary(base::Int64ToString(unified_id), &new_value));
 
   ash::test::SetDisplayResolution(unified_id, gfx::Size(200, 100));
   EXPECT_EQ(
       "200x100",
       display::Screen::GetScreen()->GetPrimaryDisplay().size().ToString());
   EXPECT_FALSE(
       displays->GetDictionary(base::Int64ToString(unified_id), &new_value));
 
   // Mirror mode should remember if the default mode was unified.
   display_manager->SetMirrorMode(true);
-  ASSERT_TRUE(secondary_displays->GetDictionary(
-      ash::DisplayIdListToString(list), &new_value));
+  ASSERT_TRUE(secondary_displays->GetDictionary(ui::DisplayIdListToString(list),
+                                                &new_value));
   EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
   EXPECT_TRUE(stored_layout.default_unified);
   EXPECT_TRUE(stored_layout.mirrored);
 
   display_manager->SetMirrorMode(false);
-  ASSERT_TRUE(secondary_displays->GetDictionary(
-      ash::DisplayIdListToString(list), &new_value));
+  ASSERT_TRUE(secondary_displays->GetDictionary(ui::DisplayIdListToString(list),
+                                                &new_value));
   EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
   EXPECT_TRUE(stored_layout.default_unified);
   EXPECT_FALSE(stored_layout.mirrored);
 
   // Exit unified mode.
   display_manager->SetDefaultMultiDisplayModeForCurrentDisplays(
       ash::DisplayManager::EXTENDED);
-  ASSERT_TRUE(secondary_displays->GetDictionary(
-      ash::DisplayIdListToString(list), &new_value));
+  ASSERT_TRUE(secondary_displays->GetDictionary(ui::DisplayIdListToString(list),
+                                                &new_value));
   EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
   EXPECT_FALSE(stored_layout.default_unified);
   EXPECT_FALSE(stored_layout.mirrored);
 }
 
 TEST_F(DisplayPreferencesTest, RestoreUnifiedMode) {
   int64_t id1 = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   display::DisplayIdList list = ash::test::CreateDisplayIdList2(id1, id1 + 1);
   StoreDisplayBoolPropertyForList(list, "default_unified", true);
   StoreDisplayPropertyForList(
@@ skipping 45 matching lines @@
   display::DisplayLayoutBuilder builder(list[0]);
   builder.AddDisplayPlacement(list[1], list[0],
                               display::DisplayPlacement::RIGHT, 0);
   builder.AddDisplayPlacement(list[2], list[0],
                               display::DisplayPlacement::BOTTOM, 100);
   display_manager->SetLayoutForCurrentDisplays(builder.Build());
 
   const base::DictionaryValue* secondary_displays =
       local_state()->GetDictionary(prefs::kSecondaryDisplays);
   const base::DictionaryValue* new_value = nullptr;
-  EXPECT_TRUE(secondary_displays->GetDictionary(
-      ash::DisplayIdListToString(list), &new_value));
+  EXPECT_TRUE(secondary_displays->GetDictionary(ui::DisplayIdListToString(list),
+                                                &new_value));
 }
 
 TEST_F(DisplayPreferencesTest, RestoreThreeDisplays) {
   LoggedInAsUser();
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   int64_t id1 = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   display::DisplayIdList list =
       ash::test::CreateDisplayIdListN(3, id1, id1 + 1, id1 + 2);
 
@@ skipping 14 matching lines @@
 
   EXPECT_EQ(gfx::Rect(0, 0, 200, 200),
             display_manager->GetDisplayForId(list[0]).bounds());
   EXPECT_EQ(gfx::Rect(-200, 0, 200, 200),
             display_manager->GetDisplayForId(list[1]).bounds());
   EXPECT_EQ(gfx::Rect(-100, 200, 300, 300),
             display_manager->GetDisplayForId(list[2]).bounds());
 }
 
 }  // namespace chromeos