Remove raw base::DictionaryValue::Set in //extensions

extensions/common/message_bundle_unittest.cc

Index: extensions/common/message_bundle_unittest.cc
diff --git a/extensions/common/message_bundle_unittest.cc b/extensions/common/message_bundle_unittest.cc
index bafbf9d63b81f1916f99d223c2d5782bc3507b96..dddcd76e474d3ea611be4e779b1e46979dc64441 100644
--- a/extensions/common/message_bundle_unittest.cc
+++ b/extensions/common/message_bundle_unittest.cc
@@ -8,10 +8,12 @@
 
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ -39,26 +41,25 @@ class MessageBundleTest : public testing::Test {
 
   // Helper method for dictionary building.
   void SetDictionary(const std::string& name,

[Devlin, 2017/06/02 15:38:49]

This method seems a little unnecessary now.  It'd be cleaner and more concise to
just inline dict->Set(name, std::move(value)) everywhere.

[jdoerrie, 2017/06/06 12:40:23]

Done.

-                     base::DictionaryValue* subtree,
+                     std::unique_ptr<base::DictionaryValue> subtree,
                      base::DictionaryValue* target) {
-    target->Set(name, static_cast<base::Value*>(subtree));
+    target->Set(name, std::move(subtree));
   }
 
   void CreateContentTree(const std::string& name,
                          const std::string& content,
                          base::DictionaryValue* dict) {
-    base::DictionaryValue* content_tree = new base::DictionaryValue;
+    auto content_tree = base::MakeUnique<base::DictionaryValue>();
     content_tree->SetString(MessageBundle::kContentKey, content);
-    SetDictionary(name, content_tree, dict);
+    SetDictionary(name, std::move(content_tree), dict);
   }
 
   void CreatePlaceholdersTree(base::DictionaryValue* dict) {
-    base::DictionaryValue* placeholders_tree = new base::DictionaryValue;
-    CreateContentTree("a", "A", placeholders_tree);
-    CreateContentTree("b", "B", placeholders_tree);
-    CreateContentTree("c", "C", placeholders_tree);
-    SetDictionary(MessageBundle::kPlaceholdersKey,
-                  placeholders_tree,
+    auto placeholders_tree = base::MakeUnique<base::DictionaryValue>();
+    CreateContentTree("a", "A", placeholders_tree.get());
+    CreateContentTree("b", "B", placeholders_tree.get());
+    CreateContentTree("c", "C", placeholders_tree.get());
+    SetDictionary(MessageBundle::kPlaceholdersKey, std::move(placeholders_tree),
                   dict);
   }
 
@@ -66,15 +67,15 @@ class MessageBundleTest : public testing::Test {
                          const std::string& message,
                          bool create_placeholder_subtree,
                          base::DictionaryValue* dict) {
-    base::DictionaryValue* message_tree = new base::DictionaryValue;
+    auto message_tree = base::MakeUnique<base::DictionaryValue>();
     if (create_placeholder_subtree)
-      CreatePlaceholdersTree(message_tree);
+      CreatePlaceholdersTree(message_tree.get());
     message_tree->SetString(MessageBundle::kMessageKey, message);
-    SetDictionary(name, message_tree, dict);
+    SetDictionary(name, std::move(message_tree), dict);
   }
 
   std::unique_ptr<base::DictionaryValue> CreateGoodDictionary() {
-    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+    auto dict = base::MakeUnique<base::DictionaryValue>();
     CreateMessageTree("n1", "message1 $a$ $b$", true, dict.get());
     CreateMessageTree("n2", "message2 $c$", true, dict.get());
     CreateMessageTree("n3", "message3", false, dict.get());
@@ -93,8 +94,8 @@ class MessageBundleTest : public testing::Test {
         dict->SetString("n4", "whatever");
         break;
       case EMPTY_NAME_TREE: {
-          base::DictionaryValue* empty_tree = new base::DictionaryValue;
-          SetDictionary("n4", empty_tree, dict.get());
+        auto empty_tree = base::MakeUnique<base::DictionaryValue>();
+        SetDictionary("n4", std::move(empty_tree), dict.get());
         }

[Devlin, 2017/06/02 15:38:48]

broken before, but can we fix this brace?

[jdoerrie, 2017/06/06 12:40:23]

Done, inlined empty_tree so braces are not necessary anymore.

         break;
       case MISSING_MESSAGE:
@@ -104,8 +105,8 @@ class MessageBundleTest : public testing::Test {
         dict->SetString("n1.placeholders", "whatever");
         break;
       case EMPTY_PLACEHOLDER_TREE: {
-          base::DictionaryValue* empty_tree = new base::DictionaryValue;
-          SetDictionary("n1.placeholders", empty_tree, dict.get());
+        auto empty_tree = base::MakeUnique<base::DictionaryValue>();
+        SetDictionary("n1.placeholders", std::move(empty_tree), dict.get());
         }
         break;
       case CONTENT_MISSING: