Convert ScopedVector<DisplayPlacement> to std::vector<DisplayPlacement>

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>
@@ skipping 90 matching lines @@
 
   // 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) {
     std::string name = ash::DisplayIdListToString(list);
     DictionaryPrefUpdate update(&local_state_, prefs::kSecondaryDisplays);
     ash::DisplayLayout display_layout;
-    display_layout.placement_list.push_back(
-        new ash::DisplayPlacement(position, offset));
+    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());
@@ skipping 67 matching lines @@
     pref_data->SetBoolean("lock", rotation_lock);
     pref_data->SetInteger("orientation", static_cast<int>(rotation));
   }
 
   std::string GetRegisteredDisplayPlacementStr(const ash::DisplayIdList& list) {
     return ash::Shell::GetInstance()
         ->display_manager()
         ->layout_store()
         ->GetRegisteredDisplayLayout(list)
         .placement_list[0]
-        ->ToString();
+        .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_;
 
@@ skipping 26 matching lines @@
 
   shell->display_manager()->UpdateDisplays();
   // Check if the layout settings are notified to the system properly.
   // The new layout overrides old layout.
   // Inverted one of for specified pair (id1, id2).  Not used for the list
   // (id1, dummy_id) since dummy_id is not connected right now.
   EXPECT_EQ("id=2200000001, parent=2200000000, top, 20",
             shell->display_manager()
                 ->GetCurrentDisplayLayout()
                 .placement_list[0]
-                ->ToString());
+                .ToString());
   EXPECT_EQ("id=2200000001, parent=2200000000, top, 20",
             GetRegisteredDisplayPlacementStr(list));
   EXPECT_EQ("id=2200000002, parent=2200000000, left, 30",
             GetRegisteredDisplayPlacementStr(dummy_list));
 }
 
 TEST_F(DisplayPreferencesTest, BasicStores) {
   ash::WindowTreeHostManager* window_tree_host_manager =
       ash::Shell::GetInstance()->window_tree_host_manager();
   ash::DisplayManager* display_manager =
@@ skipping 13 matching lines @@
   // 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);
-  EXPECT_EQ(10, layout.placement_list[0]->offset);
+  EXPECT_EQ(ash::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);
   StoreDisplayLayoutPrefForTest(list, *dummy_layout);
 
   // Can't switch to a display that does not exist.
   window_tree_host_manager->SetPrimaryDisplayId(dummy_id);
@@ skipping 10 matching lines @@
   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;
   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);
+  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);
 
   const base::DictionaryValue* properties =
       local_state()->GetDictionary(prefs::kDisplayProperties);
   const base::DictionaryValue* property = nullptr;
   EXPECT_TRUE(properties->GetDictionary(base::Int64ToString(id1), &property));
   int ui_scale = 0;
@@ skipping 70 matching lines @@
   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 =
-      *stored_layout.placement_list[0];
+      stored_layout.placement_list[0];
   EXPECT_EQ(ash::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;
@@ skipping 156 matching lines @@
   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;
     EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
     ASSERT_EQ(1u, stored_layout.placement_list.size());
     const ash::DisplayPlacement& stored_placement =
-        *stored_layout.placement_list[0];
+        stored_layout.placement_list[0];
     EXPECT_EQ(ash::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));
     const base::DictionaryValue* new_value = nullptr;
     EXPECT_TRUE(displays->GetDictionary(key, &new_value));
     ash::DisplayLayout stored_layout;
     EXPECT_TRUE(ash::JsonToDisplayLayout(*new_value, &stored_layout));
     ASSERT_EQ(1u, stored_layout.placement_list.size());
     const ash::DisplayPlacement& stored_placement =
-        *stored_layout.placement_list[0];
+        stored_layout.placement_list[0];
     EXPECT_EQ(ash::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;
 
     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 =
-        *stored_layout.placement_list[0];
+        stored_layout.placement_list[0];
     EXPECT_EQ(ash::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 =
@@ skipping 49 matching lines @@
   // 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 =
-      *display_manager->GetCurrentDisplayLayout().placement_list[0];
+      display_manager->GetCurrentDisplayLayout().placement_list[0];
   EXPECT_EQ(ash::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 =
@@ skipping 346 matching lines @@
   // Sanity check. Restore to extended.
   StoreDisplayBoolPropertyForList(list, "default_unified", false);
   StoreDisplayBoolPropertyForList(list, "mirrored", false);
   LoadDisplayPreferences(false);
   UpdateDisplay("100x100,200x200");
   EXPECT_FALSE(display_manager->IsInMirrorMode());
   EXPECT_FALSE(display_manager->IsInUnifiedMode());
 }
 
 }  // namespace chromeos