Run clang-modernize -use-nullptr over src/extensions/.

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 <string>
 #include <vector>
 
 #include "base/i18n/rtl.h"
@@ skipping 79 matching lines @@
         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);
         }
         break;
       case MISSING_MESSAGE:
-        dict->Remove("n1.message", NULL);
+        dict->Remove("n1.message", nullptr);
         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);
         }
         break;
       case CONTENT_MISSING:
-         dict->Remove("n1.placeholders.a.content", NULL);
+        dict->Remove("n1.placeholders.a.content", nullptr);
         break;
       case MESSAGE_PLACEHOLDER_DOESNT_MATCH:
         base::DictionaryValue* value;
-        dict->Remove("n1.placeholders.a", NULL);
+        dict->Remove("n1.placeholders.a", nullptr);
         dict->GetDictionary("n1.placeholders", &value);
         CreateContentTree("x", "X", value);
         break;
     }
 
     return dict;
   }
 
   unsigned int ReservedMessagesCount() {
     // Update when adding new reserved messages.
@@ skipping 34 matching lines @@
   scoped_ptr<MessageBundle> handler_;
   std::vector<linked_ptr<base::DictionaryValue> > catalogs_;
 };
 
 TEST_F(MessageBundleTest, ReservedMessagesCount) {
   ASSERT_EQ(5U, ReservedMessagesCount());
 }
 
 TEST_F(MessageBundleTest, InitEmptyDictionaries) {
   CreateMessageBundle();
-  EXPECT_TRUE(handler_.get() != NULL);
+  EXPECT_TRUE(handler_.get() != nullptr);
   EXPECT_EQ(0U + ReservedMessagesCount(), handler_->size());
   CheckReservedMessages(handler_.get());
 }
 
 TEST_F(MessageBundleTest, InitGoodDefaultDict) {
   catalogs_.push_back(
       linked_ptr<base::DictionaryValue>(CreateGoodDictionary()));
   CreateMessageBundle();
 
-  EXPECT_TRUE(handler_.get() != NULL);
+  EXPECT_TRUE(handler_.get() != nullptr);
   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()));
 
   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);
+  app_dict->Remove("n2", nullptr);
   // Replace n3 with N3.
-  app_dict->Remove("n3", NULL);
+  app_dict->Remove("n3", nullptr);
   CreateMessageTree("N3", "message3_app_dict", false, app_dict);
 
   CreateMessageBundle();
 
-  EXPECT_TRUE(handler_.get() != NULL);
+  EXPECT_TRUE(handler_.get() != nullptr);
   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()));
 
   std::string error = CreateMessageBundle();
 
-  EXPECT_TRUE(handler_.get() == NULL);
+  EXPECT_TRUE(handler_.get() == nullptr);
   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));
   handler_.reset(MessageBundle::Create(catalogs_, &error));
-  EXPECT_TRUE(handler_.get() == NULL);
+  EXPECT_TRUE(handler_.get() == nullptr);
   EXPECT_EQ("Not a valid tree for key n4.", error);
 
   catalogs_[0].reset(CreateBadDictionary(EMPTY_NAME_TREE));
   handler_.reset(MessageBundle::Create(catalogs_, &error));
-  EXPECT_TRUE(handler_.get() == NULL);
+  EXPECT_TRUE(handler_.get() == nullptr);
   EXPECT_EQ("There is no \"message\" element for key n4.", error);
 
   catalogs_[0].reset(CreateBadDictionary(MISSING_MESSAGE));
   handler_.reset(MessageBundle::Create(catalogs_, &error));
-  EXPECT_TRUE(handler_.get() == NULL);
+  EXPECT_TRUE(handler_.get() == nullptr);
   EXPECT_EQ("There is no \"message\" element for key n1.", error);
 
   catalogs_[0].reset(CreateBadDictionary(PLACEHOLDER_NOT_A_TREE));
   handler_.reset(MessageBundle::Create(catalogs_, &error));
-  EXPECT_TRUE(handler_.get() == NULL);
+  EXPECT_TRUE(handler_.get() == nullptr);
   EXPECT_EQ("Not a valid \"placeholders\" element for key n1.", error);
 
   catalogs_[0].reset(CreateBadDictionary(EMPTY_PLACEHOLDER_TREE));
   handler_.reset(MessageBundle::Create(catalogs_, &error));
-  EXPECT_TRUE(handler_.get() == NULL);
+  EXPECT_TRUE(handler_.get() == nullptr);
   EXPECT_EQ("Variable $a$ used but not defined.", error);
 
   catalogs_[0].reset(CreateBadDictionary(CONTENT_MISSING));
   handler_.reset(MessageBundle::Create(catalogs_, &error));
-  EXPECT_TRUE(handler_.get() == NULL);
+  EXPECT_TRUE(handler_.get() == nullptr);
   EXPECT_EQ("Invalid \"content\" element for key n1.", error);
 
   catalogs_[0].reset(CreateBadDictionary(MESSAGE_PLACEHOLDER_DOESNT_MATCH));
   handler_.reset(MessageBundle::Create(catalogs_, &error));
-  EXPECT_TRUE(handler_.get() == NULL);
+  EXPECT_TRUE(handler_.get() == nullptr);
   EXPECT_EQ("Variable $a$ used but not defined.", error);
 }
 
 TEST_F(MessageBundleTest, ReservedMessagesOverrideDeveloperMessages) {
   catalogs_.push_back(
       linked_ptr<base::DictionaryValue>(CreateGoodDictionary()));
 
   base::DictionaryValue* dict = catalogs_[0].get();
   CreateMessageTree(MessageBundle::kUILocaleKey, "x", false, dict);
 
   std::string error = CreateMessageBundle();
 
-  EXPECT_TRUE(handler_.get() == NULL);
+  EXPECT_TRUE(handler_.get() == nullptr);
   std::string expected_error = ErrorUtils::FormatErrorMessage(
       errors::kReservedMessageFound, MessageBundle::kUILocaleKey);
   EXPECT_EQ(expected_error, error);
 }
 
 TEST_F(MessageBundleTest, AppendReservedMessagesForLTR) {
   CreateMessageBundle();
 
-  ASSERT_TRUE(handler_.get() != NULL);
+  ASSERT_TRUE(handler_.get() != nullptr);
   ClearDictionary();
   ASSERT_TRUE(AppendReservedMessages("en_US"));
 
   EXPECT_EQ("en_US",
             handler_->GetL10nMessage(MessageBundle::kUILocaleKey));
   EXPECT_EQ("ltr", handler_->GetL10nMessage(
       MessageBundle::kBidiDirectionKey));
   EXPECT_EQ("rtl", handler_->GetL10nMessage(
       MessageBundle::kBidiReversedDirectionKey));
   EXPECT_EQ("left", handler_->GetL10nMessage(
       MessageBundle::kBidiStartEdgeKey));
   EXPECT_EQ("right", handler_->GetL10nMessage(
       MessageBundle::kBidiEndEdgeKey));
 }
 
 TEST_F(MessageBundleTest, AppendReservedMessagesForRTL) {
   CreateMessageBundle();
 
-  ASSERT_TRUE(handler_.get() != NULL);
+  ASSERT_TRUE(handler_.get() != nullptr);
   ClearDictionary();
   ASSERT_TRUE(AppendReservedMessages("he"));
 
   EXPECT_EQ("he",
             handler_->GetL10nMessage(MessageBundle::kUILocaleKey));
   EXPECT_EQ("rtl", handler_->GetL10nMessage(
       MessageBundle::kBidiDirectionKey));
   EXPECT_EQ("ltr", handler_->GetL10nMessage(
       MessageBundle::kBidiReversedDirectionKey));
   EXPECT_EQ("right", handler_->GetL10nMessage(
@@ skipping 88 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // Renderer helper functions test.
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 TEST(GetExtensionToL10nMessagesMapTest, ReturnsTheSameObject) {
   ExtensionToL10nMessagesMap* map1 = GetExtensionToL10nMessagesMap();
-  ASSERT_TRUE(NULL != map1);
+  ASSERT_TRUE(nullptr != map1);
 
   ExtensionToL10nMessagesMap* map2 = GetExtensionToL10nMessagesMap();
   ASSERT_EQ(map1, map2);
 }
 
 TEST(GetExtensionToL10nMessagesMapTest, ReturnsNullForUnknownExtensionId) {
   const std::string extension_id("some_unique_12334212314234_id");
   L10nMessagesMap* map = GetL10nMessagesMap(extension_id);
-  EXPECT_TRUE(NULL == map);
+  EXPECT_TRUE(nullptr == map);
 }
 
 TEST(GetExtensionToL10nMessagesMapTest, ReturnsMapForKnownExtensionId) {
   const std::string extension_id("some_unique_121212121212121_id");
   // Store a map for given id.
   L10nMessagesMap messages;
   messages.insert(std::make_pair("message_name", "message_value"));
   (*GetExtensionToL10nMessagesMap())[extension_id] = messages;
 
   L10nMessagesMap* map = GetL10nMessagesMap(extension_id);
-  ASSERT_TRUE(NULL != map);
+  ASSERT_TRUE(nullptr != map);
   EXPECT_EQ(1U, map->size());
   EXPECT_EQ("message_value", (*map)["message_name"]);
 }
 
 }  // namespace extensions