Moved ExtensionMessage* into extensions namespace

chrome/common/extensions/message_bundle_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 "chrome/common/extensions/extension_message_bundle.h"
+#include "chrome/common/extensions/message_bundle.h"
 
 #include <string>
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace errors = extension_manifest_errors;
 
-class ExtensionMessageBundleTest : public testing::Test {
+namespace extensions {
+
+class MessageBundleTest : public testing::Test {
  protected:
   enum BadDictionary {
     INVALID_NAME,
     NAME_NOT_A_TREE,
     EMPTY_NAME_TREE,
     MISSING_MESSAGE,
     PLACEHOLDER_NOT_A_TREE,
     EMPTY_PLACEHOLDER_TREE,
     CONTENT_MISSING,
     MESSAGE_PLACEHOLDER_DOESNT_MATCH,
   };
 
   // Helper method for dictionary building.
   void SetDictionary(const std::string& name,
                      DictionaryValue* subtree,
                      DictionaryValue* target) {
     target->Set(name, static_cast<Value*>(subtree));
   }
 
   void CreateContentTree(const std::string& name,
                          const std::string& content,
                          DictionaryValue* dict) {
     DictionaryValue* content_tree = new DictionaryValue;
-    content_tree->SetString(ExtensionMessageBundle::kContentKey, content);
+    content_tree->SetString(MessageBundle::kContentKey, content);
     SetDictionary(name, content_tree, dict);
   }
 
   void CreatePlaceholdersTree(DictionaryValue* dict) {
     DictionaryValue* placeholders_tree = new DictionaryValue;
     CreateContentTree("a", "A", placeholders_tree);
     CreateContentTree("b", "B", placeholders_tree);
     CreateContentTree("c", "C", placeholders_tree);
-    SetDictionary(ExtensionMessageBundle::kPlaceholdersKey,
+    SetDictionary(MessageBundle::kPlaceholdersKey,
                   placeholders_tree,
                   dict);
   }
 
   void CreateMessageTree(const std::string& name,
                          const std::string& message,
                          bool create_placeholder_subtree,
                          DictionaryValue* dict) {
     DictionaryValue* message_tree = new DictionaryValue;
     if (create_placeholder_subtree)
       CreatePlaceholdersTree(message_tree);
-    message_tree->SetString(ExtensionMessageBundle::kMessageKey, message);
+    message_tree->SetString(MessageBundle::kMessageKey, message);
     SetDictionary(name, message_tree, dict);
   }
 
   // Caller owns the memory.
   DictionaryValue* CreateGoodDictionary() {
     DictionaryValue* dict = new DictionaryValue;
     CreateMessageTree("n1", "message1 $a$ $b$", true, dict);
     CreateMessageTree("n2", "message2 $c$", true, dict);
     CreateMessageTree("n3", "message3", false, dict);
     return dict;
@@ skipping 38 matching lines @@
     }
 
     return dict;
   }
 
   unsigned int ReservedMessagesCount() {
     // Update when adding new reserved messages.
     return 5U;
   }
 
-  void CheckReservedMessages(ExtensionMessageBundle* handler) {
+  void CheckReservedMessages(MessageBundle* handler) {
     std::string ui_locale = extension_l10n_util::CurrentLocaleOrDefault();
     EXPECT_EQ(ui_locale,
-              handler->GetL10nMessage(ExtensionMessageBundle::kUILocaleKey));
+              handler->GetL10nMessage(MessageBundle::kUILocaleKey));
 
     std::string text_dir = "ltr";
     if (base::i18n::GetTextDirectionForLocale(ui_locale.c_str()) ==
         base::i18n::RIGHT_TO_LEFT)
       text_dir = "rtl";
 
     EXPECT_EQ(text_dir, handler->GetL10nMessage(
-        ExtensionMessageBundle::kBidiDirectionKey));
+        MessageBundle::kBidiDirectionKey));
   }
 
   bool AppendReservedMessages(const std::string& application_locale) {
     std::string error;
     return handler_->AppendReservedMessagesForLocale(
         application_locale, &error);
   }
 
   std::string CreateMessageBundle() {
     std::string error;
-    handler_.reset(ExtensionMessageBundle::Create(catalogs_, &error));
+    handler_.reset(MessageBundle::Create(catalogs_, &error));
 
     return error;
   }
 
   void ClearDictionary() {
     handler_->dictionary_.clear();
   }
 
-  scoped_ptr<ExtensionMessageBundle> handler_;
+  scoped_ptr<MessageBundle> handler_;
   std::vector<linked_ptr<DictionaryValue> > catalogs_;
 };
 
-TEST_F(ExtensionMessageBundleTest, ReservedMessagesCount) {
+TEST_F(MessageBundleTest, ReservedMessagesCount) {
   ASSERT_EQ(5U, ReservedMessagesCount());
 }
 
-TEST_F(ExtensionMessageBundleTest, InitEmptyDictionaries) {
+TEST_F(MessageBundleTest, InitEmptyDictionaries) {
   CreateMessageBundle();
   EXPECT_TRUE(handler_.get() != NULL);
   EXPECT_EQ(0U + ReservedMessagesCount(), handler_->size());
   CheckReservedMessages(handler_.get());
 }
 
-TEST_F(ExtensionMessageBundleTest, InitGoodDefaultDict) {
+TEST_F(MessageBundleTest, InitGoodDefaultDict) {
   catalogs_.push_back(linked_ptr<DictionaryValue>(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(ExtensionMessageBundleTest, InitAppDictConsultedFirst) {
+TEST_F(MessageBundleTest, InitAppDictConsultedFirst) {
   catalogs_.push_back(linked_ptr<DictionaryValue>(CreateGoodDictionary()));
   catalogs_.push_back(linked_ptr<DictionaryValue>(CreateGoodDictionary()));
 
   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(ExtensionMessageBundleTest, InitBadAppDict) {
+TEST_F(MessageBundleTest, InitBadAppDict) {
   catalogs_.push_back(
       linked_ptr<DictionaryValue>(CreateBadDictionary(INVALID_NAME)));
   catalogs_.push_back(linked_ptr<DictionaryValue>(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));
-  handler_.reset(ExtensionMessageBundle::Create(catalogs_, &error));
+  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));
-  handler_.reset(ExtensionMessageBundle::Create(catalogs_, &error));
+  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));
-  handler_.reset(ExtensionMessageBundle::Create(catalogs_, &error));
+  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));
-  handler_.reset(ExtensionMessageBundle::Create(catalogs_, &error));
+  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));
-  handler_.reset(ExtensionMessageBundle::Create(catalogs_, &error));
+  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));
-  handler_.reset(ExtensionMessageBundle::Create(catalogs_, &error));
+  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));
-  handler_.reset(ExtensionMessageBundle::Create(catalogs_, &error));
+  handler_.reset(MessageBundle::Create(catalogs_, &error));
   EXPECT_TRUE(handler_.get() == NULL);
   EXPECT_EQ("Variable $a$ used but not defined.", error);
 }
 
-TEST_F(ExtensionMessageBundleTest, ReservedMessagesOverrideDeveloperMessages) {
+TEST_F(MessageBundleTest, ReservedMessagesOverrideDeveloperMessages) {
   catalogs_.push_back(linked_ptr<DictionaryValue>(CreateGoodDictionary()));
 
   DictionaryValue* dict = catalogs_[0].get();
-  CreateMessageTree(ExtensionMessageBundle::kUILocaleKey, "x", false, dict);
+  CreateMessageTree(MessageBundle::kUILocaleKey, "x", false, dict);
 
   std::string error = CreateMessageBundle();
 
   EXPECT_TRUE(handler_.get() == NULL);
   std::string expected_error = ExtensionErrorUtils::FormatErrorMessage(
-      errors::kReservedMessageFound, ExtensionMessageBundle::kUILocaleKey);
+      errors::kReservedMessageFound, MessageBundle::kUILocaleKey);
   EXPECT_EQ(expected_error, error);
 }
 
-TEST_F(ExtensionMessageBundleTest, AppendReservedMessagesForLTR) {
+TEST_F(MessageBundleTest, AppendReservedMessagesForLTR) {
   CreateMessageBundle();
 
   ASSERT_TRUE(handler_.get() != NULL);
   ClearDictionary();
   ASSERT_TRUE(AppendReservedMessages("en_US"));
 
   EXPECT_EQ("en_US",
-            handler_->GetL10nMessage(ExtensionMessageBundle::kUILocaleKey));
+            handler_->GetL10nMessage(MessageBundle::kUILocaleKey));
   EXPECT_EQ("ltr", handler_->GetL10nMessage(
-      ExtensionMessageBundle::kBidiDirectionKey));
+      MessageBundle::kBidiDirectionKey));
   EXPECT_EQ("rtl", handler_->GetL10nMessage(
-      ExtensionMessageBundle::kBidiReversedDirectionKey));
+      MessageBundle::kBidiReversedDirectionKey));
   EXPECT_EQ("left", handler_->GetL10nMessage(
-      ExtensionMessageBundle::kBidiStartEdgeKey));
+      MessageBundle::kBidiStartEdgeKey));
   EXPECT_EQ("right", handler_->GetL10nMessage(
-      ExtensionMessageBundle::kBidiEndEdgeKey));
+      MessageBundle::kBidiEndEdgeKey));
 }
 
-TEST_F(ExtensionMessageBundleTest, AppendReservedMessagesForRTL) {
+TEST_F(MessageBundleTest, AppendReservedMessagesForRTL) {
   CreateMessageBundle();
 
   ASSERT_TRUE(handler_.get() != NULL);
   ClearDictionary();
   ASSERT_TRUE(AppendReservedMessages("he"));
 
   EXPECT_EQ("he",
-            handler_->GetL10nMessage(ExtensionMessageBundle::kUILocaleKey));
+            handler_->GetL10nMessage(MessageBundle::kUILocaleKey));
   EXPECT_EQ("rtl", handler_->GetL10nMessage(
-      ExtensionMessageBundle::kBidiDirectionKey));
+      MessageBundle::kBidiDirectionKey));
   EXPECT_EQ("ltr", handler_->GetL10nMessage(
-      ExtensionMessageBundle::kBidiReversedDirectionKey));
+      MessageBundle::kBidiReversedDirectionKey));
   EXPECT_EQ("right", handler_->GetL10nMessage(
-      ExtensionMessageBundle::kBidiStartEdgeKey));
+      MessageBundle::kBidiStartEdgeKey));
   EXPECT_EQ("left", handler_->GetL10nMessage(
-      ExtensionMessageBundle::kBidiEndEdgeKey));
+      MessageBundle::kBidiEndEdgeKey));
 }
 
-TEST_F(ExtensionMessageBundleTest, IsValidNameCheckValidCharacters) {
-  EXPECT_TRUE(ExtensionMessageBundle::IsValidName(std::string("a__BV_9")));
-  EXPECT_TRUE(ExtensionMessageBundle::IsValidName(std::string("@@a__BV_9")));
-  EXPECT_FALSE(ExtensionMessageBundle::IsValidName(std::string("$a__BV_9$")));
-  EXPECT_FALSE(ExtensionMessageBundle::IsValidName(std::string("a-BV-9")));
-  EXPECT_FALSE(ExtensionMessageBundle::IsValidName(std::string("a#BV!9")));
-  EXPECT_FALSE(ExtensionMessageBundle::IsValidName(std::string("a<b")));
+TEST_F(MessageBundleTest, IsValidNameCheckValidCharacters) {
+  EXPECT_TRUE(MessageBundle::IsValidName(std::string("a__BV_9")));
+  EXPECT_TRUE(MessageBundle::IsValidName(std::string("@@a__BV_9")));
+  EXPECT_FALSE(MessageBundle::IsValidName(std::string("$a__BV_9$")));
+  EXPECT_FALSE(MessageBundle::IsValidName(std::string("a-BV-9")));
+  EXPECT_FALSE(MessageBundle::IsValidName(std::string("a#BV!9")));
+  EXPECT_FALSE(MessageBundle::IsValidName(std::string("a<b")));
 }
 
 struct ReplaceVariables {
   const char* original;
   const char* result;
   const char* error;
   const char* begin_delimiter;
   const char* end_delimiter;
   bool pass;
 };
 
-TEST(ExtensionMessageBundle, ReplaceMessagesInText) {
-  const char* kMessageBegin = ExtensionMessageBundle::kMessageBegin;
-  const char* kMessageEnd = ExtensionMessageBundle::kMessageEnd;
-  const char* kPlaceholderBegin = ExtensionMessageBundle::kPlaceholderBegin;
-  const char* kPlaceholderEnd = ExtensionMessageBundle::kPlaceholderEnd;
+TEST(MessageBundle, ReplaceMessagesInText) {
+  const char* kMessageBegin = MessageBundle::kMessageBegin;
+  const char* kMessageEnd = MessageBundle::kMessageEnd;
+  const char* kPlaceholderBegin = MessageBundle::kPlaceholderBegin;
+  const char* kPlaceholderEnd = MessageBundle::kPlaceholderEnd;
 
   static ReplaceVariables test_cases[] = {
     // Message replacement.
     { "This is __MSG_siMPle__ message", "This is simple message",
       "", kMessageBegin, kMessageEnd, true },
     { "This is __MSG_", "This is __MSG_",
       "", kMessageBegin, kMessageEnd, true },
     { "This is __MSG__simple__ message", "This is __MSG__simple__ message",
       "Variable __MSG__simple__ used but not defined.",
       kMessageBegin, kMessageEnd, false },
@@ skipping 22 matching lines @@
        "", kPlaceholderBegin, kPlaceholderEnd, true },
     { "A $simple$$long_v$", "A simpleA pretty long replacement",
        "", kPlaceholderBegin, kPlaceholderEnd, true },
     { "This is $bad name$", "This is $bad name$",
        "", kPlaceholderBegin, kPlaceholderEnd, true },
     { "This is $missing$", "This is $missing$",
        "Variable $missing$ used but not defined.",
        kPlaceholderBegin, kPlaceholderEnd, false },
   };
 
-  ExtensionMessageBundle::SubstitutionMap messages;
+  MessageBundle::SubstitutionMap messages;
   messages.insert(std::make_pair("simple", "simple"));
   messages.insert(std::make_pair("long", "A pretty long replacement"));
   messages.insert(std::make_pair("long_v", "A pretty long replacement"));
   messages.insert(std::make_pair("bad name", "Doesn't matter"));
   messages.insert(std::make_pair("d1g1ts_are_ok", "I are d1g1t"));
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     std::string text = test_cases[i].original;
     std::string error;
     EXPECT_EQ(test_cases[i].pass,
-      ExtensionMessageBundle::ReplaceVariables(messages,
-                                               test_cases[i].begin_delimiter,
-                                               test_cases[i].end_delimiter,
-                                               &text,
-                                               &error));
+              MessageBundle::ReplaceVariables(messages,
+                                              test_cases[i].begin_delimiter,
+                                              test_cases[i].end_delimiter,
+                                              &text,
+                                              &error));
     EXPECT_EQ(test_cases[i].result, text);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // Renderer helper functions test.
 //
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 16 matching lines @@
   // 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);
   EXPECT_EQ(1U, map->size());
   EXPECT_EQ("message_value", (*map)["message_name"]);
 }
+
+}  // namespace extensions