GetActiveUserProfile() should not be called before profile is initialized.

chrome/browser/extensions/api/input_ime/input_ime_api.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/browser/extensions/api/input_ime/input_ime_api.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/ui/user_adding_screen.h"
@@ skipping 331 matching lines @@
 }  // namespace chromeos
 
 namespace extensions {
 
 InputImeEventRouter*
 InputImeEventRouter::GetInstance() {
   return Singleton<InputImeEventRouter>::get();
 }
 
 bool InputImeEventRouter::RegisterIme(
+    Profile* profile,
     const std::string& extension_id,
     const extensions::InputComponentInfo& component) {
 #if defined(USE_X11)
   VLOG(1) << "RegisterIme: " << extension_id << " id: " << component.id;
 
-  Profile* profile = ProfileManager::GetActiveUserProfile();
   // Avoid potential mem leaks due to duplicated component IDs.
   if (!profile_engine_map_[profile][extension_id][component.id]) {
     std::vector<std::string> layouts;
     layouts.assign(component.layouts.begin(), component.layouts.end());
 
     std::vector<std::string> languages;
     languages.assign(component.languages.begin(), component.languages.end());
 
     // Ideally Observer should be per (extension_id + Profile), and multiple
     // InputMethodEngine can share one Observer. But it would become tricky
     // to maintain an internal map for observers which does nearly nothing
     // but just make sure they can properly deleted.
     // Making Obesrver per InputMethodEngine can make things cleaner.
     scoped_ptr<chromeos::InputMethodEngineInterface::Observer> observer(
         new chromeos::ImeObserver(profile, extension_id));
     chromeos::InputMethodEngine* engine = new chromeos::InputMethodEngine();
-    engine->Initialize(observer.Pass(),
+    engine->Initialize(profile,
+                       observer.Pass(),
                        component.name.c_str(),
                        extension_id.c_str(),
                        component.id.c_str(),
                        languages,
                        layouts,
                        component.options_page_url,
                        component.input_view_url);
     profile_engine_map_[profile][extension_id][component.id] = engine;
   }
 
@@ skipping 462 matching lines @@
                                     const Extension* extension) {
   const std::vector<InputComponentInfo>* input_components =
       extensions::InputComponents::GetInputComponents(extension);
   if (!input_components)
     return;
   for (std::vector<extensions::InputComponentInfo>::const_iterator component =
            input_components->begin();
        component != input_components->end();
        ++component) {
     if (component->type == extensions::INPUT_COMPONENT_TYPE_IME) {
-      // Don't pass profile_ to register ime, instead always use
-      // GetActiveUserProfile. It is because:
-      // The original profile for login screen is called signin profile.
-      // And the active profile is the incognito profile based on signin
-      // profile. So if |profile_| is signin profile, we need to make sure
+      // If |browser_context| looks like signin profile, use the real signin
+      // profile. This is because IME extensions for signin profile are run
+      // in Off-The-Record profile, based on given static defaults.
+      // So if |profile_| is signin profile, we need to make sure
       // the router/observer runs under its incognito profile, because the
       // component extensions were installed under its incognito profile.
-      input_ime_event_router()->RegisterIme(extension->id(), *component);
+      Profile* profile = Profile::FromBrowserContext(browser_context);
+      if (chromeos::ProfileHelper::IsSigninProfile(profile))
+        profile = chromeos::ProfileHelper::GetSigninProfile();
+      input_ime_event_router()->RegisterIme(
+          profile, extension->id(), *component);
     }
   }
 }
 
 void InputImeAPI::OnExtensionUnloaded(content::BrowserContext* browser_context,
                                       const Extension* extension,
                                       UnloadedExtensionInfo::Reason reason) {
   const std::vector<InputComponentInfo>* input_components =
       extensions::InputComponents::GetInputComponents(extension);
   if (!input_components)
     return;
   if (input_components->size() > 0)
     input_ime_event_router()->UnregisterAllImes(extension->id());
 }
 
 void InputImeAPI::OnListenerAdded(const EventListenerInfo& details) {
   InputMethodEngineInterface* engine =
       input_ime_event_router()->GetActiveEngine(details.extension_id);
   if (engine)
     engine->NotifyImeReady();
 }
 
 InputImeEventRouter* InputImeAPI::input_ime_event_router() {
   return InputImeEventRouter::GetInstance();
 }
 
 }  // namespace extensions