Add reserved messages to ExtensionMessageBundle dictionary. They are of the f...

chrome/common/extensions/extension_message_bundle.cc

 // Copyright (c) 2009 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 <string>
 #include <vector>
 
+#include "app/l10n_util.h"
 #include "base/hash_tables.h"
 #include "base/linked_ptr.h"
 #include "base/scoped_ptr.h"
+#include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/values.h"
+#include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/extensions/extension_error_utils.h"
+#include "chrome/common/extensions/extension_l10n_util.h"
+
+namespace errors = extension_manifest_errors;
 
 const wchar_t* ExtensionMessageBundle::kContentKey = L"content";
 const wchar_t* ExtensionMessageBundle::kMessageKey = L"message";
 const wchar_t* ExtensionMessageBundle::kPlaceholdersKey = L"placeholders";
 
 const char* ExtensionMessageBundle::kPlaceholderBegin = "$";
 const char* ExtensionMessageBundle::kPlaceholderEnd = "$";
 const char* ExtensionMessageBundle::kMessageBegin = "__MSG_";
 const char* ExtensionMessageBundle::kMessageEnd = "__";
 
+// Reserved messages names.
+const char* ExtensionMessageBundle::kUILocaleKey = "@@ui_locale";
+const char* ExtensionMessageBundle::kBidiDirectionKey = "@@bidi_dir";
+const char* ExtensionMessageBundle::kBidiReversedDirectionKey =
+    "@@bidi_reversed_dir";
+const char* ExtensionMessageBundle::kBidiStartEdgeKey = "@@bidi_start_edge";
+const char* ExtensionMessageBundle::kBidiEndEdgeKey = "@@bidi_end_edge";
+
+// Reserved messages values.
+const char* ExtensionMessageBundle::kBidiLeftEdgeValue = "left";
+const char* ExtensionMessageBundle::kBidiRightEdgeValue = "right";
+
 // Formats message in case we encounter a bad formed key in the JSON object.
 // Returns false and sets |error| to actual error message.
 static bool BadKeyMessage(const std::string& name, std::string* error) {
   *error = StringPrintf("Name of a key \"%s\" is invalid. Only ASCII [a-z], "
                         "[A-Z], [0-9] and \"_\" are allowed.", name.c_str());
   return false;
 }
 
 // static
 ExtensionMessageBundle* ExtensionMessageBundle::Create(
@@ skipping 20 matching lines @@
       if (!IsValidName(*key_it))
         return BadKeyMessage(key, error);
       std::string value;
       if (!GetMessageValue(*key_it, *catalog, &value, error))
         return false;
       // Keys are not case-sensitive.
       dictionary_[key] = value;
     }
   }
 
+  if (!AppendReservedMessages(extension_l10n_util::CurrentLocaleOrDefault(),
+                              error))
+    return false;
+
+  return true;
+}
+
+bool ExtensionMessageBundle::AppendReservedMessages(
+    const std::string& app_locale, std::string* error) {
+  SubstitutionMap append_messages;
+  append_messages[kUILocaleKey] = app_locale;
+
+  // Calling l10n_util::GetTextDirection on non-UI threads doesn't seems safe,
+  // so we use GetTextDirectionForLocale instead.
+  if (l10n_util::GetTextDirectionForLocale(app_locale.c_str()) ==
+      l10n_util::RIGHT_TO_LEFT) {
+    append_messages[kBidiDirectionKey] = "rtl";
+    append_messages[kBidiReversedDirectionKey] = "ltr";
+    append_messages[kBidiStartEdgeKey] = kBidiRightEdgeValue;
+    append_messages[kBidiEndEdgeKey] = kBidiLeftEdgeValue;
+  } else {
+    append_messages[kBidiDirectionKey] = "ltr";
+    append_messages[kBidiReversedDirectionKey] = "rtl";
+    append_messages[kBidiStartEdgeKey] = kBidiLeftEdgeValue;
+    append_messages[kBidiEndEdgeKey] = kBidiRightEdgeValue;
+  }
+
+  // Add all reserved messages to the dictionary, but check for collisions.
+  SubstitutionMap::iterator it = append_messages.begin();
+  for (; it != append_messages.end(); ++it) {
+    if (ContainsKey(dictionary_, it->first)) {
+      *error = ExtensionErrorUtils::FormatErrorMessage(
+          errors::kReservedMessageFound, it->first);
+      return false;
+    } else {
+      dictionary_[it->first] = it->second;
+    }
+  }
+
   return true;
 }
 
 bool ExtensionMessageBundle::GetMessageValue(const std::wstring& wkey,
                                              const DictionaryValue& catalog,
                                              std::string* value,
                                              std::string* error) const {
   std::string key(WideToUTF8(wkey));
   // Get the top level tree for given key (name part).
   DictionaryValue* name_tree;
@@ skipping 133 matching lines @@
 }
 
 // static
 template <typename str>
 bool ExtensionMessageBundle::IsValidName(const str& name) {
   if (name.empty())
     return false;
 
   for (typename str::const_iterator it = name.begin(); it != name.end(); ++it) {
     // Allow only ascii 0-9, a-z, A-Z, and _ in the name.
-    if (!IsAsciiAlpha(*it) && !IsAsciiDigit(*it) && *it != '_')
+    if (!IsAsciiAlpha(*it) && !IsAsciiDigit(*it) && *it != '_' && *it != '@')
       return false;
   }
 
   return true;
 }
 
 // Dictionary interface.
 
 std::string ExtensionMessageBundle::GetL10nMessage(
     const std::string& name) const {
   return GetL10nMessage(name, dictionary_);
 }
 
 // static
 std::string ExtensionMessageBundle::GetL10nMessage(
     const std::string& name, const SubstitutionMap& dictionary) {
   SubstitutionMap::const_iterator it =
     dictionary.find(StringToLowerASCII(name));
   if (it != dictionary.end()) {
     return it->second;
   }
 
   return "";
 }