Move DisplayLayout and DisplayLayoutBuilder From ash To ui/display

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>
 #include <vector>
 
-#include "ash/display/display_layout_builder.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/display_util.h"
 #include "ash/display/json_converter.h"
 #include "ash/display/resolution_notification_controller.h"
 #include "ash/display/screen_orientation_controller_chromeos.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #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/gfx/geometry/vector3d_f.h"
 #include "ui/gfx/screen.h"
 #include "ui/message_center/message_center.h"
 
 using ash::ResolutionNotificationController;
 
 namespace chromeos {
 namespace {
 const char kPrimaryIdKey[] = "primary-id";
 const char kMirroredKey[] = "mirrored";
@@ skipping 47 matching lines @@
     EXPECT_CALL(*mock_user_manager_, IsUserLoggedIn())
         .WillRepeatedly(testing::Return(true));
     EXPECT_CALL(*mock_user_manager_, IsLoggedInAsUserWithGaiaAccount())
         .WillRepeatedly(testing::Return(false));
     EXPECT_CALL(*mock_user_manager_, IsLoggedInAsSupervisedUser())
         .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 ash::DisplayIdList& list,
-                                     ash::DisplayPlacement::Position position,
-                                     int offset,
-                                     int64_t primary_id) {
+  void StoreDisplayLayoutPrefForList(
+      const display::DisplayIdList& list,
+      display::DisplayPlacement::Position position,
+      int offset,
+      int64_t primary_id) {
     std::string name = ash::DisplayIdListToString(list);
     DictionaryPrefUpdate update(&local_state_, prefs::kSecondaryDisplays);
-    ash::DisplayLayout display_layout;
+    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();
     scoped_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 ash::DisplayIdList& list,
+  void StoreDisplayPropertyForList(const display::DisplayIdList& list,
                                    std::string key,
                                    scoped_ptr<base::Value> value) {
     std::string name = ash::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));
     } else {
       scoped_ptr<base::DictionaryValue> layout_value(
           new base::DictionaryValue());
       layout_value->SetBoolean(key, value != nullptr);
       pref_data->Set(name, layout_value.release());
     }
   }
 
-  void StoreDisplayBoolPropertyForList(const ash::DisplayIdList& list,
+  void StoreDisplayBoolPropertyForList(const display::DisplayIdList& list,
                                        const std::string& key,
                                        bool value) {
     StoreDisplayPropertyForList(
         list, key, make_scoped_ptr(new base::FundamentalValue(value)));
   }
 
-  void StoreDisplayLayoutPrefForList(const ash::DisplayIdList& list,
-                                     ash::DisplayPlacement::Position layout,
+  void StoreDisplayLayoutPrefForList(const display::DisplayIdList& list,
+                                     display::DisplayPlacement::Position layout,
                                      int offset) {
     StoreDisplayLayoutPrefForList(list, layout, offset, list[0]);
   }
 
   void StoreDisplayOverscan(int64_t id, const gfx::Insets& insets) {
     DictionaryPrefUpdate update(&local_state_, prefs::kDisplayProperties);
     const std::string name = base::Int64ToString(id);
 
     base::DictionaryValue* pref_data = update.Get();
     base::DictionaryValue* insets_value = new base::DictionaryValue();
@@ skipping 15 matching lines @@
   }
 
   void StoreDisplayRotationPrefsForTest(bool rotation_lock,
                                         gfx::Display::Rotation rotation) {
     DictionaryPrefUpdate update(local_state(), prefs::kDisplayRotationLock);
     base::DictionaryValue* pref_data = update.Get();
     pref_data->SetBoolean("lock", rotation_lock);
     pref_data->SetInteger("orientation", static_cast<int>(rotation));
   }
 
-  std::string GetRegisteredDisplayPlacementStr(const ash::DisplayIdList& list) {
+  std::string GetRegisteredDisplayPlacementStr(
+      const display::DisplayIdList& list) {
     return ash::Shell::GetInstance()
         ->display_manager()
         ->layout_store()
         ->GetRegisteredDisplayLayout(list)
         .placement_list[0]
         .ToString();
   }
 
   PrefService* local_state() { return &local_state_; }
 
  private:
   MockUserManager* mock_user_manager_;  // Not owned.
   ScopedUserManagerEnabler user_manager_enabler_;
   TestingPrefServiceSimple local_state_;
   scoped_ptr<DisplayConfigurationObserver> observer_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayPreferencesTest);
 };
 
 }  // namespace
 
 TEST_F(DisplayPreferencesTest, ListedLayoutOverrides) {
   UpdateDisplay("100x100,200x200");
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
 
-  ash::DisplayIdList list = display_manager->GetCurrentDisplayIdList();
-  ash::DisplayIdList dummy_list =
+  display::DisplayIdList list = display_manager->GetCurrentDisplayIdList();
+  display::DisplayIdList dummy_list =
       ash::test::CreateDisplayIdList2(list[0], list[1] + 1);
   ASSERT_NE(list[0], dummy_list[1]);
 
-  StoreDisplayLayoutPrefForList(list, ash::DisplayPlacement::TOP, 20);
-  StoreDisplayLayoutPrefForList(dummy_list, ash::DisplayPlacement::LEFT, 30);
+  StoreDisplayLayoutPrefForList(list, display::DisplayPlacement::TOP, 20);
+  StoreDisplayLayoutPrefForList(dummy_list, display::DisplayPlacement::LEFT,
+                                30);
   StoreDisplayPowerStateForTest(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON);
 
   ash::Shell* shell = ash::Shell::GetInstance();
 
   LoadDisplayPreferences(true);
   // DisplayPowerState should be ignored at boot.
   EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_ON,
             shell->display_configurator()->requested_power_state());
 
@@ skipping 31 matching lines @@
   profiles.push_back(ui::COLOR_PROFILE_MOVIE);
   profiles.push_back(ui::COLOR_PROFILE_READING);
   // Allows only |id1|.
   ash::test::DisplayManagerTestApi().SetAvailableColorProfiles(id1, profiles);
   display_manager->SetColorCalibrationProfile(id1, ui::COLOR_PROFILE_DYNAMIC);
   display_manager->SetColorCalibrationProfile(id2, ui::COLOR_PROFILE_DYNAMIC);
 
   LoggedInAsUser();
 
   display_manager->SetLayoutForCurrentDisplays(
-      ash::test::CreateDisplayLayout(ash::DisplayPlacement::TOP, 10));
-  const ash::DisplayLayout& layout = display_manager->GetCurrentDisplayLayout();
-  EXPECT_EQ(ash::DisplayPlacement::TOP, layout.placement_list[0].position);
+      ash::test::CreateDisplayLayout(display::DisplayPlacement::TOP, 10));
+  const display::DisplayLayout& layout =
+      display_manager->GetCurrentDisplayLayout();
+  EXPECT_EQ(display::DisplayPlacement::TOP, layout.placement_list[0].position);
   EXPECT_EQ(10, layout.placement_list[0].offset);
 
-  ash::DisplayLayoutBuilder dummy_layout_builder(id1);
-  dummy_layout_builder.SetSecondaryPlacement(dummy_id,
-                                             ash::DisplayPlacement::LEFT, 20);
-  scoped_ptr<ash::DisplayLayout> dummy_layout(dummy_layout_builder.Build());
-  ash::DisplayIdList list = ash::test::CreateDisplayIdList2(id1, dummy_id);
+  display::DisplayLayoutBuilder dummy_layout_builder(id1);
+  dummy_layout_builder.SetSecondaryPlacement(
+      dummy_id, display::DisplayPlacement::LEFT, 20);
+  scoped_ptr<display::DisplayLayout> dummy_layout(dummy_layout_builder.Build());
+  display::DisplayIdList list = ash::test::CreateDisplayIdList2(id1, dummy_id);
   StoreDisplayLayoutPrefForTest(list, *dummy_layout);
 
   // Can't switch to a display that does not exist.
   window_tree_host_manager->SetPrimaryDisplayId(dummy_id);
   EXPECT_NE(dummy_id, gfx::Screen::GetScreen()->GetPrimaryDisplay().id());
 
   window_tree_host_manager->SetOverscanInsets(id1, gfx::Insets(10, 11, 12, 13));
   display_manager->SetDisplayRotation(id1, gfx::Display::ROTATE_90,
                                       gfx::Display::ROTATION_SOURCE_USER);
   EXPECT_TRUE(ash::SetDisplayUIScale(id1, 1.25f));
   EXPECT_FALSE(ash::SetDisplayUIScale(id2, 1.25f));
 
   const base::DictionaryValue* displays =
       local_state()->GetDictionary(prefs::kSecondaryDisplays);
   const base::DictionaryValue* layout_value = nullptr;
   std::string key = base::Int64ToString(id1) + "," + base::Int64ToString(id2);
   std::string dummy_key =
       base::Int64ToString(id1) + "," + base::Int64ToString(dummy_id);
   EXPECT_TRUE(displays->GetDictionary(dummy_key, &layout_value));
 
-  ash::DisplayLayout stored_layout;
+  display::DisplayLayout stored_layout;
   EXPECT_TRUE(ash::JsonToDisplayLayout(*layout_value, &stored_layout));
   ASSERT_EQ(1u, stored_layout.placement_list.size());
 
   EXPECT_EQ(dummy_layout->placement_list[0].position,
             stored_layout.placement_list[0].position);
   EXPECT_EQ(dummy_layout->placement_list[0].offset,
             stored_layout.placement_list[0].offset);
 
   bool mirrored = true;
   EXPECT_TRUE(layout_value->GetBoolean(kMirroredKey, &mirrored));
@@ skipping 76 matching lines @@
       "device-scale-factor", &device_scale_factor));
   EXPECT_EQ(300, width);
   EXPECT_EQ(200, height);
   EXPECT_EQ(1250, device_scale_factor);
 
   // The layout is swapped.
   EXPECT_TRUE(displays->GetDictionary(key, &layout_value));
 
   EXPECT_TRUE(ash::JsonToDisplayLayout(*layout_value, &stored_layout));
   ASSERT_EQ(1u, stored_layout.placement_list.size());
-  const ash::DisplayPlacement& stored_placement =
+  const display::DisplayPlacement& stored_placement =
       stored_layout.placement_list[0];
-  EXPECT_EQ(ash::DisplayPlacement::BOTTOM, stored_placement.position);
+  EXPECT_EQ(display::DisplayPlacement::BOTTOM, stored_placement.position);
   EXPECT_EQ(-10, stored_placement.offset);
   EXPECT_EQ(id1, stored_placement.display_id);
   EXPECT_EQ(id2, stored_placement.parent_display_id);
   EXPECT_EQ(id2, stored_layout.primary_id);
 
   if (true)
     return;
 
   mirrored = true;
   EXPECT_TRUE(layout_value->GetBoolean(kMirroredKey, &mirrored));
   EXPECT_FALSE(mirrored);
   std::string primary_id_str;
   EXPECT_TRUE(layout_value->GetString(kPrimaryIdKey, &primary_id_str));
   EXPECT_EQ(base::Int64ToString(id2), primary_id_str);
 
   display_manager->SetLayoutForCurrentDisplays(
-      ash::test::CreateDisplayLayout(ash::DisplayPlacement::BOTTOM, 20));
+      ash::test::CreateDisplayLayout(display::DisplayPlacement::BOTTOM, 20));
 
   UpdateDisplay("1+0-200x200*2,1+0-200x200");
   // Mirrored.
   int offset = 0;
   std::string position;
   EXPECT_TRUE(displays->GetDictionary(key, &layout_value));
   EXPECT_TRUE(layout_value->GetString(kPositionKey, &position));
   EXPECT_EQ("bottom", position);
   EXPECT_TRUE(layout_value->GetInteger(kOffsetKey, &offset));
   EXPECT_EQ(20, offset);
@@ skipping 134 matching lines @@
   ash::test::SwapPrimaryDisplay();
   ASSERT_EQ(id1, ash::ScreenUtil::GetSecondaryDisplay().id());
 
   std::string key = base::Int64ToString(id1) + "," + base::Int64ToString(id2);
   const base::DictionaryValue* displays =
       local_state()->GetDictionary(prefs::kSecondaryDisplays);
   // Initial saved value is swapped.
   {
     const base::DictionaryValue* new_value = nullptr;
     EXPECT_TRUE(displays->GetDictionary(key, &new_value));
-    ash::DisplayLayout stored_layout;
+    display::DisplayLayout stored_layout;
     EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
     ASSERT_EQ(1u, stored_layout.placement_list.size());
-    const ash::DisplayPlacement& stored_placement =
+    const display::DisplayPlacement& stored_placement =
         stored_layout.placement_list[0];
-    EXPECT_EQ(ash::DisplayPlacement::LEFT, stored_placement.position);
+    EXPECT_EQ(display::DisplayPlacement::LEFT, stored_placement.position);
     EXPECT_EQ(0, stored_placement.offset);
     EXPECT_EQ(id1, stored_placement.display_id);
     EXPECT_EQ(id2, stored_placement.parent_display_id);
     EXPECT_EQ(id2, stored_layout.primary_id);
   }
 
   // Updating layout with primary swapped should save the correct value.
   {
     ash::Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays(
-        ash::test::CreateDisplayLayout(ash::DisplayPlacement::TOP, 10));
+        ash::test::CreateDisplayLayout(display::DisplayPlacement::TOP, 10));
     const base::DictionaryValue* new_value = nullptr;
     EXPECT_TRUE(displays->GetDictionary(key, &new_value));
-    ash::DisplayLayout stored_layout;
+    display::DisplayLayout stored_layout;
     EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
     ASSERT_EQ(1u, stored_layout.placement_list.size());
-    const ash::DisplayPlacement& stored_placement =
+    const display::DisplayPlacement& stored_placement =
         stored_layout.placement_list[0];
-    EXPECT_EQ(ash::DisplayPlacement::TOP, stored_placement.position);
+    EXPECT_EQ(display::DisplayPlacement::TOP, stored_placement.position);
     EXPECT_EQ(10, stored_placement.offset);
     EXPECT_EQ(id1, stored_placement.display_id);
     EXPECT_EQ(id2, stored_placement.parent_display_id);
     EXPECT_EQ(id2, stored_layout.primary_id);
   }
 
   // Swapping primary will save the swapped value.
   {
     ash::test::SwapPrimaryDisplay();
     const base::DictionaryValue* new_value = nullptr;
     EXPECT_TRUE(displays->GetDictionary(key, &new_value));
-    ash::DisplayLayout stored_layout;
+    display::DisplayLayout stored_layout;
 
     EXPECT_TRUE(displays->GetDictionary(key, &new_value));
     EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
     ASSERT_EQ(1u, stored_layout.placement_list.size());
-    const ash::DisplayPlacement& stored_placement =
+    const display::DisplayPlacement& stored_placement =
         stored_layout.placement_list[0];
-    EXPECT_EQ(ash::DisplayPlacement::BOTTOM, stored_placement.position);
+    EXPECT_EQ(display::DisplayPlacement::BOTTOM, stored_placement.position);
     EXPECT_EQ(-10, stored_placement.offset);
     EXPECT_EQ(id2, stored_placement.display_id);
     EXPECT_EQ(id1, stored_placement.parent_display_id);
     EXPECT_EQ(id1, stored_layout.primary_id);
   }
 }
 
 TEST_F(DisplayPreferencesTest, RestoreColorProfiles) {
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
@@ skipping 29 matching lines @@
 
   UpdateDisplay("200x200*2,200x200");
 
   LoggedInAsGuest();
   int64_t id1 = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
   ash::test::ScopedSetInternalDisplayId set_internal(id1);
   int64_t id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   display_manager->SetLayoutForCurrentDisplays(
-      ash::test::CreateDisplayLayout(ash::DisplayPlacement::TOP, 10));
+      ash::test::CreateDisplayLayout(display::DisplayPlacement::TOP, 10));
   ash::SetDisplayUIScale(id1, 1.25f);
   window_tree_host_manager->SetPrimaryDisplayId(id2);
   int64_t new_primary = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
   window_tree_host_manager->SetOverscanInsets(new_primary,
                                               gfx::Insets(10, 11, 12, 13));
   display_manager->SetDisplayRotation(new_primary, gfx::Display::ROTATE_90,
                                       gfx::Display::ROTATION_SOURCE_USER);
 
   // Does not store the preferences locally.
   EXPECT_FALSE(local_state()->FindPreference(
       prefs::kSecondaryDisplays)->HasUserSetting());
   EXPECT_FALSE(local_state()->FindPreference(
       prefs::kDisplayProperties)->HasUserSetting());
 
   // Settings are still notified to the system.
   gfx::Screen* screen = gfx::Screen::GetScreen();
   EXPECT_EQ(id2, screen->GetPrimaryDisplay().id());
-  const ash::DisplayPlacement& placement =
+  const display::DisplayPlacement& placement =
       display_manager->GetCurrentDisplayLayout().placement_list[0];
-  EXPECT_EQ(ash::DisplayPlacement::BOTTOM, placement.position);
+  EXPECT_EQ(display::DisplayPlacement::BOTTOM, placement.position);
   EXPECT_EQ(-10, placement.offset);
   const gfx::Display& primary_display = screen->GetPrimaryDisplay();
   EXPECT_EQ("178x176", primary_display.bounds().size().ToString());
   EXPECT_EQ(gfx::Display::ROTATE_90, primary_display.rotation());
 
   const ash::DisplayInfo& info1 = display_manager->GetDisplayInfo(id1);
   EXPECT_EQ(1.25f, info1.configured_ui_scale());
 
   const ash::DisplayInfo& info_primary =
       display_manager->GetDisplayInfo(new_primary);
@@ skipping 251 matching lines @@
 }
 
 TEST_F(DisplayPreferencesTest, SaveUnifiedMode) {
 
   LoggedInAsUser();
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   display_manager->SetUnifiedDesktopEnabled(true);
 
   UpdateDisplay("200x200,100x100");
-  ash::DisplayIdList list = display_manager->GetCurrentDisplayIdList();
+  display::DisplayIdList list = display_manager->GetCurrentDisplayIdList();
   EXPECT_EQ("400x200",
             gfx::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));
 
-  ash::DisplayLayout stored_layout;
+  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 = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
   EXPECT_FALSE(
       displays->GetDictionary(base::Int64ToString(unified_id), &new_value));
 
@@ skipping 23 matching lines @@
       ash::DisplayManager::EXTENDED);
   ASSERT_TRUE(secondary_displays->GetDictionary(
       ash::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 = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
-  ash::DisplayIdList list = ash::test::CreateDisplayIdList2(id1, id1 + 1);
+  display::DisplayIdList list = ash::test::CreateDisplayIdList2(id1, id1 + 1);
   StoreDisplayBoolPropertyForList(list, "default_unified", true);
   StoreDisplayPropertyForList(
       list, "primary-id",
       make_scoped_ptr(new base::StringValue(base::Int64ToString(id1))));
   LoadDisplayPreferences(false);
 
   // Should not restore to unified unless unified desktop is enabled.
   UpdateDisplay("100x100,200x200");
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
@@ skipping 24 matching lines @@
   EXPECT_FALSE(display_manager->IsInMirrorMode());
   EXPECT_FALSE(display_manager->IsInUnifiedMode());
 }
 
 TEST_F(DisplayPreferencesTest, SaveThreeDisplays) {
   LoggedInAsUser();
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   UpdateDisplay("200x200,200x200,300x300");
 
-  ash::DisplayIdList list = display_manager->GetCurrentDisplayIdList();
+  display::DisplayIdList list = display_manager->GetCurrentDisplayIdList();
   ASSERT_EQ(3u, list.size());
 
-  ash::DisplayLayoutBuilder builder(list[0]);
-  builder.AddDisplayPlacement(list[1], list[0], ash::DisplayPlacement::RIGHT,
-                              0);
-  builder.AddDisplayPlacement(list[2], list[0], ash::DisplayPlacement::BOTTOM,
-                              100);
+  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));
 }
 
 TEST_F(DisplayPreferencesTest, RestoreThreeDisplays) {
   LoggedInAsUser();
   ash::DisplayManager* display_manager =
       ash::Shell::GetInstance()->display_manager();
   int64_t id1 = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
-  ash::DisplayIdList list =
+  display::DisplayIdList list =
       ash::test::CreateDisplayIdListN(3, id1, id1 + 1, id1 + 2);
 
-  ash::DisplayLayoutBuilder builder(list[0]);
-  builder.AddDisplayPlacement(list[1], list[0], ash::DisplayPlacement::LEFT, 0);
-  builder.AddDisplayPlacement(list[2], list[1], ash::DisplayPlacement::BOTTOM,
-                              100);
+  display::DisplayLayoutBuilder builder(list[0]);
+  builder.AddDisplayPlacement(list[1], list[0], display::DisplayPlacement::LEFT,
+                              0);
+  builder.AddDisplayPlacement(list[2], list[1],
+                              display::DisplayPlacement::BOTTOM, 100);
   StoreDisplayLayoutPrefForTest(list, *builder.Build());
   LoadDisplayPreferences(false);
 
   UpdateDisplay("200x200,200x200,300x300");
-  ash::DisplayIdList new_list = display_manager->GetCurrentDisplayIdList();
+  display::DisplayIdList new_list = display_manager->GetCurrentDisplayIdList();
   ASSERT_EQ(3u, list.size());
   ASSERT_EQ(list[0], new_list[0]);
   ASSERT_EQ(list[1], new_list[1]);
   ASSERT_EQ(list[2], new_list[2]);
 
   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