Remove raw DictionaryValue::Set in //chrome

chrome/common/extensions/api/common_extension_api_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 "extensions/common/extension_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_features_unittest.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/features/feature_session_type.h"
 #include "extensions/common/features/simple_feature.h"
@@ skipping 397 matching lines @@
   base::DictionaryValue manifest;
   manifest.SetString("name", "extension");
   manifest.SetString("version", "1.0");
   manifest.SetInteger("manifest_version", 2);
   {
     std::unique_ptr<base::ListValue> permissions_list(new base::ListValue());
     for (std::set<std::string>::const_iterator i = permissions.begin();
         i != permissions.end(); ++i) {
       permissions_list->AppendString(*i);
     }
-    manifest.Set("permissions", permissions_list.release());
+    manifest.Set("permissions", std::move(permissions_list));
   }
 
   std::string error;
   scoped_refptr<Extension> extension(Extension::Create(
       base::FilePath(), Manifest::UNPACKED,
       manifest, Extension::NO_FLAGS, &error));
   CHECK(extension.get());
   CHECK(error.empty());
 
   return extension;
@@ skipping 60 matching lines @@
       CheckAliasStatus::NOT_ALLOWED));
   EXPECT_FALSE(extension_api->IsAnyFeatureAvailableToContext(
       *api_features.GetFeature("history"), nullptr,
       Feature::CONTENT_SCRIPT_CONTEXT, GURL(), CheckAliasStatus::NOT_ALLOWED));
 }
 
 scoped_refptr<Extension> CreateHostedApp() {
   base::DictionaryValue values;
   values.SetString(manifest_keys::kName, "test");
   values.SetString(manifest_keys::kVersion, "0.1");
-  values.Set(manifest_keys::kWebURLs, new base::ListValue());
+  values.Set(manifest_keys::kWebURLs, base::MakeUnique<base::ListValue>());
   values.SetString(manifest_keys::kLaunchWebURL,
                    "http://www.example.com");
   std::string error;
   scoped_refptr<Extension> extension(Extension::Create(
       base::FilePath(), Manifest::INTERNAL, values, Extension::NO_FLAGS,
       &error));
   CHECK(extension.get());
   return extension;
 }
 
 scoped_refptr<Extension> CreatePackagedAppWithPermissions(
     const std::set<std::string>& permissions) {
   base::DictionaryValue values;
   values.SetString(manifest_keys::kName, "test");
   values.SetString(manifest_keys::kVersion, "0.1");
   values.SetString(manifest_keys::kPlatformAppBackground,
       "http://www.example.com");
 
-  base::DictionaryValue* app = new base::DictionaryValue();
-  base::DictionaryValue* background = new base::DictionaryValue();
-  base::ListValue* scripts = new base::ListValue();
+  auto app = base::MakeUnique<base::DictionaryValue>();
+  auto background = base::MakeUnique<base::DictionaryValue>();
+  auto scripts = base::MakeUnique<base::ListValue>();
   scripts->AppendString("test.js");
-  background->Set("scripts", scripts);
-  app->Set("background", background);
-  values.Set(manifest_keys::kApp, app);
+  background->Set("scripts", std::move(scripts));
+  app->Set("background", std::move(background));
+  values.Set(manifest_keys::kApp, std::move(app));
   {
-    std::unique_ptr<base::ListValue> permissions_list(new base::ListValue());
+    auto permissions_list = base::MakeUnique<base::ListValue>();
     for (std::set<std::string>::const_iterator i = permissions.begin();
         i != permissions.end(); ++i) {
       permissions_list->AppendString(*i);
     }
-    values.Set("permissions", permissions_list.release());
+    values.Set("permissions", std::move(permissions_list));
   }
 
   std::string error;
   scoped_refptr<Extension> extension(Extension::Create(
       base::FilePath(), Manifest::INTERNAL, values, Extension::NO_FLAGS,
       &error));
   CHECK(extension.get()) << error;
   return extension;
 }
 
@@ skipping 388 matching lines @@
                                 CheckAliasStatus::NOT_ALLOWED)
                   .is_available());
   EXPECT_FALSE(extension_api
                    ->IsAvailable("pageAction", extension.get(),
                                  Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
                                  CheckAliasStatus::NOT_ALLOWED)
                    .is_available());
 }
 
 }  // namespace extensions