Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

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/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"
@@ skipping 71 matching lines @@
                                      int64_t primary_id) {
     std::string name = ash::DisplayIdListToString(list);
     DictionaryPrefUpdate update(&local_state_, prefs::kSecondaryDisplays);
     ash::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());
+    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 ash::DisplayIdList& list,
                                    std::string key,
-                                   scoped_ptr<base::Value> value) {
+                                   std::unique_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(
+      std::unique_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,
                                        const std::string& key,
                                        bool value) {
     StoreDisplayPropertyForList(
-        list, key, make_scoped_ptr(new base::FundamentalValue(value)));
+        list, key, base::WrapUnique(new base::FundamentalValue(value)));
   }
 
   void StoreDisplayLayoutPrefForList(const ash::DisplayIdList& list,
                                      ash::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);
@@ skipping 34 matching lines @@
         .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_;
+  std::unique_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();
@@ skipping 57 matching lines @@
 
   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);
 
   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());
+  std::unique_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);
   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);
@@ skipping 714 matching lines @@
   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);
   StoreDisplayBoolPropertyForList(list, "default_unified", true);
   StoreDisplayPropertyForList(
       list, "primary-id",
-      make_scoped_ptr(new base::StringValue(base::Int64ToString(id1))));
+      base::WrapUnique(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();
   EXPECT_FALSE(display_manager->IsInUnifiedMode());
 
   // Restored to unified.
   display_manager->SetUnifiedDesktopEnabled(true);
@@ skipping 68 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