Get the ProfileService object after NOTIFICATION_SESSION_STARTED is sent to Chrome

chrome/browser/chromeos/status/input_method_menu.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/chromeos/status/input_method_menu.h"
 
 #include <string>
 #include <vector>
 
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
 #include "chrome/browser/chromeos/language_preferences.h"
 #include "chrome/browser/chromeos/status/status_area_view_chromeos.h"
 #include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/views/controls/menu/menu_model_adapter.h"
@@ skipping 89 matching lines @@
 const size_t kMappingFromIdToIndicatorTextLen =
     ARRAYSIZE_UNSAFE(kMappingFromIdToIndicatorText);
 
 // Returns the language name for the given |language_code|.
 string16 GetLanguageName(const std::string& language_code) {
   const string16 language_name = l10n_util::GetDisplayNameForLocale(
       language_code, g_browser_process->GetApplicationLocale(), true);
   return language_name;
 }
 
+PrefService* GetPrefService() {
+  Profile* profile = ProfileManager::GetDefaultProfile();
+  if (profile)
+    return profile->GetPrefs();
+  return NULL;
+}
+
 }  // namespace
 
 namespace chromeos {
 
 using input_method::InputMethodManager;
 
 ////////////////////////////////////////////////////////////////////////////////
 // InputMethodMenu
 
-InputMethodMenu::InputMethodMenu(PrefService* pref_service,
-                                 bool for_out_of_box_experience_dialog)
+InputMethodMenu::InputMethodMenu()
     : initialized_prefs_(false),
       initialized_observers_(false),
       input_method_descriptors_(InputMethodManager::GetInstance()->
                                 GetActiveInputMethods()),
       model_(new ui::SimpleMenuModel(NULL)),
       ALLOW_THIS_IN_INITIALIZER_LIST(input_method_menu_delegate_(
           new views::MenuModelAdapter(this))),
       input_method_menu_(
           new views::MenuItemView(input_method_menu_delegate_.get())),
       input_method_menu_runner_(new views::MenuRunner(input_method_menu_)),
       minimum_input_method_menu_width_(0),
-      menu_alignment_(views::MenuItemView::TOPRIGHT),
-      pref_service_(pref_service),
-      for_out_of_box_experience_dialog_(for_out_of_box_experience_dialog) {
+      menu_alignment_(views::MenuItemView::TOPRIGHT) {
   DCHECK(input_method_descriptors_.get() &&
          !input_method_descriptors_->empty());
 
   // Sync current and previous input methods on Chrome prefs with ibus-daemon.
-  if (pref_service_ && StatusAreaViewChromeos::IsBrowserMode()) {
+  if (StatusAreaViewChromeos::IsBrowserMode())
     InitializePrefMembers();
-  }
 
   if (StatusAreaViewChromeos::IsLoginMode()) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_LOGIN_USER_CHANGED,
                    content::NotificationService::AllSources());
 #if defined(USE_AURA)
     // On Aura status area is not recreated on sign in. Instead, 2 notifications
     // are sent to Chrome on sign in: NOTIFICATION_LOGIN_USER_CHANGED with
     // StatusAreaViewChromeos::IsLoginMode() and NOTIFICATION_SESSION_STARTED
     // with StatusAreaViewChromeos::IsBrowserMode().
@@ skipping 49 matching lines @@
     return property_list.at(index).is_selection_item_checked;
   }
 
   // Separator(s) or the "Customize language and input..." button.
   return false;
 }
 
 int InputMethodMenu::GetGroupIdAt(int index) const {
   DCHECK_GE(index, 0);
 
-  if (IndexIsInInputMethodList(index)) {
-    return for_out_of_box_experience_dialog_ ?
-        kRadioGroupNone : kRadioGroupLanguage;
-  }
+  if (IndexIsInInputMethodList(index))
+    return kRadioGroupLanguage;
 
   if (GetPropertyIndex(index, &index)) {
     const input_method::InputMethodPropertyList& property_list
         = InputMethodManager::GetInstance()->GetCurrentInputMethodProperties();
     return property_list.at(index).selection_item_id;
   }
 
   return kRadioGroupNone;
 }
 
@@ skipping 43 matching lines @@
   return model_->GetItemCount();
 }
 
 ui::MenuModel::ItemType InputMethodMenu::GetTypeAt(int index) const {
   DCHECK_GE(index, 0);
 
   if (IndexPointsToConfigureImeMenuItem(index)) {
     return ui::MenuModel::TYPE_COMMAND;  // "Customize language and input"
   }
 
-  if (IndexIsInInputMethodList(index)) {
-    return for_out_of_box_experience_dialog_ ?
-        ui::MenuModel::TYPE_COMMAND : ui::MenuModel::TYPE_RADIO;
-  }
+  if (IndexIsInInputMethodList(index))
+    return ui::MenuModel::TYPE_RADIO;
 
   if (GetPropertyIndex(index, &index)) {
     const input_method::InputMethodPropertyList& property_list
         = InputMethodManager::GetInstance()->GetCurrentInputMethodProperties();
     if (property_list.at(index).is_selection_item) {
       return ui::MenuModel::TYPE_RADIO;
     }
     return ui::MenuModel::TYPE_COMMAND;
   }
 
@@ skipping 105 matching lines @@
     size_t num_active_input_methods) {
   UpdateUIFromInputMethod(current_input_method, num_active_input_methods);
 }
 
 // TODO(yusukes): Move code for handling preferences to chromeos/input_method/.
 void InputMethodMenu::PreferenceUpdateNeeded(
     InputMethodManager* manager,
     const input_method::InputMethodDescriptor& previous_input_method,
     const input_method::InputMethodDescriptor& current_input_method) {
   if (StatusAreaViewChromeos::IsBrowserMode()) {
-    if (pref_service_) {  // make sure we're not in unit tests.
+    if (initialized_prefs_) {  // make sure we're not in unit tests.
       // Sometimes (e.g. initial boot) |previous_input_method.id()| is empty.
       previous_input_method_pref_.SetValue(previous_input_method.id());
       current_input_method_pref_.SetValue(current_input_method.id());
     }
   } else if (StatusAreaViewChromeos::IsLoginMode()) {
     if (g_browser_process && g_browser_process->local_state()) {
       g_browser_process->local_state()->SetString(
           language_prefs::kPreferredKeyboardLayout, current_input_method.id());
     }
   }
@@ skipping 19 matching lines @@
         manager->GetCurrentInputMethod();
     size_t num_active_input_methods = manager->GetNumActiveInputMethods();
     UpdateUIFromInputMethod(input_method, num_active_input_methods);
   }
 }
 
 void InputMethodMenu::FirstObserverIsAdded(InputMethodManager* manager) {
   // NOTICE: Since this function might be called from the constructor of this
   // class, it's better to avoid calling virtual functions.
 
-  if (pref_service_ && (StatusAreaViewChromeos::IsBrowserMode())) {
+  if (initialized_prefs_ && StatusAreaViewChromeos::IsBrowserMode()) {
     // Get the input method name in the Preferences file which was in use last
     // time, and switch to the method. We remember two input method names in the
     // preference so that the Control+space hot-key could work fine from the
     // beginning. InputMethodChanged() will be called soon and the indicator
     // will be updated.
     const std::string previous_input_method_id =
         previous_input_method_pref_.GetValue();
     if (!previous_input_method_id.empty()) {
       manager->ChangeInputMethod(previous_input_method_id);
     }
@@ skipping 259 matching lines @@
     manager->RemovePreLoginPreferenceObserver(this);
   } else if (StatusAreaViewChromeos::IsBrowserMode()) {
     manager->RemovePostLoginPreferenceObserver(this);
   }
   manager->RemoveObserver(this);
   initialized_observers_ = false;
 }
 
 void InputMethodMenu::InitializePrefMembers() {
   if (!initialized_prefs_) {
-    initialized_prefs_ = true;
-    previous_input_method_pref_.Init(
-        prefs::kLanguagePreviousInputMethod, pref_service_, this);
-    current_input_method_pref_.Init(
-        prefs::kLanguageCurrentInputMethod, pref_service_, this);
+    PrefService* pref_service = GetPrefService();
+    if (pref_service) {
+      initialized_prefs_ = true;
+      previous_input_method_pref_.Init(
+          prefs::kLanguagePreviousInputMethod, pref_service, this);
+      current_input_method_pref_.Init(
+          prefs::kLanguageCurrentInputMethod, pref_service, this);
+    }
   }
 }
 
 }  // namespace chromeos