Convert //extensions/{common,shell} from scoped_ptr to std::unique_ptr

extensions/common/manifest_handlers/oauth2_manifest_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 <utility>
 
 #include "base/test/values_test_util.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/oauth2_manifest_handler.h"
 #include "extensions/common/manifest_test.h"
@@ skipping 24 matching lines @@
     AUTO_APPROVE_TRUE,
     AUTO_APPROVE_INVALID
   };
 
   enum ClientIdValue {
     CLIENT_ID_DEFAULT,
     CLIENT_ID_NOT_SET,
     CLIENT_ID_EMPTY
   };
 
-  scoped_ptr<base::DictionaryValue> CreateManifest(
+  std::unique_ptr<base::DictionaryValue> CreateManifest(
       AutoApproveValue auto_approve,
       bool extension_id_whitelisted,
       ClientIdValue client_id) {
-    scoped_ptr<base::DictionaryValue> manifest = base::DictionaryValue::From(
-        base::test::ParseJson("{ \n"
-                              "  \"name\": \"test\", \n"
-                              "  \"version\": \"0.1\", \n"
-                              "  \"manifest_version\": 2, \n"
-                              "  \"oauth2\": { \n"
-                              "    \"scopes\": [ \"scope1\" ], \n"
-                              "  }, \n"
-                              "} \n"));
+    std::unique_ptr<base::DictionaryValue> manifest =
+        base::DictionaryValue::From(
+            base::test::ParseJson("{ \n"
+                                  "  \"name\": \"test\", \n"
+                                  "  \"version\": \"0.1\", \n"
+                                  "  \"manifest_version\": 2, \n"
+                                  "  \"oauth2\": { \n"
+                                  "    \"scopes\": [ \"scope1\" ], \n"
+                                  "  }, \n"
+                                  "} \n"));
     EXPECT_TRUE(manifest);
     switch (auto_approve) {
       case AUTO_APPROVE_NOT_SET:
         break;
       case AUTO_APPROVE_FALSE:
         manifest->SetBoolean(keys::kOAuth2AutoApprove, false);
         break;
       case AUTO_APPROVE_TRUE:
         manifest->SetBoolean(keys::kOAuth2AutoApprove, true);
         break;
@@ skipping 81 matching lines @@
     EXPECT_EQ("'oauth2' is only allowed for extensions, legacy packaged apps, "
                   "and packaged apps, but this is a hosted app.",
               warning.message);
     EXPECT_EQ("", OAuth2Info::GetOAuth2Info(extension.get()).client_id);
     EXPECT_TRUE(OAuth2Info::GetOAuth2Info(extension.get()).scopes.empty());
     EXPECT_FALSE(OAuth2Info::GetOAuth2Info(extension.get()).auto_approve);
   }
 }
 
 TEST_F(OAuth2ManifestTest, AutoApproveNotSetExtensionNotOnWhitelist) {
-  scoped_ptr<base::DictionaryValue> ext_manifest =
+  std::unique_ptr<base::DictionaryValue> ext_manifest =
       CreateManifest(AUTO_APPROVE_NOT_SET, false, CLIENT_ID_DEFAULT);
   ManifestData manifest(std::move(ext_manifest), "test");
   scoped_refptr<extensions::Extension> extension =
       LoadAndExpectSuccess(manifest);
   EXPECT_TRUE(extension->install_warnings().empty());
   EXPECT_FALSE(OAuth2Info::GetOAuth2Info(extension.get()).auto_approve);
 }
 
 TEST_F(OAuth2ManifestTest, AutoApproveFalseExtensionNotOnWhitelist) {
-  scoped_ptr<base::DictionaryValue> ext_manifest =
+  std::unique_ptr<base::DictionaryValue> ext_manifest =
       CreateManifest(AUTO_APPROVE_FALSE, false, CLIENT_ID_DEFAULT);
   ManifestData manifest(std::move(ext_manifest), "test");
   scoped_refptr<extensions::Extension> extension =
       LoadAndExpectSuccess(manifest);
   EXPECT_EQ(1U, extension->install_warnings().size());
   const extensions::InstallWarning& warning =
       extension->install_warnings()[0];
   EXPECT_EQ(kAutoApproveNotAllowedWarning, warning.message);
   EXPECT_FALSE(OAuth2Info::GetOAuth2Info(extension.get()).auto_approve);
 }
 
 TEST_F(OAuth2ManifestTest, AutoApproveTrueExtensionNotOnWhitelist) {
-  scoped_ptr<base::DictionaryValue> ext_manifest =
+  std::unique_ptr<base::DictionaryValue> ext_manifest =
       CreateManifest(AUTO_APPROVE_TRUE, false, CLIENT_ID_DEFAULT);
   ManifestData manifest(std::move(ext_manifest), "test");
   scoped_refptr<extensions::Extension> extension =
       LoadAndExpectSuccess(manifest);
   EXPECT_EQ(1U, extension->install_warnings().size());
   const extensions::InstallWarning& warning =
       extension->install_warnings()[0];
   EXPECT_EQ(kAutoApproveNotAllowedWarning, warning.message);
   EXPECT_FALSE(OAuth2Info::GetOAuth2Info(extension.get()).auto_approve);
 }
 
 TEST_F(OAuth2ManifestTest, AutoApproveInvalidExtensionNotOnWhitelist) {
-  scoped_ptr<base::DictionaryValue> ext_manifest =
+  std::unique_ptr<base::DictionaryValue> ext_manifest =
       CreateManifest(AUTO_APPROVE_INVALID, false, CLIENT_ID_DEFAULT);
   ManifestData manifest(std::move(ext_manifest), "test");
   scoped_refptr<extensions::Extension> extension =
       LoadAndExpectSuccess(manifest);
   EXPECT_EQ(1U, extension->install_warnings().size());
   const extensions::InstallWarning& warning =
       extension->install_warnings()[0];
   EXPECT_EQ(kAutoApproveNotAllowedWarning, warning.message);
   EXPECT_FALSE(OAuth2Info::GetOAuth2Info(extension.get()).auto_approve);
 }
 
 TEST_F(OAuth2ManifestTest, AutoApproveNotSetExtensionOnWhitelist) {
-  scoped_ptr<base::DictionaryValue> ext_manifest =
+  std::unique_ptr<base::DictionaryValue> ext_manifest =
       CreateManifest(AUTO_APPROVE_NOT_SET, true, CLIENT_ID_DEFAULT);
   ManifestData manifest(std::move(ext_manifest), "test");
   scoped_refptr<extensions::Extension> extension =
       LoadAndExpectSuccess(manifest);
   EXPECT_TRUE(extension->install_warnings().empty());
   EXPECT_FALSE(OAuth2Info::GetOAuth2Info(extension.get()).auto_approve);
 }
 
 TEST_F(OAuth2ManifestTest, AutoApproveFalseExtensionOnWhitelist) {
-  scoped_ptr<base::DictionaryValue> ext_manifest =
+  std::unique_ptr<base::DictionaryValue> ext_manifest =
       CreateManifest(AUTO_APPROVE_FALSE, true, CLIENT_ID_DEFAULT);
   ManifestData manifest(std::move(ext_manifest), "test");
   scoped_refptr<extensions::Extension> extension =
       LoadAndExpectSuccess(manifest);
   EXPECT_TRUE(extension->install_warnings().empty());
   EXPECT_FALSE(OAuth2Info::GetOAuth2Info(extension.get()).auto_approve);
 }
 
 TEST_F(OAuth2ManifestTest, AutoApproveTrueExtensionOnWhitelist) {
-  scoped_ptr<base::DictionaryValue> ext_manifest =
+  std::unique_ptr<base::DictionaryValue> ext_manifest =
       CreateManifest(AUTO_APPROVE_TRUE, true, CLIENT_ID_DEFAULT);
   ManifestData manifest(std::move(ext_manifest), "test");
   scoped_refptr<extensions::Extension> extension =
       LoadAndExpectSuccess(manifest);
   EXPECT_TRUE(extension->install_warnings().empty());
   EXPECT_TRUE(OAuth2Info::GetOAuth2Info(extension.get()).auto_approve);
 }
 
 TEST_F(OAuth2ManifestTest, AutoApproveInvalidExtensionOnWhitelist) {
-  scoped_ptr<base::DictionaryValue> ext_manifest =
+  std::unique_ptr<base::DictionaryValue> ext_manifest =
       CreateManifest(AUTO_APPROVE_INVALID, true, CLIENT_ID_DEFAULT);
   ManifestData manifest(std::move(ext_manifest), "test");
   std::string error;
   scoped_refptr<extensions::Extension> extension =
       LoadExtension(manifest, &error);
   EXPECT_EQ(
       "Invalid value for 'oauth2.auto_approve'. Value must be true or false.",
       error);
 }
 
 TEST_F(OAuth2ManifestTest, InvalidClientId) {
   {
-    scoped_ptr<base::DictionaryValue> ext_manifest =
+    std::unique_ptr<base::DictionaryValue> ext_manifest =
         CreateManifest(AUTO_APPROVE_NOT_SET, false, CLIENT_ID_NOT_SET);
     ManifestData manifest(std::move(ext_manifest), "test");
     std::string error;
     LoadAndExpectError(manifest, errors::kInvalidOAuth2ClientId);
   }
 
   {
-    scoped_ptr<base::DictionaryValue> ext_manifest =
+    std::unique_ptr<base::DictionaryValue> ext_manifest =
         CreateManifest(AUTO_APPROVE_NOT_SET, false, CLIENT_ID_EMPTY);
     ManifestData manifest(std::move(ext_manifest), "test");
     std::string error;
     LoadAndExpectError(manifest, errors::kInvalidOAuth2ClientId);
   }
 }
 
 TEST_F(OAuth2ManifestTest, ComponentInvalidClientId) {
   // Component Apps without auto_approve must include a client ID.
   {
-    scoped_ptr<base::DictionaryValue> ext_manifest =
+    std::unique_ptr<base::DictionaryValue> ext_manifest =
         CreateManifest(AUTO_APPROVE_NOT_SET, false, CLIENT_ID_NOT_SET);
     ManifestData manifest(std::move(ext_manifest), "test");
     std::string error;
     LoadAndExpectError(manifest,
                        errors::kInvalidOAuth2ClientId,
                        extensions::Manifest::COMPONENT);
   }
 
   {
-    scoped_ptr<base::DictionaryValue> ext_manifest =
+    std::unique_ptr<base::DictionaryValue> ext_manifest =
         CreateManifest(AUTO_APPROVE_NOT_SET, false, CLIENT_ID_EMPTY);
     ManifestData manifest(std::move(ext_manifest), "test");
     std::string error;
     LoadAndExpectError(manifest,
                        errors::kInvalidOAuth2ClientId,
                        extensions::Manifest::COMPONENT);
   }
 }
 
 TEST_F(OAuth2ManifestTest, ComponentWithChromeClientId) {
   {
-    scoped_ptr<base::DictionaryValue> ext_manifest =
+    std::unique_ptr<base::DictionaryValue> ext_manifest =
         CreateManifest(AUTO_APPROVE_TRUE, true, CLIENT_ID_NOT_SET);
     ManifestData manifest(std::move(ext_manifest), "test");
     scoped_refptr<extensions::Extension> extension =
         LoadAndExpectSuccess(manifest, extensions::Manifest::COMPONENT);
     EXPECT_TRUE(OAuth2Info::GetOAuth2Info(extension.get()).client_id.empty());
   }
 
   {
-    scoped_ptr<base::DictionaryValue> ext_manifest =
+    std::unique_ptr<base::DictionaryValue> ext_manifest =
         CreateManifest(AUTO_APPROVE_TRUE, true, CLIENT_ID_EMPTY);
     ManifestData manifest(std::move(ext_manifest), "test");
     scoped_refptr<extensions::Extension> extension =
         LoadAndExpectSuccess(manifest, extensions::Manifest::COMPONENT);
     EXPECT_TRUE(OAuth2Info::GetOAuth2Info(extension.get()).client_id.empty());
   }
 }
 
 TEST_F(OAuth2ManifestTest, ComponentWithStandardClientId) {
-  scoped_ptr<base::DictionaryValue> ext_manifest =
+  std::unique_ptr<base::DictionaryValue> ext_manifest =
       CreateManifest(AUTO_APPROVE_TRUE, true, CLIENT_ID_DEFAULT);
   ManifestData manifest(std::move(ext_manifest), "test");
   scoped_refptr<extensions::Extension> extension =
       LoadAndExpectSuccess(manifest, extensions::Manifest::COMPONENT);
   EXPECT_EQ("client1", OAuth2Info::GetOAuth2Info(extension.get()).client_id);
 }
 
 }  // namespace extensions