Some easy linked_ptr removal from extensions/common/

extensions/common/message_bundle_unittest.cc

 // Copyright 2014 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/message_bundle.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/macros.h"
-#include "base/memory/linked_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension_l10n_util.h"
 #include "extensions/common/manifest_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
@@ skipping 41 matching lines @@
                          const std::string& message,
                          bool create_placeholder_subtree,
                          base::DictionaryValue* dict) {
     base::DictionaryValue* message_tree = new base::DictionaryValue;
     if (create_placeholder_subtree)
       CreatePlaceholdersTree(message_tree);
     message_tree->SetString(MessageBundle::kMessageKey, message);
     SetDictionary(name, message_tree, dict);
   }
 
-  // Caller owns the memory.
-  base::DictionaryValue* CreateGoodDictionary() {
-    base::DictionaryValue* dict = new base::DictionaryValue;
-    CreateMessageTree("n1", "message1 $a$ $b$", true, dict);
-    CreateMessageTree("n2", "message2 $c$", true, dict);
-    CreateMessageTree("n3", "message3", false, dict);
+  std::unique_ptr<base::DictionaryValue> CreateGoodDictionary() {
+    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+    CreateMessageTree("n1", "message1 $a$ $b$", true, dict.get());
+    CreateMessageTree("n2", "message2 $c$", true, dict.get());
+    CreateMessageTree("n3", "message3", false, dict.get());
     return dict;
   }
 
-  // Caller owns the memory.
-  base::DictionaryValue* CreateBadDictionary(enum BadDictionary what_is_bad) {
-    base::DictionaryValue* dict = CreateGoodDictionary();
+  std::unique_ptr<base::DictionaryValue> CreateBadDictionary(
+      enum BadDictionary what_is_bad) {
+    std::unique_ptr<base::DictionaryValue> dict = CreateGoodDictionary();
     // Now remove/break things.
     switch (what_is_bad) {
       case INVALID_NAME:
-        CreateMessageTree("n 5", "nevermind", false, dict);
+        CreateMessageTree("n 5", "nevermind", false, dict.get());
         break;
       case NAME_NOT_A_TREE:
         dict->SetString("n4", "whatever");
         break;
       case EMPTY_NAME_TREE: {
           base::DictionaryValue* empty_tree = new base::DictionaryValue;
-          SetDictionary("n4", empty_tree, dict);
+          SetDictionary("n4", empty_tree, dict.get());
         }
         break;
       case MISSING_MESSAGE:
         dict->Remove("n1.message", NULL);
         break;
       case PLACEHOLDER_NOT_A_TREE:
         dict->SetString("n1.placeholders", "whatever");
         break;
       case EMPTY_PLACEHOLDER_TREE: {
           base::DictionaryValue* empty_tree = new base::DictionaryValue;
-          SetDictionary("n1.placeholders", empty_tree, dict);
+          SetDictionary("n1.placeholders", empty_tree, dict.get());
         }
         break;
       case CONTENT_MISSING:
          dict->Remove("n1.placeholders.a.content", NULL);
         break;
       case MESSAGE_PLACEHOLDER_DOESNT_MATCH:
         base::DictionaryValue* value;
         dict->Remove("n1.placeholders.a", NULL);
         dict->GetDictionary("n1.placeholders", &value);
         CreateContentTree("x", "X", value);
@@ skipping 33 matching lines @@
     handler_.reset(MessageBundle::Create(catalogs_, &error));
 
     return error;
   }
 
   void ClearDictionary() {
     handler_->dictionary_.clear();
   }
 
   std::unique_ptr<MessageBundle> handler_;
-  std::vector<linked_ptr<base::DictionaryValue> > catalogs_;
+  std::vector<std::unique_ptr<base::DictionaryValue>> catalogs_;
 };
 
 TEST_F(MessageBundleTest, ReservedMessagesCount) {
   ASSERT_EQ(5U, ReservedMessagesCount());
 }
 
 TEST_F(MessageBundleTest, InitEmptyDictionaries) {
   CreateMessageBundle();
   EXPECT_TRUE(handler_.get() != NULL);
   EXPECT_EQ(0U + ReservedMessagesCount(), handler_->size());
   CheckReservedMessages(handler_.get());
 }
 
 TEST_F(MessageBundleTest, InitGoodDefaultDict) {
-  catalogs_.push_back(
-      linked_ptr<base::DictionaryValue>(CreateGoodDictionary()));
+  catalogs_.push_back(CreateGoodDictionary());
   CreateMessageBundle();
 
   EXPECT_TRUE(handler_.get() != NULL);
   EXPECT_EQ(3U + ReservedMessagesCount(), handler_->size());
 
   EXPECT_EQ("message1 A B", handler_->GetL10nMessage("n1"));
   EXPECT_EQ("message2 C", handler_->GetL10nMessage("n2"));
   EXPECT_EQ("message3", handler_->GetL10nMessage("n3"));
   CheckReservedMessages(handler_.get());
 }
 
 TEST_F(MessageBundleTest, InitAppDictConsultedFirst) {
-  catalogs_.push_back(
-      linked_ptr<base::DictionaryValue>(CreateGoodDictionary()));
-  catalogs_.push_back(
-      linked_ptr<base::DictionaryValue>(CreateGoodDictionary()));
+  catalogs_.push_back(CreateGoodDictionary());
+  catalogs_.push_back(CreateGoodDictionary());
 
   base::DictionaryValue* app_dict = catalogs_[0].get();
   // Flip placeholders in message of n1 tree.
   app_dict->SetString("n1.message", "message1 $b$ $a$");
   // Remove one message from app dict.
   app_dict->Remove("n2", NULL);
   // Replace n3 with N3.
   app_dict->Remove("n3", NULL);
   CreateMessageTree("N3", "message3_app_dict", false, app_dict);
 
   CreateMessageBundle();
 
   EXPECT_TRUE(handler_.get() != NULL);
   EXPECT_EQ(3U + ReservedMessagesCount(), handler_->size());
 
   EXPECT_EQ("message1 B A", handler_->GetL10nMessage("n1"));
   EXPECT_EQ("message2 C", handler_->GetL10nMessage("n2"));
   EXPECT_EQ("message3_app_dict", handler_->GetL10nMessage("n3"));
   CheckReservedMessages(handler_.get());
 }
 
 TEST_F(MessageBundleTest, InitBadAppDict) {
-  catalogs_.push_back(
-      linked_ptr<base::DictionaryValue>(CreateBadDictionary(INVALID_NAME)));
-  catalogs_.push_back(
-      linked_ptr<base::DictionaryValue>(CreateGoodDictionary()));
+  catalogs_.push_back(CreateBadDictionary(INVALID_NAME));
+  catalogs_.push_back(CreateGoodDictionary());
 
   std::string error = CreateMessageBundle();
 
   EXPECT_TRUE(handler_.get() == NULL);
   EXPECT_EQ("Name of a key \"n 5\" is invalid. Only ASCII [a-z], "
             "[A-Z], [0-9] and \"_\" are allowed.", error);
 
-  catalogs_[0].reset(CreateBadDictionary(NAME_NOT_A_TREE));
+  catalogs_[0] = CreateBadDictionary(NAME_NOT_A_TREE);
   handler_.reset(MessageBundle::Create(catalogs_, &error));
   EXPECT_TRUE(handler_.get() == NULL);
   EXPECT_EQ("Not a valid tree for key n4.", error);
 
-  catalogs_[0].reset(CreateBadDictionary(EMPTY_NAME_TREE));
+  catalogs_[0] = CreateBadDictionary(EMPTY_NAME_TREE);
   handler_.reset(MessageBundle::Create(catalogs_, &error));
   EXPECT_TRUE(handler_.get() == NULL);
   EXPECT_EQ("There is no \"message\" element for key n4.", error);
 
-  catalogs_[0].reset(CreateBadDictionary(MISSING_MESSAGE));
+  catalogs_[0] = CreateBadDictionary(MISSING_MESSAGE);
   handler_.reset(MessageBundle::Create(catalogs_, &error));
   EXPECT_TRUE(handler_.get() == NULL);
   EXPECT_EQ("There is no \"message\" element for key n1.", error);
 
-  catalogs_[0].reset(CreateBadDictionary(PLACEHOLDER_NOT_A_TREE));
+  catalogs_[0] = CreateBadDictionary(PLACEHOLDER_NOT_A_TREE);
   handler_.reset(MessageBundle::Create(catalogs_, &error));
   EXPECT_TRUE(handler_.get() == NULL);
   EXPECT_EQ("Not a valid \"placeholders\" element for key n1.", error);
 
-  catalogs_[0].reset(CreateBadDictionary(EMPTY_PLACEHOLDER_TREE));
+  catalogs_[0] = CreateBadDictionary(EMPTY_PLACEHOLDER_TREE);
   handler_.reset(MessageBundle::Create(catalogs_, &error));
   EXPECT_TRUE(handler_.get() == NULL);
   EXPECT_EQ("Variable $a$ used but not defined.", error);
 
-  catalogs_[0].reset(CreateBadDictionary(CONTENT_MISSING));
+  catalogs_[0] = CreateBadDictionary(CONTENT_MISSING);
   handler_.reset(MessageBundle::Create(catalogs_, &error));
   EXPECT_TRUE(handler_.get() == NULL);
   EXPECT_EQ("Invalid \"content\" element for key n1.", error);
 
-  catalogs_[0].reset(CreateBadDictionary(MESSAGE_PLACEHOLDER_DOESNT_MATCH));
+  catalogs_[0] = CreateBadDictionary(MESSAGE_PLACEHOLDER_DOESNT_MATCH);
   handler_.reset(MessageBundle::Create(catalogs_, &error));
   EXPECT_TRUE(handler_.get() == NULL);
   EXPECT_EQ("Variable $a$ used but not defined.", error);
 }
 
 TEST_F(MessageBundleTest, ReservedMessagesOverrideDeveloperMessages) {
-  catalogs_.push_back(
-      linked_ptr<base::DictionaryValue>(CreateGoodDictionary()));
+  catalogs_.push_back(CreateGoodDictionary());
 
   base::DictionaryValue* dict = catalogs_[0].get();
   CreateMessageTree(MessageBundle::kUILocaleKey, "x", false, dict);
 
   std::string error = CreateMessageBundle();
 
   EXPECT_TRUE(handler_.get() == NULL);
   std::string expected_error = ErrorUtils::FormatErrorMessage(
       errors::kReservedMessageFound, MessageBundle::kUILocaleKey);
   EXPECT_EQ(expected_error, error);
@@ skipping 149 matching lines @@
   messages.insert(std::make_pair("message_name", "message_value"));
   (*GetExtensionToL10nMessagesMap())[extension_id] = messages;
 
   L10nMessagesMap* map = GetL10nMessagesMap(extension_id);
   ASSERT_TRUE(NULL != map);
   EXPECT_EQ(1U, map->size());
   EXPECT_EQ("message_value", (*map)["message_name"]);
 }
 
 }  // namespace extensions