Remove redundant "keyboard layout" suffix and fix redundant language display.

chrome/browser/chromeos/status/language_menu_button.cc

 // Copyright (c) 2010 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/language_menu_button.h"
 
 #include <string>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
@@ skipping 303 matching lines @@
   DCHECK(input_method_descriptors_.get());
 
   // We use IDS_OPTIONS_SETTINGS_LANGUAGES_CUSTOMIZE here as the button
   // opens the same dialog that is opened from the main options dialog.
   if (IndexPointsToConfigureImeMenuItem(index)) {
     return l10n_util::GetStringUTF16(IDS_OPTIONS_SETTINGS_LANGUAGES_CUSTOMIZE);
   }
 
   std::wstring name;
   if (IndexIsInInputMethodList(index)) {
-    const std::string language_code =
-        input_method::GetLanguageCodeFromDescriptor(
-            input_method_descriptors_->at(index));
-    const bool need_method_name =
-        (ambiguous_language_code_set_.count(language_code) > 0);
-    name = GetTextForMenu(input_method_descriptors_->at(index),
-                          need_method_name);
+    name = GetTextForMenu(input_method_descriptors_->at(index));
   } else if (GetPropertyIndex(index, &index)) {
     const ImePropertyList& property_list
         = CrosLibrary::Get()->GetInputMethodLibrary()->current_ime_properties();
     return input_method::GetStringUTF16(property_list.at(index).label);
   }
 
   return WideToUTF16(name);
 }
 
 void LanguageMenuButton::ActivatedAt(int index) {
@@ skipping 145 matching lines @@
     SetEnabled(true);
     SetTooltipText(tooltip);
   }
   SetText(name);
   SchedulePaint();
 }
 
 void LanguageMenuButton::UpdateIndicatorFromInputMethod(
     const InputMethodDescriptor& input_method) {
   const std::wstring name = GetTextForIndicator(input_method);
-  const std::wstring tooltip =
-      GetTextForMenu(input_method, true /* add_method_name */);
+  const std::wstring tooltip = GetTextForMenu(input_method);
   UpdateIndicator(name, tooltip);
 }
 
 void LanguageMenuButton::RebuildModel() {
   model_.reset(new menus::SimpleMenuModel(NULL));
   string16 dummy_label = UTF8ToUTF16("");
   // Indicates if separator's needed before each section.
   bool need_separator = false;
 
-  ambiguous_language_code_set_.clear();
   if (!input_method_descriptors_->empty()) {
     // We "abuse" the command_id and group_id arguments of AddRadioItem method.
     // A COMMAND_ID_XXX enum value is passed as command_id, and array index of
     // |input_method_descriptors_| or |property_list| is passed as group_id.
     for (size_t i = 0; i < input_method_descriptors_->size(); ++i) {
       model_->AddRadioItem(COMMAND_ID_INPUT_METHODS, dummy_label, i);
     }
 
-    GetAmbiguousLanguageCodeSet(*input_method_descriptors_,
-                                &ambiguous_language_code_set_);
     need_separator = true;
   }
 
   const ImePropertyList& property_list
       = CrosLibrary::Get()->GetInputMethodLibrary()->current_ime_properties();
   if (!property_list.empty()) {
     if (need_separator)
       model_->AddSeparator();
     for (size_t i = 0; i < property_list.size(); ++i) {
       model_->AddRadioItem(COMMAND_ID_IME_PROPERTIES, dummy_label, i);
@@ skipping 102 matching lines @@
     }
 
     text = StringToUpperASCII(UTF8ToWide(language_code)).substr(
         0, kMaxLanguageNameLen);
   }
   DCHECK(!text.empty());
   return text;
 }
 
 std::wstring LanguageMenuButton::GetTextForMenu(
-    const InputMethodDescriptor& input_method, bool add_method_name) {
+    const InputMethodDescriptor& input_method) {
+  // We don't show language here.  Name of keyboard layout or input method
+  // usually imply (or explicitly include) its language.
+
+  // Special case for Dutch, French and German: these languages have multiple
+  // keyboard layouts and share the same laout of keyboard (Belgian). We need to
+  // show explicitly the language for the layout.
+  // For Arabic, Hebrew and Hindi: they share "Standard Input Method".
   const std::string language_code
       = input_method::GetLanguageCodeFromDescriptor(input_method);
+  std::wstring text;
+  if (language_code == "ar" ||
+      language_code == "he" ||
+      language_code == "hi" ||
+      language_code == "nl" ||
+      language_code == "fr" ||
+      language_code == "de") {
+    text = GetLanguageName(language_code) + L" - ";
+  }
+  text += input_method::GetString(input_method.display_name);
 
-  // For the drop-down menu and tooltip, we'll show language names like
-  // "Chinese (Simplified)" and "Japanese", instead of input method names
-  // like "Pinyin" and "Mozc".
-  std::wstring text = GetLanguageName(language_code);
-  if (add_method_name) {
-    text += L" - ";
-    text += input_method::GetString(input_method.display_name);
-  }
   DCHECK(!text.empty());
   return text;
 }
 
 void LanguageMenuButton::RegisterPrefs(PrefService* local_state) {
   local_state->RegisterStringPref(language_prefs::kPreferredKeyboardLayout,
                                   "");
 }
 
-void LanguageMenuButton::GetAmbiguousLanguageCodeSet(
-    const InputMethodDescriptors& input_method_descriptors,
-    std::set<std::string>* ambiguous_language_code_set) {
-  DCHECK(ambiguous_language_code_set);
-  ambiguous_language_code_set->clear();
-
-  std::set<std::string> languages_seen;
-  for (size_t i = 0; i < input_method_descriptors.size(); ++i) {
-    const std::string language_code
-        = input_method::GetLanguageCodeFromDescriptor(
-            input_method_descriptors.at(i));
-    // If there is more than one input method for this language, then we need
-    // to display the method name.
-    if (languages_seen.count(language_code) > 0 ||
-        // Special-case Japanese as showing the language name alone is
-        // confusing when Japanese keyboard is enabled but Japanese
-        // input methods are not.
-        language_code == "ja") {
-      ambiguous_language_code_set->insert(language_code);
-    } else {
-      languages_seen.insert(language_code);
-    }
-  }
-}
-
 void LanguageMenuButton::Observe(NotificationType type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
   if (type == NotificationType::LOGIN_USER_CHANGED) {
     logged_in_ = true;
   }
 }
 
 }  // namespace chromeos