[IME] InputMethodUtil should cache the hardware layouts from VPD, instead of the filtered hardware …

chrome/browser/chromeos/input_method/input_method_util.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/input_method/input_method_util.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <utility>
@@ skipping 507 matching lines @@
         input_method.id()) {
       return delegate_->GetLocalizedString(
           kMappingImeIdToMediumLenNameResourceId[i].resource_id);
     }
   }
   return GetInputMethodShortName(input_method);
 }
 
 base::string16 InputMethodUtil::GetInputMethodLongName(
     const InputMethodDescriptor& input_method) const {
-  if (!input_method.name().empty()) {
+  if (!input_method.name().empty() && !IsKeyboardLayout(input_method.id())) {
     // If the descriptor has a name, use it.
     return base::UTF8ToUTF16(input_method.name());
   }
 
   // We don't show language here.  Name of keyboard layout or input method
   // usually imply (or explicitly include) its language.
 
   // Special case for German, French and Dutch: these languages have multiple
   // keyboard layouts and share the same layout of keyboard (Belgian). We need
   // to show explicitly the language for the layout. For Arabic, Amharic, and
@@ skipping 198 matching lines @@
     }
     ids.swap(new_ids);
   }
   return rewritten;
 }
 
 void InputMethodUtil::UpdateHardwareLayoutCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   hardware_layouts_.clear();
   hardware_login_layouts_.clear();
-  Tokenize(delegate_->GetHardwareKeyboardLayouts(), ",", &hardware_layouts_);
+  if (cached_hardware_layouts_.empty())
+    Tokenize(delegate_->GetHardwareKeyboardLayouts(), ",",
+             &cached_hardware_layouts_);
+  hardware_layouts_ = cached_hardware_layouts_;
   MigrateXkbInputMethods(&hardware_layouts_);
 
   for (size_t i = 0; i < hardware_layouts_.size(); ++i) {
     if (IsLoginKeyboard(hardware_layouts_[i]))
       hardware_login_layouts_.push_back(hardware_layouts_[i]);
   }
   if (hardware_layouts_.empty()) {
     // This is totally fine if it's empty. The hardware keyboard layout is
     // not stored if startup_manifest.json (OEM customization data) is not
     // present (ex. Cr48 doen't have that file).
     hardware_layouts_.push_back(GetFallbackInputMethodDescriptor().id());
   }
 
   if (hardware_login_layouts_.empty())
     hardware_login_layouts_.push_back(GetFallbackInputMethodDescriptor().id());
 }
 
 void InputMethodUtil::SetHardwareKeyboardLayoutForTesting(
     const std::string& layout) {
   delegate_->SetHardwareKeyboardLayoutForTesting(layout);
+  cached_hardware_layouts_.clear();
   UpdateHardwareLayoutCache();
 }
 
 const std::vector<std::string>&
     InputMethodUtil::GetHardwareInputMethodIds() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  // Once the initialization is done, at least one input method should be set.
-  if (hardware_layouts_.empty())
-    UpdateHardwareLayoutCache();
+  UpdateHardwareLayoutCache();
   return hardware_layouts_;
 }
 
 const std::vector<std::string>&
     InputMethodUtil::GetHardwareLoginInputMethodIds() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  // Once the initialization is done, at least one input method should be set.
-  if (hardware_login_layouts_.empty())
-    UpdateHardwareLayoutCache();
+  UpdateHardwareLayoutCache();
   return hardware_login_layouts_;
 }
 
 bool InputMethodUtil::IsLoginKeyboard(const std::string& input_method_id)
     const {
   const InputMethodDescriptor* ime =
       GetInputMethodDescriptorFromId(input_method_id);
   return ime ? ime->is_login_keyboard() : false;
 }
 
@@ skipping 17 matching lines @@
           break;
       }
       if (it == range.second)
         language_code_to_ids_.insert(
             std::make_pair(language_codes[j], input_method.id()));
     }
   }
 }
 
 void InputMethodUtil::InitXkbInputMethodsForTesting() {
+  cached_hardware_layouts_.clear();
   if (!extension_ime_util::UseWrappedExtensionKeyboardLayouts())
     return;
   scoped_ptr<InputMethodDescriptors> original_imes =
       InputMethodWhitelist().GetSupportedInputMethods();
   InputMethodDescriptors whitelist_imes;
   for (size_t i = 0; i < original_imes->size(); ++i) {
     const InputMethodDescriptor& ime = (*original_imes)[i];
     whitelist_imes.push_back(InputMethodDescriptor(
         extension_ime_util::GetInputMethodIDByKeyboardLayout(ime.id()),
         "",
@@ skipping 52 matching lines @@
     if (IsKeyboardLayout(input_method.id())) {
       xkb_id_to_descriptor_.insert(
           std::make_pair(input_method.GetPreferredKeyboardLayout(),
                          input_method));
     }
   }
 }
 
 }  // namespace input_method
 }  // namespace chromeos