Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/system_display/system_display_apitest.cc

 // Copyright 2013 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 <stdint.h>
 
 #include <utility>
 
 #include "base/debug/leak_annotations.h"
 #include "base/macros.h"
@@ skipping 74 matching lines @@
     EXPECT_FALSE(set_info_value_);
     set_info_value_ = params.ToValue();
     set_info_display_id_ = display_id;
     return true;
   }
 
   void EnableUnifiedDesktop(bool enable) override {
     unified_desktop_enabled_ = enable;
   }
 
-  scoped_ptr<base::DictionaryValue> GetSetInfoValue() {
+  std::unique_ptr<base::DictionaryValue> GetSetInfoValue() {
     return std::move(set_info_value_);
   }
 
   std::string GetSetInfoDisplayId() const { return set_info_display_id_; }
 
   bool unified_desktop_enabled() const { return unified_desktop_enabled_; }
 
  private:
   // Update the content of the |unit| obtained for |display| using
   // platform specific method.
@@ skipping 11 matching lines @@
     unit->dpi_x = 96.0;
     unit->dpi_y = 96.0;
     if (id == 0) {
       unit->overscan.left = 20;
       unit->overscan.top = 40;
       unit->overscan.right = 60;
       unit->overscan.bottom = 80;
     }
   }
 
-  scoped_ptr<base::DictionaryValue> set_info_value_;
+  std::unique_ptr<base::DictionaryValue> set_info_value_;
   std::string set_info_display_id_;
   bool unified_desktop_enabled_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(MockDisplayInfoProvider);
 };
 
 class SystemDisplayApiTest : public ShellApiTest {
  public:
   SystemDisplayApiTest()
       : provider_(new MockDisplayInfoProvider), screen_(new MockScreen) {}
 
   ~SystemDisplayApiTest() override {}
 
   void SetUpOnMainThread() override {
     ShellApiTest::SetUpOnMainThread();
     ANNOTATE_LEAKING_OBJECT_PTR(gfx::Screen::GetScreen());
     gfx::Screen::SetScreenInstance(screen_.get());
     DisplayInfoProvider::InitializeForTesting(provider_.get());
   }
 
  protected:
-  scoped_ptr<MockDisplayInfoProvider> provider_;
-  scoped_ptr<gfx::Screen> screen_;
+  std::unique_ptr<MockDisplayInfoProvider> provider_;
+  std::unique_ptr<gfx::Screen> screen_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SystemDisplayApiTest);
 };
 
 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, GetDisplay) {
   ASSERT_TRUE(RunAppTest("system/display")) << message_;
 }
 
 #if !defined(OS_CHROMEOS)
 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, SetDisplay) {
   scoped_refptr<SystemDisplaySetDisplayPropertiesFunction> set_info_function(
       new SystemDisplaySetDisplayPropertiesFunction());
 
   set_info_function->set_has_callback(true);
 
   EXPECT_EQ(
       "Function available only on ChromeOS.",
       api_test_utils::RunFunctionAndReturnError(
           set_info_function.get(), "[\"display_id\", {}]", browser_context()));
 
-  scoped_ptr<base::DictionaryValue> set_info = provider_->GetSetInfoValue();
+  std::unique_ptr<base::DictionaryValue> set_info =
+      provider_->GetSetInfoValue();
   EXPECT_FALSE(set_info);
 }
 #endif  // !defined(OS_CHROMEOS)
 
 #if defined(OS_CHROMEOS)
 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, SetDisplayNotKioskEnabled) {
-  scoped_ptr<base::DictionaryValue> test_extension_value(
-      api_test_utils::ParseDictionary(
-          "{\n"
-          "  \"name\": \"Test\",\n"
-          "  \"version\": \"1.0\",\n"
-          "  \"app\": {\n"
-          "    \"background\": {\n"
-          "      \"scripts\": [\"background.js\"]\n"
-          "    }\n"
-          "  }\n"
-          "}"));
+  std::unique_ptr<base::DictionaryValue> test_extension_value(
+      api_test_utils::ParseDictionary("{\n"
+                                      "  \"name\": \"Test\",\n"
+                                      "  \"version\": \"1.0\",\n"
+                                      "  \"app\": {\n"
+                                      "    \"background\": {\n"
+                                      "      \"scripts\": [\"background.js\"]\n"
+                                      "    }\n"
+                                      "  }\n"
+                                      "}"));
   scoped_refptr<Extension> test_extension(
       api_test_utils::CreateExtension(test_extension_value.get()));
 
   scoped_refptr<SystemDisplaySetDisplayPropertiesFunction> set_info_function(
       new SystemDisplaySetDisplayPropertiesFunction());
 
   set_info_function->set_extension(test_extension.get());
   set_info_function->set_has_callback(true);
 
   EXPECT_EQ(
       "The extension needs to be kiosk enabled to use the function.",
       api_test_utils::RunFunctionAndReturnError(
           set_info_function.get(), "[\"display_id\", {}]", browser_context()));
 
-  scoped_ptr<base::DictionaryValue> set_info = provider_->GetSetInfoValue();
+  std::unique_ptr<base::DictionaryValue> set_info =
+      provider_->GetSetInfoValue();
   EXPECT_FALSE(set_info);
 }
 
 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, SetDisplayKioskEnabled) {
-  scoped_ptr<base::DictionaryValue> test_extension_value(
-      api_test_utils::ParseDictionary(
-          "{\n"
-          "  \"name\": \"Test\",\n"
-          "  \"version\": \"1.0\",\n"
-          "  \"app\": {\n"
-          "    \"background\": {\n"
-          "      \"scripts\": [\"background.js\"]\n"
-          "    }\n"
-          "  },\n"
-          "  \"kiosk_enabled\": true\n"
-          "}"));
+  std::unique_ptr<base::DictionaryValue> test_extension_value(
+      api_test_utils::ParseDictionary("{\n"
+                                      "  \"name\": \"Test\",\n"
+                                      "  \"version\": \"1.0\",\n"
+                                      "  \"app\": {\n"
+                                      "    \"background\": {\n"
+                                      "      \"scripts\": [\"background.js\"]\n"
+                                      "    }\n"
+                                      "  },\n"
+                                      "  \"kiosk_enabled\": true\n"
+                                      "}"));
   scoped_refptr<Extension> test_extension(
       api_test_utils::CreateExtension(test_extension_value.get()));
 
   scoped_refptr<SystemDisplaySetDisplayPropertiesFunction> set_info_function(
       new SystemDisplaySetDisplayPropertiesFunction());
 
   set_info_function->set_has_callback(true);
   set_info_function->set_extension(test_extension.get());
 
   ASSERT_TRUE(api_test_utils::RunFunction(
       set_info_function.get(),
       "[\"display_id\", {\n"
       "  \"isPrimary\": true,\n"
       "  \"mirroringSourceId\": \"mirroringId\",\n"
       "  \"boundsOriginX\": 100,\n"
       "  \"boundsOriginY\": 200,\n"
       "  \"rotation\": 90,\n"
       "  \"overscan\": {\"left\": 1, \"top\": 2, \"right\": 3, \"bottom\": 4}\n"
       "}]",
       browser_context()));
 
-  scoped_ptr<base::DictionaryValue> set_info = provider_->GetSetInfoValue();
+  std::unique_ptr<base::DictionaryValue> set_info =
+      provider_->GetSetInfoValue();
   ASSERT_TRUE(set_info);
   EXPECT_TRUE(api_test_utils::GetBoolean(set_info.get(), "isPrimary"));
   EXPECT_EQ("mirroringId",
             api_test_utils::GetString(set_info.get(), "mirroringSourceId"));
   EXPECT_EQ(100, api_test_utils::GetInteger(set_info.get(), "boundsOriginX"));
   EXPECT_EQ(200, api_test_utils::GetInteger(set_info.get(), "boundsOriginY"));
   EXPECT_EQ(90, api_test_utils::GetInteger(set_info.get(), "rotation"));
   base::DictionaryValue* overscan;
   ASSERT_TRUE(set_info->GetDictionary("overscan", &overscan));
   EXPECT_EQ(1, api_test_utils::GetInteger(overscan, "left"));
   EXPECT_EQ(2, api_test_utils::GetInteger(overscan, "top"));
   EXPECT_EQ(3, api_test_utils::GetInteger(overscan, "right"));
   EXPECT_EQ(4, api_test_utils::GetInteger(overscan, "bottom"));
 
   EXPECT_EQ("display_id", provider_->GetSetInfoDisplayId());
 }
 
 IN_PROC_BROWSER_TEST_F(SystemDisplayApiTest, EnableUnifiedDesktop) {
-  scoped_ptr<base::DictionaryValue> test_extension_value(
+  std::unique_ptr<base::DictionaryValue> test_extension_value(
       api_test_utils::ParseDictionary("{\n"
                                       "  \"name\": \"Test\",\n"
                                       "  \"version\": \"1.0\",\n"
                                       "  \"app\": {\n"
                                       "    \"background\": {\n"
                                       "      \"scripts\": [\"background.js\"]\n"
                                       "    }\n"
                                       "  }\n"
                                       "}"));
   scoped_refptr<Extension> test_extension(
@@ skipping 21 matching lines @@
     enable_unified_function->set_extension(test_extension.get());
     ASSERT_TRUE(api_test_utils::RunFunction(enable_unified_function.get(),
                                             "[false]", browser_context()));
     EXPECT_FALSE(provider_->unified_desktop_enabled());
   }
 }
 
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace extensions