Moving IME manifests to chrome resources.

chrome/browser/chromeos/input_method/component_extension_ime_manager_impl.cc

 // Copyright 2013 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/browser/chromeos/input_method/component_extension_ime_manager_impl.h"
 
+#include <algorithm>
+
 #include "base/file_util.h"
+#include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chromeos/ime/extension_ime_util.h"
-#include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_l10n_util.h"
-#include "extensions/common/file_util.h"
 #include "extensions/common/manifest_constants.h"
+#include "grit/browser_resources.h"
+#include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/base/resource/resource_bundle.h"
 
 namespace chromeos {
 
 namespace {
 
 struct WhitelistedComponentExtensionIME {
   const char* id;
-  const char* path;
+  int manifest_resource_id;
 } whitelisted_component_extension[] = {
-  {
-    // ChromeOS Hangul Input.
-    extension_ime_util::kHangulExtensionId,
-    "/usr/share/chromeos-assets/input_methods/hangul",
-  },
-#if defined(OFFICIAL_BUILD)
-  {
-    // Official Google XKB Input.
-    extension_ime_util::kXkbExtensionId,
-    "/usr/share/chromeos-assets/input_methods/google_xkb",
-  },
-  {
-    // Google input tools.
-    extension_ime_util::kT13nExtensionId,
-    "/usr/share/chromeos-assets/input_methods/input_tools",
-  },
-#else
-  {
-    // Open-sourced ChromeOS xkb extension.
-    extension_ime_util::kXkbExtensionId,
-    "/usr/share/chromeos-assets/input_methods/xkb",
-  },
-  {
-    // Open-sourced ChromeOS Keyboards extension.
-    extension_ime_util::kM17nExtensionId,
-    "/usr/share/chromeos-assets/input_methods/keyboard_layouts",
-  },
-  {
-    // Open-sourced Pinyin Chinese Input Method.
-    extension_ime_util::kChinesePinyinExtensionId,
-    "/usr/share/chromeos-assets/input_methods/pinyin",
-  },
-  {
-    // Open-sourced Zhuyin Chinese Input Method.
-    extension_ime_util::kChineseZhuyinExtensionId,
-    "/usr/share/chromeos-assets/input_methods/zhuyin",
-  },
-  {
-    // Open-sourced Cangjie Chinese Input Method.
-    extension_ime_util::kChineseCangjieExtensionId,
-    "/usr/share/chromeos-assets/input_methods/cangjie",
-  },
-  {
-    // Japanese Mozc Input.
-    extension_ime_util::kMozcExtensionId,
-    "/usr/share/chromeos-assets/input_methods/nacl_mozc",
-  },
-#endif
-  {
-    // Braille hardware keyboard IME that works together with ChromeVox.
-    extension_misc::kBrailleImeExtensionId,
-    extension_misc::kBrailleImeExtensionPath,
-  },
+      {// ChromeOS Hangul Input.
+       extension_ime_util::kHangulExtensionId,
+       IDR_HANGUL_MANIFEST,
+      },
+      {// Official Google XKB Input.
+       extension_ime_util::kXkbExtensionId,
+       IDR_GOOGLE_XKB_MANIFEST,
+      },
+      {// Google input tools.
+       extension_ime_util::kT13nExtensionId,
+       IDR_GOOGLE_INPUT_TOOLS_MANIFEST,
+      },
+      {// Open-sourced ChromeOS xkb extension.
+       extension_ime_util::kXkbExtensionId,
+       IDR_XKB_MANIFEST,
+      },
+      {// Open-sourced ChromeOS Keyboards extension.
+       extension_ime_util::kM17nExtensionId,
+       IDR_M17N_MANIFEST,
+      },
+      {// Open-sourced Pinyin Chinese Input Method.
+       extension_ime_util::kChinesePinyinExtensionId,
+       IDR_PINYIN_MANIFEST,
+      },
+      {// Open-sourced Zhuyin Chinese Input Method.
+       extension_ime_util::kChineseZhuyinExtensionId,
+       IDR_ZHUYIN_MANIFEST,
+      },
+      {// Open-sourced Cangjie Chinese Input Method.
+       extension_ime_util::kChineseCangjieExtensionId,
+       IDR_CANGJIE_MANIFEST,
+      },
+      {// Japanese Mozc Input.
+       extension_ime_util::kMozcExtensionId,
+       IDR_MOZC_MANIFEST,
+      },
+      {// Braille hardware keyboard IME that works together with ChromeVox.
+       extension_misc::kBrailleImeExtensionId,
+       IDR_BRAILLE_MANIFEST,
+      },
 };
 
+const struct InputMethodNameMap {
+  const char* message_name;
+  int resource_id;
+  bool operator()(const InputMethodNameMap& m1,
+                  const InputMethodNameMap& m2) const {
+    return strcmp(m1.message_name, m2.message_name) < 0;
+  }
+} kInputMethodNameMap[] = {
+      {"__MSG_ARMENIAN_PHONETIC_KEYBOARD__",
+       IDS_IME_NAME_ARMENIAN_PHONETIC_KEYBOARD},
+      {"__MSG_ARRAY_INPUTMETHOD__", IDS_IME_NAME_ARRAY_INPUTMETHOD},
+      {"__MSG_BELARUSIAN_KEYBOARD__", IDS_IME_NAME_BELARUSIAN_KEYBOARD},
+      {"__MSG_BELGIAN_KEYBOARD__", IDS_IME_NAME_BELGIAN_KEYBOARD},
+      {"__MSG_BRAZILIAN_KEYBOARD__", IDS_IME_NAME_BRAZILIAN_KEYBOARD},
+      {"__MSG_BULGARIAN_KEYBOARD__", IDS_IME_NAME_BULGARIAN_KEYBOARD},
+      {"__MSG_BULGARIAN_PHONETIC_KEYBOARD__",
+       IDS_IME_NAME_BULGARIAN_PHONETIC_KEYBOARD},
+      {"__MSG_CANADIAN_ENGLISH_KEYBOARD__",
+       IDS_IME_NAME_CANADIAN_ENGLISH_KEYBOARD},
+      {"__MSG_CANADIAN_FRENCH_KEYBOARD__",
+       IDS_IME_NAME_CANADIAN_FRENCH_KEYBOARD},
+      {"__MSG_CANADIAN_MULTILINGUAL_KEYBOARD__",
+       IDS_IME_NAME_CANADIAN_MULTILINGUAL_KEYBOARD},
+      {"__MSG_CANGJIE_INPUTMETHOD__", IDS_IME_NAME_CANGJIE_INPUTMETHOD},
+      {"__MSG_CATALAN_KEYBOARD__", IDS_IME_NAME_CATALAN_KEYBOARD},
+      {"__MSG_CROATIAN_KEYBOARD__", IDS_IME_NAME_CROATIAN_KEYBOARD},
+      {"__MSG_CZECH_KEYBOARD__", IDS_IME_NAME_CZECH_KEYBOARD},
+      {"__MSG_CZECH_QWERTY_KEYBOARD__", IDS_IME_NAME_CZECH_QWERTY_KEYBOARD},
+      {"__MSG_DANISH_KEYBOARD__", IDS_IME_NAME_DANISH_KEYBOARD},
+      {"__MSG_DAYI_INPUTMETHOD__", IDS_IME_NAME_DAYI_INPUTMETHOD},
+      {"__MSG_ESTONIAN_KEYBOARD__", IDS_IME_NAME_ESTONIAN_KEYBOARD},
+      {"__MSG_FINNISH_KEYBOARD__", IDS_IME_NAME_FINNISH_KEYBOARD},
+      {"__MSG_FRENCH_KEYBOARD__", IDS_IME_NAME_FRENCH_KEYBOARD},
+      {"__MSG_GEORGIAN_KEYBOARD__", IDS_IME_NAME_GEORGIAN_KEYBOARD},
+      {"__MSG_GERMAN_KEYBOARD__", IDS_IME_NAME_GERMAN_KEYBOARD},
+      {"__MSG_GERMAN_NEO_2_KEYBOARD__", IDS_IME_NAME_GERMAN_NEO_2_KEYBOARD},
+      {"__MSG_GREEK_KEYBOARD__", IDS_IME_NAME_GREEK_KEYBOARD},
+      {"__MSG_HANGUL_2_SET__", IDS_IME_NAME_HANGUL_2_SET},
+      {"__MSG_HANGUL_3_SET_390__", IDS_IME_NAME_HANGUL_3_SET_390},
+      {"__MSG_HANGUL_3_SET_FINAL__", IDS_IME_NAME_HANGUL_3_SET_FINAL},
+      {"__MSG_HANGUL_3_SET_NO_SHIFT__", IDS_IME_NAME_HANGUL_3_SET_NO_SHIFT},
+      {"__MSG_HANGUL_AHNMATAE__", IDS_IME_NAME_HANGUL_AHNMATAE},
+      {"__MSG_HANGUL_ROMAJA__", IDS_IME_NAME_HANGUL_ROMAJA},
+      {"__MSG_HEBREW_KEYBOARD__", IDS_IME_NAME_HEBREW_KEYBOARD},
+      {"__MSG_HUNGARIAN_KEYBOARD__", IDS_IME_NAME_HUNGARIAN_KEYBOARD},
+      {"__MSG_ICELANDIC_KEYBOARD__", IDS_IME_NAME_ICELANDIC_KEYBOARD},
+      {"__MSG_IRISH_KEYBOARD__", IDS_IME_NAME_IRISH_KEYBOARD},
+      {"__MSG_ITALIAN_KEYBOARD__", IDS_IME_NAME_ITALIAN_KEYBOARD},
+      {"__MSG_JAPANESE_KEYBOARD__", IDS_IME_NAME_JAPANESE_KEYBOARD},
+      {"__MSG_KEYBOARD_ARABIC__", IDS_IME_NAME_KEYBOARD_ARABIC},
+      {"__MSG_KEYBOARD_BENGALI_PHONETIC__",
+       IDS_IME_NAME_KEYBOARD_BENGALI_PHONETIC},
+      {"__MSG_KEYBOARD_DEVANAGARI_PHONETIC__",
+       IDS_IME_NAME_KEYBOARD_DEVANAGARI_PHONETIC},
+      {"__MSG_KEYBOARD_ETHIOPIC__", IDS_IME_NAME_KEYBOARD_ETHIOPIC},
+      {"__MSG_KEYBOARD_GUJARATI_PHONETIC__",
+       IDS_IME_NAME_KEYBOARD_GUJARATI_PHONETIC},
+      {"__MSG_KEYBOARD_KANNADA_PHONETIC__",
+       IDS_IME_NAME_KEYBOARD_KANNADA_PHONETIC},
+      {"__MSG_KEYBOARD_KHMER__", IDS_IME_NAME_KEYBOARD_KHMER},
+      {"__MSG_KEYBOARD_LAO__", IDS_IME_NAME_KEYBOARD_LAO},
+      {"__MSG_KEYBOARD_MALAYALAM_PHONETIC__",
+       IDS_IME_NAME_KEYBOARD_MALAYALAM_PHONETIC},
+      {"__MSG_KEYBOARD_MYANMAR_MYANSAN__",
+       IDS_IME_NAME_KEYBOARD_MYANMAR_MYANSAN},
+      {"__MSG_KEYBOARD_MYANMAR__", IDS_IME_NAME_KEYBOARD_MYANMAR},
+      {"__MSG_KEYBOARD_NEPALI_INSCRIPT__",
+       IDS_IME_NAME_KEYBOARD_NEPALI_INSCRIPT},
+      {"__MSG_KEYBOARD_NEPALI_PHONETIC__",
+       IDS_IME_NAME_KEYBOARD_NEPALI_PHONETIC},
+      {"__MSG_KEYBOARD_PERSIAN__", IDS_IME_NAME_KEYBOARD_PERSIAN},
+      {"__MSG_KEYBOARD_SINHALA__", IDS_IME_NAME_KEYBOARD_SINHALA},
+      {"__MSG_KEYBOARD_SORANIKURDISH_AR__",
+       IDS_IME_NAME_KEYBOARD_SORANIKURDISH_AR},
+      {"__MSG_KEYBOARD_SORANIKURDISH_EN__",
+       IDS_IME_NAME_KEYBOARD_SORANIKURDISH_EN},
+      {"__MSG_KEYBOARD_TAMIL_INSCRIPT__", IDS_IME_NAME_KEYBOARD_TAMIL_INSCRIPT},
+      {"__MSG_KEYBOARD_TAMIL_ITRANS__", IDS_IME_NAME_KEYBOARD_TAMIL_ITRANS},
+      {"__MSG_KEYBOARD_TAMIL_PHONETIC__", IDS_IME_NAME_KEYBOARD_TAMIL_PHONETIC},
+      {"__MSG_KEYBOARD_TAMIL_TAMIL99__", IDS_IME_NAME_KEYBOARD_TAMIL_TAMIL99},
+      {"__MSG_KEYBOARD_TAMIL_TYPEWRITER__",
+       IDS_IME_NAME_KEYBOARD_TAMIL_TYPEWRITER},
+      {"__MSG_KEYBOARD_TELUGU_PHONETIC__",
+       IDS_IME_NAME_KEYBOARD_TELUGU_PHONETIC},
+      {"__MSG_KEYBOARD_THAI_KEDMANEE__", IDS_IME_NAME_KEYBOARD_THAI_KEDMANEE},
+      {"__MSG_KEYBOARD_THAI_PATTACHOTE__",
+       IDS_IME_NAME_KEYBOARD_THAI_PATTACHOTE},
+      {"__MSG_KEYBOARD_THAI_TIS__", IDS_IME_NAME_KEYBOARD_THAI_TIS},
+      {"__MSG_KEYBOARD_VIETNAMESE_TCVN__",
+       IDS_IME_NAME_KEYBOARD_VIETNAMESE_TCVN},
+      {"__MSG_KEYBOARD_VIETNAMESE_TELEX__",
+       IDS_IME_NAME_KEYBOARD_VIETNAMESE_TELEX},
+      {"__MSG_KEYBOARD_VIETNAMESE_VIQR__",
+       IDS_IME_NAME_KEYBOARD_VIETNAMESE_VIQR},
+      {"__MSG_KEYBOARD_VIETNAMESE_VNI__", IDS_IME_NAME_KEYBOARD_VIETNAMESE_VNI},
+      {"__MSG_LATIN_AMERICAN_KEYBOARD__", IDS_IME_NAME_LATIN_AMERICAN_KEYBOARD},
+      {"__MSG_LATVIAN_KEYBOARD__", IDS_IME_NAME_LATVIAN_KEYBOARD},
+      {"__MSG_LITHUANIAN_KEYBOARD__", IDS_IME_NAME_LITHUANIAN_KEYBOARD},
+      {"__MSG_MONGOLIAN_KEYBOARD__", IDS_IME_NAME_MONGOLIAN_KEYBOARD},
+      {"__MSG_MOZC_JP_INPUTMETHOD__", IDS_IME_NAME_MOZC_JP_INPUTMETHOD},
+      {"__MSG_MOZC_US_INPUTMETHOD__", IDS_IME_NAME_MOZC_US_INPUTMETHOD},
+      {"__MSG_NORWEGIAN_KEYBOARD__", IDS_IME_NAME_NORWEGIAN_KEYBOARD},
+      {"__MSG_PINYIN_INPUTMETHOD__", IDS_IME_NAME_PINYIN_INPUTMETHOD},
+      {"__MSG_POLISH_KEYBOARD__", IDS_IME_NAME_POLISH_KEYBOARD},
+      {"__MSG_PORTUGUESE_KEYBOARD__", IDS_IME_NAME_PORTUGUESE_KEYBOARD},
+      {"__MSG_QUICK_INPUTMETHOD__", IDS_IME_NAME_QUICK_INPUTMETHOD},
+      {"__MSG_ROMANIAN_KEYBOARD__", IDS_IME_NAME_ROMANIAN_KEYBOARD},
+      {"__MSG_RUSSIAN_KEYBOARD__", IDS_IME_NAME_RUSSIAN_KEYBOARD},
+      {"__MSG_RUSSIAN_PHONETIC_KEYBOARD__",
+       IDS_IME_NAME_RUSSIAN_PHONETIC_KEYBOARD},
+      {"__MSG_SERBIAN_KEYBOARD__", IDS_IME_NAME_SERBIAN_KEYBOARD},
+      {"__MSG_SLOVAKIAN_KEYBOARD__", IDS_IME_NAME_SLOVAKIAN_KEYBOARD},
+      {"__MSG_SLOVENIAN_KEYBOARD__", IDS_IME_NAME_SLOVENIAN_KEYBOARD},
+      {"__MSG_SPANISH_KEYBOARD__", IDS_IME_NAME_SPANISH_KEYBOARD},
+      {"__MSG_SWEDISH_KEYBOARD__", IDS_IME_NAME_SWEDISH_KEYBOARD},
+      {"__MSG_SWISS_FRENCH_KEYBOARD__", IDS_IME_NAME_SWISS_FRENCH_KEYBOARD},
+      {"__MSG_SWISS_KEYBOARD__", IDS_IME_NAME_SWISS_KEYBOARD},
+      {"__MSG_TRADITIONAL_PINYIN_INPUTMETHOD__",
+       IDS_IME_NAME_TRADITIONAL_PINYIN_INPUTMETHOD},
+      {"__MSG_TRANSLITERATION_AM__", IDS_IME_NAME_TRANSLITERATION_AM},
+      {"__MSG_TRANSLITERATION_AR__", IDS_IME_NAME_TRANSLITERATION_AR},
+      {"__MSG_TRANSLITERATION_BN__", IDS_IME_NAME_TRANSLITERATION_BN},
+      {"__MSG_TRANSLITERATION_EL__", IDS_IME_NAME_TRANSLITERATION_EL},
+      {"__MSG_TRANSLITERATION_FA__", IDS_IME_NAME_TRANSLITERATION_FA},
+      {"__MSG_TRANSLITERATION_GU__", IDS_IME_NAME_TRANSLITERATION_GU},
+      {"__MSG_TRANSLITERATION_HE__", IDS_IME_NAME_TRANSLITERATION_HE},
+      {"__MSG_TRANSLITERATION_HI__", IDS_IME_NAME_TRANSLITERATION_HI},
+      {"__MSG_TRANSLITERATION_KN__", IDS_IME_NAME_TRANSLITERATION_KN},
+      {"__MSG_TRANSLITERATION_ML__", IDS_IME_NAME_TRANSLITERATION_ML},
+      {"__MSG_TRANSLITERATION_MR__", IDS_IME_NAME_TRANSLITERATION_MR},
+      {"__MSG_TRANSLITERATION_NE__", IDS_IME_NAME_TRANSLITERATION_NE},
+      {"__MSG_TRANSLITERATION_OR__", IDS_IME_NAME_TRANSLITERATION_OR},
+      {"__MSG_TRANSLITERATION_PA__", IDS_IME_NAME_TRANSLITERATION_PA},
+      {"__MSG_TRANSLITERATION_SA__", IDS_IME_NAME_TRANSLITERATION_SA},
+      {"__MSG_TRANSLITERATION_SR__", IDS_IME_NAME_TRANSLITERATION_SR},
+      {"__MSG_TRANSLITERATION_TA__", IDS_IME_NAME_TRANSLITERATION_TA},
+      {"__MSG_TRANSLITERATION_TE__", IDS_IME_NAME_TRANSLITERATION_TE},
+      {"__MSG_TRANSLITERATION_TI__", IDS_IME_NAME_TRANSLITERATION_TI},
+      {"__MSG_TRANSLITERATION_UR__", IDS_IME_NAME_TRANSLITERATION_UR},
+      {"__MSG_TURKISH_KEYBOARD__", IDS_IME_NAME_TURKISH_KEYBOARD},
+      {"__MSG_UKRAINIAN_KEYBOARD__", IDS_IME_NAME_UKRAINIAN_KEYBOARD},
+      {"__MSG_UK_DVORAK_KEYBOARD__", IDS_IME_NAME_UK_DVORAK_KEYBOARD},
+      {"__MSG_UK_KEYBOARD__", IDS_IME_NAME_UK_KEYBOARD},
+      {"__MSG_US_COLEMAK_KEYBOARD__", IDS_IME_NAME_US_COLEMAK_KEYBOARD},
+      {"__MSG_US_DVORAK_KEYBOARD__", IDS_IME_NAME_US_DVORAK_KEYBOARD},
+      {"__MSG_US_EXTENDED_KEYBOARD__", IDS_IME_NAME_US_EXTENDED_KEYBOARD},
+      {"__MSG_US_INTERNATIONAL_KEYBOARD__",
+       IDS_IME_NAME_US_INTERNATIONAL_KEYBOARD},
+      {"__MSG_US_KEYBOARD__", IDS_IME_NAME_US_KEYBOARD},
+      {"__MSG_WUBI_INPUTMETHOD__", IDS_IME_NAME_WUBI_INPUTMETHOD},
+      {"__MSG_ZHUYIN_INPUTMETHOD__", IDS_IME_NAME_ZHUYIN_INPUTMETHOD},
+};
+
+const char* kImePathKeyName = "ime_path";
+
 extensions::ComponentLoader* GetComponentLoader() {
   // TODO(skuhne, nkostylev): At this time the only thing which makes sense here
   // is to use the active profile. Nkostylev is working on getting IME settings
   // to work for multi user by collecting all settings from all users. Once that
   // is done we might have to re-visit this decision.
   Profile* profile = ProfileManager::GetActiveUserProfile();
   extensions::ExtensionSystem* extension_system =
       extensions::ExtensionSystem::Get(profile);
   ExtensionService* extension_service = extension_system->extension_service();
   return extension_service->component_loader();
 }
 }  // namespace
 
 ComponentExtensionIMEManagerImpl::ComponentExtensionIMEManagerImpl()
-    : is_initialized_(false),
-      weak_ptr_factory_(this) {
+    : weak_ptr_factory_(this) {
+  ReadComponentExtensionsInfo(&component_extension_list_);
 }
 
 ComponentExtensionIMEManagerImpl::~ComponentExtensionIMEManagerImpl() {
 }
 
 std::vector<ComponentExtensionIME> ComponentExtensionIMEManagerImpl::ListIME() {
-  DCHECK(thread_checker_.CalledOnValidThread());
   return component_extension_list_;
 }
 
 bool ComponentExtensionIMEManagerImpl::Load(const std::string& extension_id,
                                             const std::string& manifest,
                                             const base::FilePath& file_path) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!base::PathExists(file_path))
+    return false;
+
   Profile* profile = ProfileManager::GetActiveUserProfile();
   extensions::ExtensionSystem* extension_system =
       extensions::ExtensionSystem::Get(profile);
   ExtensionService* extension_service = extension_system->extension_service();
   if (extension_service->GetExtensionById(extension_id, false))
     return false;
   const std::string loaded_extension_id =
       GetComponentLoader()->Add(manifest, file_path);
   DCHECK_EQ(loaded_extension_id, extension_id);
   return true;
 }
 
 void ComponentExtensionIMEManagerImpl::Unload(const std::string& extension_id,
                                               const base::FilePath& file_path) {
-  DCHECK(thread_checker_.CalledOnValidThread());
   // Remove(extension_id) does nothing when the extension has already been
   // removed or not been registered.
   GetComponentLoader()->Remove(extension_id);
 }
 
 scoped_ptr<base::DictionaryValue> ComponentExtensionIMEManagerImpl::GetManifest(
-    const base::FilePath& file_path) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+    const std::string& manifest_string) {
   std::string error;
-  scoped_ptr<base::DictionaryValue> manifest(
-      extensions::file_util::LoadManifest(file_path, &error));
+  JSONStringValueSerializer serializer(manifest_string);
+  scoped_ptr<base::Value> manifest(serializer.Deserialize(NULL, &error));
   if (!manifest.get())
     LOG(ERROR) << "Failed at getting manifest";
-  if (!extension_l10n_util::LocalizeExtension(file_path,
-                                              manifest.get(),
-                                              &error))
-    LOG(ERROR) << "Localization failed";
+  if (!manifest->IsType(base::Value::TYPE_DICTIONARY))
+    LOG(ERROR) << "Invalid manifest format";
 
-  return manifest.Pass();
-}
-
-void ComponentExtensionIMEManagerImpl::InitializeAsync(
-    const base::Closure& callback) {
-  DCHECK(!is_initialized_);
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  std::vector<ComponentExtensionIME>* component_extension_ime_list
-      = new std::vector<ComponentExtensionIME>;
-  content::BrowserThread::PostTaskAndReply(
-      content::BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(&ComponentExtensionIMEManagerImpl::ReadComponentExtensionsInfo,
-                 base::Unretained(component_extension_ime_list)),
-      base::Bind(
-          &ComponentExtensionIMEManagerImpl::OnReadComponentExtensionsInfo,
-          weak_ptr_factory_.GetWeakPtr(),
-          base::Owned(component_extension_ime_list),
-          callback));
-}
-
-bool ComponentExtensionIMEManagerImpl::IsInitialized() {
-  return is_initialized_;
+  return scoped_ptr<base::DictionaryValue>(
+             static_cast<base::DictionaryValue*>(manifest.release())).Pass();
 }
 
 // static
 bool ComponentExtensionIMEManagerImpl::ReadEngineComponent(
     const ComponentExtensionIME& component_extension,
     const base::DictionaryValue& dict,
     ComponentExtensionEngine* out) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
   DCHECK(out);
   std::string type;
   if (!dict.GetString(extensions::manifest_keys::kType, &type))
     return false;
   if (type != "ime")
     return false;
   if (!dict.GetString(extensions::manifest_keys::kId, &out->engine_id))
     return false;
   if (!dict.GetString(extensions::manifest_keys::kName, &out->display_name))
     return false;
 
+  // Localizes the input method name.
+  if (out->display_name.find("__MSG_") == 0) {
+    const InputMethodNameMap* map = kInputMethodNameMap;
+    size_t map_size = arraysize(kInputMethodNameMap);
+    std::string name = StringToUpperASCII(out->display_name);
+    const InputMethodNameMap map_key = {name.c_str(), 0};
+    const InputMethodNameMap* p =
+        std::lower_bound(map, map + map_size, map_key, map_key);
+    if (p != map + map_size && !map_key(*p, map_key) && !map_key(map_key, *p))
+      out->display_name = l10n_util::GetStringUTF8(p->resource_id);

[nona, 2014/07/14 10:02:47]

nit: How about adding DCHECK for preventing shipping un-translated strings?

[Shu Chen, 2014/07/14 15:07:21]

Done.

+  }
+
   std::set<std::string> languages;
   const base::Value* language_value = NULL;
   if (dict.Get(extensions::manifest_keys::kLanguage, &language_value)) {
     if (language_value->GetType() == base::Value::TYPE_STRING) {
       std::string language_str;
       language_value->GetAsString(&language_str);
       languages.insert(language_str);
     } else if (language_value->GetType() == base::Value::TYPE_LIST) {
       const base::ListValue* language_list = NULL;
       language_value->GetAsList(&language_list);
@@ skipping 44 matching lines @@
   }
 
   return true;
 }
 
 // static
 bool ComponentExtensionIMEManagerImpl::ReadExtensionInfo(
     const base::DictionaryValue& manifest,
     const std::string& extension_id,
     ComponentExtensionIME* out) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
   if (!manifest.GetString(extensions::manifest_keys::kDescription,
                           &out->description))
     return false;
+  std::string path;
+  if (manifest.GetString(kImePathKeyName, &path))
+    out->path = base::FilePath(path);
   std::string url_string;
   if (manifest.GetString(extensions::manifest_keys::kOptionsPage,
                          &url_string)) {
     GURL url = extensions::Extension::GetResourceURL(
         extensions::Extension::GetBaseURLFromExtensionId(extension_id),
         url_string);
     if (!url.is_valid())
       return false;
     out->options_page_url = url;
   }
   // It's okay to return true on no option page and/or input view page case.
   return true;
 }
 
 // static
 void ComponentExtensionIMEManagerImpl::ReadComponentExtensionsInfo(
     std::vector<ComponentExtensionIME>* out_imes) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
   DCHECK(out_imes);
   for (size_t i = 0; i < arraysize(whitelisted_component_extension); ++i) {
     ComponentExtensionIME component_ime;
-    component_ime.path = base::FilePath(
-        whitelisted_component_extension[i].path);
-
-    if (!component_ime.path.IsAbsolute()) {
-      base::FilePath resources_path;
-      if (!PathService::Get(chrome::DIR_RESOURCES, &resources_path))
-        NOTREACHED();
-      component_ime.path = resources_path.Append(component_ime.path);
-    }
-    const base::FilePath manifest_path =
-        component_ime.path.Append("manifest.json");
-
-    if (!base::PathExists(component_ime.path) ||
-        !base::PathExists(manifest_path))
-      continue;
-
-    if (!base::ReadFileToString(manifest_path, &component_ime.manifest))
+    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+    component_ime.manifest =
+        rb.GetRawDataResource(
+               whitelisted_component_extension[i].manifest_resource_id)
+            .as_string();
+    if (component_ime.manifest.empty())
       continue;
 
     scoped_ptr<base::DictionaryValue> manifest =
-        GetManifest(component_ime.path);
+        GetManifest(component_ime.manifest);
     if (!manifest.get())
       continue;
 
     if (!ReadExtensionInfo(*manifest.get(),
                            whitelisted_component_extension[i].id,
                            &component_ime))
       continue;
     component_ime.id = whitelisted_component_extension[i].id;
 
+    if (!component_ime.path.IsAbsolute()) {
+      base::FilePath resources_path;
+      if (!PathService::Get(chrome::DIR_RESOURCES, &resources_path))
+        NOTREACHED();
+      component_ime.path = resources_path.Append(component_ime.path);
+    }
+
     const base::ListValue* component_list;
     if (!manifest->GetList(extensions::manifest_keys::kInputComponents,
                            &component_list))
       continue;
 
     for (size_t i = 0; i < component_list->GetSize(); ++i) {
       const base::DictionaryValue* dictionary;
       if (!component_list->GetDictionary(i, &dictionary))
         continue;
 
       ComponentExtensionEngine engine;
       ReadEngineComponent(component_ime, *dictionary, &engine);
       component_ime.engines.push_back(engine);
     }
     out_imes->push_back(component_ime);
   }
 }
 
-void ComponentExtensionIMEManagerImpl::OnReadComponentExtensionsInfo(
-    std::vector<ComponentExtensionIME>* result,
-    const base::Closure& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(result);
-  component_extension_list_ = *result;
-  is_initialized_ = true;
-  callback.Run();
-}
-
 }  // namespace chromeos