Implementing chrome.i18n.getMessage call, that loads message from the extensi...

chrome/renderer/extensions/extension_process_bindings.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 <map>
+#include <set>
+#include <string>
+#include <vector>
+
 #include "chrome/renderer/extensions/extension_process_bindings.h"
 
 #include "base/singleton.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_message_bundle.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/extensions/bindings_utils.h"
 #include "chrome/renderer/extensions/event_bindings.h"
 #include "chrome/renderer/extensions/js_only_v8_extensions.h"
 #include "chrome/renderer/extensions/renderer_extension_bindings.h"
 #include "chrome/renderer/render_view.h"
 #include "grit/common_resources.h"
 #include "grit/renderer_resources.h"
@@ skipping 15 matching lines @@
 
 // A map of extension ID to vector of page action ids.
 typedef std::map< std::string, std::vector<std::string> > PageActionIdMap;
 
 // A map of permission name to whether its enabled for this extension.
 typedef std::map<std::string, bool> PermissionsMap;
 
 // A map of extension ID to permissions map.
 typedef std::map<std::string, PermissionsMap> ExtensionPermissionsMap;
 
+// A map of message name to message.
+typedef std::map<std::string, std::string> L10nMessagesMap;
+
+// A map of extension ID to l10n message map.
+typedef std::map<std::string, L10nMessagesMap >
+  ExtensionToL10nMessagesMap;
+
 const char kExtensionName[] = "chrome/ExtensionProcessBindings";
 const char* kExtensionDeps[] = {
   BaseJsV8Extension::kName,
   EventBindings::kName,
   JsonSchemaJsV8Extension::kName,
   RendererExtensionBindings::kName,
   ExtensionApiTestV8Extension::kName,
 };
 
 struct SingletonData {
   std::set<std::string> function_names_;
   PageActionIdMap page_action_ids_;
   ExtensionPermissionsMap permissions_;
+  ExtensionToL10nMessagesMap extension_l10n_messages_map_;
 };
 
 static std::set<std::string>* GetFunctionNameSet() {
   return &Singleton<SingletonData>()->function_names_;
 }
 
 static PageActionIdMap* GetPageActionMap() {
   return &Singleton<SingletonData>()->page_action_ids_;
 }
 
 static PermissionsMap* GetPermissionsMap(const std::string& extension_id) {
   return &Singleton<SingletonData>()->permissions_[extension_id];
 }
 
+static ExtensionToL10nMessagesMap* GetExtensionToL10nMessagesMap() {
+  return &Singleton<SingletonData>()->extension_l10n_messages_map_;
+}
+
+static L10nMessagesMap* GetL10nMessagesMap(const std::string extension_id) {
+  ExtensionToL10nMessagesMap::iterator it =
+    Singleton<SingletonData>()->extension_l10n_messages_map_.find(extension_id);
+  if (it != Singleton<SingletonData>()->extension_l10n_messages_map_.end()) {
+    return &(it->second);
+  } else {
+    return NULL;
+  }
+}
+
 class ExtensionImpl : public ExtensionBase {
  public:
   ExtensionImpl() : ExtensionBase(
       kExtensionName, GetStringResource<IDR_EXTENSION_PROCESS_BINDINGS_JS>(),
       arraysize(kExtensionDeps), kExtensionDeps) {}
 
   static void SetFunctionNames(const std::vector<std::string>& names) {
     std::set<std::string>* name_set = GetFunctionNameSet();
     for (size_t i = 0; i < names.size(); ++i) {
       name_set->insert(names[i]);
@@ skipping 21 matching lines @@
     } else if (name->Equals(v8::String::New("GetNextRequestId"))) {
       return v8::FunctionTemplate::New(GetNextRequestId);
     } else if (name->Equals(v8::String::New("OpenChannelToTab"))) {
       return v8::FunctionTemplate::New(OpenChannelToTab);
     } else if (name->Equals(v8::String::New("GetCurrentPageActions"))) {
       return v8::FunctionTemplate::New(GetCurrentPageActions);
     } else if (name->Equals(v8::String::New("StartRequest"))) {
       return v8::FunctionTemplate::New(StartRequest);
     } else if (name->Equals(v8::String::New("GetRenderViewId"))) {
       return v8::FunctionTemplate::New(GetRenderViewId);
+    } else if (name->Equals(v8::String::New("GetL10nMessage"))) {
+      return v8::FunctionTemplate::New(GetL10nMessage);
     }
 
     return ExtensionBase::GetNativeFunction(name);
   }
 
  private:
   static v8::Handle<v8::Value> GetExtensionAPIDefinition(
       const v8::Arguments& args) {
     return v8::String::New(GetStringResource<IDR_EXTENSION_API_JSON>());
   }
 
   // Returns true is |type| "isa" |match|.
   static bool ViewTypeMatches(ViewType::Type type, ViewType::Type match) {
     if (type == match)
       return true;
 
     // INVALID means match all.
     if (match == ViewType::INVALID)
       return true;
 
     // TODO(erikkay) for now, special case mole as a type of toolstrip.
     // Perhaps this isn't the right long-term thing to do.
-    if (match == ViewType::EXTENSION_TOOLSTRIP && 
+    if (match == ViewType::EXTENSION_TOOLSTRIP &&
         type == ViewType::EXTENSION_MOLE) {
       return true;
     }
 
     return false;
   }
 
   static v8::Handle<v8::Value> GetExtensionViews(const v8::Arguments& args) {
     if (args.Length() != 2)
       return v8::Undefined();
@@ skipping 103 matching lines @@
     v8::Local<v8::Array> page_action_vector = v8::Array::New(size);
     for (size_t i = 0; i < size; ++i) {
       std::string page_action_id = page_actions[i];
       page_action_vector->Set(v8::Integer::New(i),
                               v8::String::New(page_action_id.c_str()));
     }
 
     return page_action_vector;
   }
 
+  static v8::Handle<v8::Value> GetL10nMessage(const v8::Arguments& args) {
+    if (args.Length() != 2 || !args[0]->IsString())

[Erik does not do reviews, 2009/09/26 00:35:48]

NOTREACHED()

+      return v8::String::New("");

[Erik does not do reviews, 2009/09/26 00:35:48]

return V8::Undefined instead (and the other places you do this below)

+
+    L10nMessagesMap* l10n_messages =
+      GetL10nMessagesMap(ExtensionIdForCurrentContext());
+    if (!l10n_messages)
+      return v8::String::New("");
+
+    std::string message_name = *v8::String::AsciiValue(args[0]);
+    std::string message =
+      ExtensionMessageBundle::GetL10nMessage(message_name, *l10n_messages);
+
+    std::vector<string16> substitutions;
+    if (args[1]->IsNull() || args[1]->IsUndefined()) {
+      // chrome.i18n.getMessage("message_name");
+      // chrome.i18n.getMessage("message_name", null);
+      return v8::String::New(message.c_str());
+    } else if (args[1]->IsString()) {
+      // chrome.i18n.getMessage("message_name", "one param");
+      std::string substitute = *v8::String::Utf8Value(args[1]->ToString());
+      substitutions.push_back(UTF8ToUTF16(substitute));
+    } else if (args[1]->IsArray()) {
+      // chrome.i18n.getMessage("message_name", ["more", "params"]);
+      v8::Array* placeholders = static_cast<v8::Array*>(*args[1]);

[Erik does not do reviews, 2009/09/26 00:35:48]

verify that the length of placeholders is > 0 and <= 9 and add a DCHECK

+      for (uint32_t i = 0; i < placeholders->Length(); ++i) {
+        std::string substitute =
+          *v8::String::Utf8Value(
+              placeholders->Get(v8::Integer::New(i))->ToString());
+        substitutions.push_back(UTF8ToUTF16(substitute));
+      }
+    } else {

[Erik does not do reviews, 2009/09/26 00:35:48]

NOTREACHED()

+      return v8::String::New("");
+    }
+
+    return v8::String::New(UTF16ToUTF8(ReplaceStringPlaceholders(
+        UTF8ToUTF16(message), substitutions, NULL)).c_str());
+  }
+
   // Starts an API request to the browser, with an optional callback.  The
   // callback will be dispatched to EventBindings::HandleResponse.
   static v8::Handle<v8::Value> StartRequest(const v8::Arguments& args) {
     // Get the current RenderView so that we can send a routed IPC message from
     // the correct source.
     RenderView* renderview = bindings_utils::GetRenderViewForCurrentContext();
     if (!renderview)
       return v8::Undefined();
 
     if (args.Length() != 4 || !args[0]->IsString() || !args[1]->IsString() ||
@@ skipping 56 matching lines @@
 
   v8::HandleScope handle_scope;
   v8::Handle<v8::Value> argv[5];
   argv[0] = v8::Integer::New(request_id);
   argv[1] = v8::String::New(request->second->name.c_str());
   argv[2] = v8::Boolean::New(success);
   argv[3] = v8::String::New(response.c_str());
   argv[4] = v8::String::New(error.c_str());
   v8::Handle<v8::Value> retval = bindings_utils::CallFunctionInContext(
       request->second->context, "handleResponse", arraysize(argv), argv);
-  // In debug, the js will validate the callback parameters and return a 
+  // In debug, the js will validate the callback parameters and return a
   // string if a validation error has occured.
 #ifdef _DEBUG
   if (!retval.IsEmpty() && !retval->IsUndefined()) {
     std::string error = *v8::String::AsciiValue(retval);
     DCHECK(false) << error;
   }
 #endif
 
   pending_requests.erase(request);
 }
 
 // static
 void ExtensionProcessBindings::SetPageActions(
     const std::string& extension_id,
     const std::vector<std::string>& page_actions) {
   PageActionIdMap& page_action_map = *GetPageActionMap();
   if (!page_actions.empty()) {
     page_action_map[extension_id] = page_actions;
   } else {
     if (page_action_map.find(extension_id) != page_action_map.end())
       page_action_map.erase(extension_id);
   }
 }
 
 // static
+void ExtensionProcessBindings::SetL10nMessages(
+    const std::string& extension_id,
+    const std::map<std::string, std::string>& l10n_messages) {
+  ExtensionToL10nMessagesMap& l10n_messages_map =
+    *GetExtensionToL10nMessagesMap();
+  l10n_messages_map[extension_id] = l10n_messages;
+}
+
+// static
 void ExtensionProcessBindings::SetAPIPermissions(
     const std::string& extension_id,
     const std::vector<std::string>& permissions) {
   PermissionsMap& permissions_map = *GetPermissionsMap(extension_id);
 
   // Default all the API permissions to off. We will reset them below.
   for (size_t i = 0; i < Extension::kNumPermissions; ++i)
     permissions_map[Extension::kPermissionNames[i]] = false;
   for (size_t i = 0; i < permissions.size(); ++i)
     permissions_map[permissions[i]] = true;
@@ skipping 63 matching lines @@
     return;
 
   v8::HandleScope handle_scope;
   WebFrame* frame = view->GetMainFrame();
   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   v8::Handle<v8::Value> argv[1];
   argv[0] = v8::String::New(type_str);
   bindings_utils::CallFunctionInContext(context, "setViewType",
                                         arraysize(argv), argv);
 }