IME refactoring: ChromeOS introduce input methods State.

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"
@@ skipping 210 matching lines @@
       {"__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},
 };
 
 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::ComponentLoader* GetComponentLoader(Profile* profile) {
   extensions::ExtensionSystem* extension_system =
       extensions::ExtensionSystem::Get(profile);
   ExtensionService* extension_service = extension_system->extension_service();
   return extension_service->component_loader();
 }
 }  // namespace
 
 ComponentExtensionIMEManagerImpl::ComponentExtensionIMEManagerImpl()
     : weak_ptr_factory_(this) {
   ReadComponentExtensionsInfo(&component_extension_list_);
 }
 
 ComponentExtensionIMEManagerImpl::~ComponentExtensionIMEManagerImpl() {
 }
 
 std::vector<ComponentExtensionIME> ComponentExtensionIMEManagerImpl::ListIME() {
   return component_extension_list_;
 }
 
-bool ComponentExtensionIMEManagerImpl::Load(const std::string& extension_id,
+bool ComponentExtensionIMEManagerImpl::Load(Profile* profile,
+                                            const std::string& extension_id,
                                             const std::string& manifest,
                                             const base::FilePath& file_path) {
   // If current environment is linux_chromeos, there should be no file path for
   // the component extensions, so avoid loading them.
   // The tests are also running on linux_chromeos environment. No test should
   // run with the real component extensions because the component extension
   // contents are not in chromium code base. They're installed through ebuild
   // scripts from chromeos.
   if (!base::SysInfo::IsRunningOnChromeOS())
     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);
+      GetComponentLoader(profile)->Add(manifest, file_path);
   DCHECK_EQ(loaded_extension_id, extension_id);
   return true;
 }
 
-void ComponentExtensionIMEManagerImpl::Unload(const std::string& extension_id,
+void ComponentExtensionIMEManagerImpl::Unload(Profile* profile,
+                                              const std::string& extension_id,
                                               const base::FilePath& file_path) {
   // Remove(extension_id) does nothing when the extension has already been
   // removed or not been registered.
-  GetComponentLoader()->Remove(extension_id);
+  GetComponentLoader(profile)->Remove(extension_id);
 }
 
 scoped_ptr<base::DictionaryValue> ComponentExtensionIMEManagerImpl::GetManifest(
     const std::string& manifest_string) {
   std::string error;
   JSONStringValueSerializer serializer(manifest_string);
   scoped_ptr<base::Value> manifest(serializer.Deserialize(NULL, &error));
   if (!manifest.get())
     LOG(ERROR) << "Failed at getting manifest";
 
@@ skipping 158 matching lines @@
 
       ComponentExtensionEngine engine;
       ReadEngineComponent(component_ime, *dictionary, &engine);
       component_ime.engines.push_back(engine);
     }
     out_imes->push_back(component_ime);
   }
 }
 
 }  // namespace chromeos