Move display preference code from ash/display/ to ui/display/manager/.

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/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm_shell.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/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.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/display_layout_builder.h"
 #include "ui/display/manager/chromeos/display_configurator.h"
 #include "ui/display/manager/display_layout_store.h"
 #include "ui/display/manager/display_manager.h"
 #include "ui/display/manager/display_manager_utilities.h"
+#include "ui/display/manager/json_converter.h"
 #include "ui/display/screen.h"
 #include "ui/display/test/display_manager_test_api.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";
@@ skipping 71 matching lines @@
 
     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()))
+    if (display::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 = display::DisplayIdListToString(list);
 
     DictionaryPrefUpdate update(&local_state_, prefs::kSecondaryDisplays);
     base::DictionaryValue* pref_data = update.Get();
@@ skipping 182 matching lines @@
 
   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));
 
   display::DisplayLayout stored_layout;
-  EXPECT_TRUE(ash::JsonToDisplayLayout(*layout_value, &stored_layout));
+  EXPECT_TRUE(display::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));
   EXPECT_FALSE(mirrored);
@@ skipping 99 matching lines @@
   EXPECT_TRUE(property->GetInteger("height", &height));
   EXPECT_TRUE(property->GetInteger(
       "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));
+  EXPECT_TRUE(display::JsonToDisplayLayout(*layout_value, &stored_layout));
   ASSERT_EQ(1u, stored_layout.placement_list.size());
   const display::DisplayPlacement& stored_placement =
       stored_layout.placement_list[0];
   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)
@@ skipping 160 matching lines @@
   ASSERT_EQ(id1, display_manager()->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));
     display::DisplayLayout stored_layout;
-    EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
+    EXPECT_TRUE(display::JsonToDisplayLayout(*new_value, &stored_layout));
     ASSERT_EQ(1u, stored_layout.placement_list.size());
     const display::DisplayPlacement& stored_placement =
         stored_layout.placement_list[0];
     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.
   {
     display_manager()->SetLayoutForCurrentDisplays(
         display::test::CreateDisplayLayout(display_manager(),
                                            display::DisplayPlacement::TOP, 10));
     const base::DictionaryValue* new_value = nullptr;
     EXPECT_TRUE(displays->GetDictionary(key, &new_value));
     display::DisplayLayout stored_layout;
-    EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
+    EXPECT_TRUE(display::JsonToDisplayLayout(*new_value, &stored_layout));
     ASSERT_EQ(1u, stored_layout.placement_list.size());
     const display::DisplayPlacement& stored_placement =
         stored_layout.placement_list[0];
     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.
   {
     SwapPrimaryDisplay();
     const base::DictionaryValue* new_value = nullptr;
     EXPECT_TRUE(displays->GetDictionary(key, &new_value));
     display::DisplayLayout stored_layout;
 
     EXPECT_TRUE(displays->GetDictionary(key, &new_value));
-    EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
+    EXPECT_TRUE(display::JsonToDisplayLayout(*new_value, &stored_layout));
     ASSERT_EQ(1u, stored_layout.placement_list.size());
     const display::DisplayPlacement& stored_placement =
         stored_layout.placement_list[0];
     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);
   }
 }
@@ skipping 338 matching lines @@
       "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(
       display::DisplayIdListToString(list), &new_value));
 
   display::DisplayLayout stored_layout;
-  EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
+  EXPECT_TRUE(display::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));
 
   display::test::SetDisplayResolution(display_manager(), 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(
       display::DisplayIdListToString(list), &new_value));
-  EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
+  EXPECT_TRUE(display::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(
       display::DisplayIdListToString(list), &new_value));
-  EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
+  EXPECT_TRUE(display::JsonToDisplayLayout(*new_value, &stored_layout));
   EXPECT_TRUE(stored_layout.default_unified);
   EXPECT_FALSE(stored_layout.mirrored);
 
   // Exit unified mode.
   display_manager()->SetDefaultMultiDisplayModeForCurrentDisplays(
       display::DisplayManager::EXTENDED);
   ASSERT_TRUE(secondary_displays->GetDictionary(
       display::DisplayIdListToString(list), &new_value));
-  EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
+  EXPECT_TRUE(display::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 =
       display::test::CreateDisplayIdList2(id1, id1 + 1);
   StoreDisplayBoolPropertyForList(list, "default_unified", true);
   StoreDisplayPropertyForList(
@@ skipping 76 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