[ios] Adds configuration helper files for voice search.

ios/chrome/browser/voice/speech_input_locale_config_impl.mm

Index: ios/chrome/browser/voice/speech_input_locale_config_impl.mm
diff --git a/ios/chrome/browser/voice/speech_input_locale_config_impl.mm b/ios/chrome/browser/voice/speech_input_locale_config_impl.mm
new file mode 100644
index 0000000000000000000000000000000000000000..5be24ab6bf65cdb68638b94ac4ce6b8c68351540
--- /dev/null
+++ b/ios/chrome/browser/voice/speech_input_locale_config_impl.mm
@@ -0,0 +1,193 @@
+// Copyright 2016 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 "ios/chrome/browser/voice/speech_input_locale_config_impl.h"
+
+#import <Foundation/Foundation.h>
+
+#include "base/mac/bundle_locations.h"
+#include "base/mac/foundation_util.h"
+#include "base/mac/scoped_cftyperef.h"
+#include "base/strings/string_split.h"
+#include "base/strings/sys_string_conversions.h"
+#import "ios/chrome/browser/voice/speech_input_locale_match_config.h"
+#include "ios/public/provider/chrome/browser/chrome_browser_provider.h"
+#include "ios/public/provider/chrome/browser/voice/voice_search_language.h"
+
+namespace {
+
+// Returns the language portion of |locale_code|.
+std::string GetLanguageComponentForLocaleCode(const std::string& locale_code) {
+  std::vector<std::string> tokens = base::SplitString(
+      locale_code, "-", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+  if (tokens.empty())
+    return std::string();
+  return tokens[0];
+}
+
+// Use "en-US" as a default value.
+const char kEnglishUS[] = "en-US";
+
+// Converts |locale| to its canonical form and returns it as a std::string.
+std::string GetCanonicalLocaleForLocale(NSString* locale_code) {
+  std::string locale = base::SysNSStringToUTF8(
+      [NSLocale canonicalLocaleIdentifierFromString:locale_code]);
+  return locale;
+}
+
+}  // namespace
+
+namespace voice {
+
+// static
+SpeechInputLocaleConfigImpl* SpeechInputLocaleConfigImpl::GetInstance() {
+  return base::Singleton<SpeechInputLocaleConfigImpl>::get();
+}
+
+SpeechInputLocaleConfigImpl::SpeechInputLocaleConfigImpl() {
+  InitializeAvailableLocales();
+  InitializeLocaleMatches();
+  InitializeTextToSpeechLangauges();
+}
+
+SpeechInputLocaleConfigImpl::~SpeechInputLocaleConfigImpl() {}
+
+SpeechInputLocale SpeechInputLocaleConfigImpl::GetDefaultLocale() const {
+  return GetMatchingLocale(GetDefaultLocaleCode());
+}
+
+const std::vector<SpeechInputLocale>&
+SpeechInputLocaleConfigImpl::GetAvailableLocales() const {
+  return available_locales_;
+}
+
+SpeechInputLocale SpeechInputLocaleConfigImpl::GetLocaleForCode(
+    const std::string& locale_code) const {
+  auto index_iterator = locale_indices_for_codes_.find(locale_code);
+  if (index_iterator == locale_indices_for_codes_.end())
+    return SpeechInputLocale();
+  return available_locales_[index_iterator->second];
+}
+
+const std::vector<std::string>&
+SpeechInputLocaleConfigImpl::GetTextToSpeechLanguages() const {
+  return text_to_speech_languages_;
+}
+
+bool SpeechInputLocaleConfigImpl::IsTextToSpeechEnabledForCode(
+    const std::string& locale_code) const {
+  std::string language = GetLanguageComponentForLocaleCode(locale_code);
+  auto found_language = std::find(text_to_speech_languages_.begin(),
+                                  text_to_speech_languages_.end(), language);
+  return found_language != text_to_speech_languages_.end();
+}
+
+SpeechInputLocale SpeechInputLocaleConfigImpl::GetMatchingLocale(
+    const std::string& locale_code) const {
+  // Return exact match if one is found.
+  auto index_iterator = locale_indices_for_codes_.find(locale_code);
+  if (index_iterator != locale_indices_for_codes_.end())
+    return available_locales_[index_iterator->second];
+  // If there is no exact match, search for another locale with the same
+  // language component.
+  std::string language = GetLanguageComponentForLocaleCode(locale_code);
+  std::vector<size_t> locale_indices;
+  for (auto locale_index_for_code : locale_indices_for_codes_) {
+    std::string code = locale_index_for_code.first;
+    if (GetLanguageComponentForLocaleCode(code) == language)
+      locale_indices.push_back(locale_index_for_code.second);
+  }
+  // Use en-US as a default value.
+  auto it = locale_indices_for_codes_.find(kEnglishUS);
+  CHECK(it != locale_indices_for_codes_.end());
+  size_t locale_index = it->second;
+  if (locale_indices.size() == 1) {
+    // If only one match was found, use its associated InputLocale.
+    locale_index = locale_indices[0];
+  } else if (locale_indices.size() > 1) {
+    // If multiple regional differences for the same language are supported
+    // (e.g. en-US, en-GB, en-AU, en-NZ), use the default language mapping.
+    auto default_locale_iterator =
+        default_locale_indices_for_languages_.find(language);
+    if (default_locale_iterator != default_locale_indices_for_languages_.end())
+      return available_locales_[default_locale_iterator->second];
+  }
+  return available_locales_[locale_index];
+}
+
+std::string SpeechInputLocaleConfigImpl::GetDefaultLocaleCode() const {
+  // Default locale code is computed based on the UI language as reported by
+  // first object in +preferredLanguages and the device's locale (which
+  // corresponds to the "Region Format" in iOS' Settings UI). By combining
+  // the two signals, there is a better chance of setting the default
+  // Voice Search language to the regionally specific language variant.
+  // For example, users who selected English as the UI language and use
+  // South Africa Region Format (for date, time, currency, etc.) will
+  // default to use en-ZA, English (South Africa), as the Voice Search
+  // language.
+  NSLocale* current_locale = [NSLocale currentLocale];
+  NSLocale* lang_pref_locale = [NSLocale
+      localeWithLocaleIdentifier:[[NSLocale preferredLanguages] firstObject]];
+  // Prioritize the language portion of |language_pref_locale|.
+  NSString* language = [lang_pref_locale objectForKey:NSLocaleLanguageCode];
+  if (!language.length)
+    language = [current_locale objectForKey:NSLocaleLanguageCode];
+  DCHECK(language.length);
+  // Prioritize the country portion of |current_locale|.
+  NSString* country = [current_locale objectForKey:NSLocaleCountryCode];
+  if (!country.length)
+    country = [lang_pref_locale objectForKey:NSLocaleCountryCode];
+  DCHECK(country.length);
+  return GetCanonicalLocaleForLocale(
+      [NSString stringWithFormat:@"%@-%@", language, country]);
+}
+
+void SpeechInputLocaleConfigImpl::InitializeAvailableLocales() {
+  NSArray* languages =
+      ios::GetChromeBrowserProvider()->GetAvailableVoiceSearchLanguages();
+  for (VoiceSearchLanguage* language in languages) {
+    // Store the InputLocale in |available_locales_|.
+    std::string locale_code = GetCanonicalLocaleForLocale(language.identifier);
+    DCHECK(locale_code.length());
+    voice::SpeechInputLocale locale;
+    locale.code = locale_code;
+    locale.display_name = base::SysNSStringToUTF16(language.displayName);
+    available_locales_.push_back(locale);
+    // Store the index of the InputLocale.
+    size_t locale_index = available_locales_.size() - 1;
+    locale_indices_for_codes_[locale_code] = locale_index;
+    // Store a mapping from |language.localizationPreference| to the locale.
+    std::string localization_preference =
+        GetCanonicalLocaleForLocale(language.localizationPreference);
+    if (localization_preference.length())
+      locale_indices_for_codes_[localization_preference] = locale_index;
+  }
+}
+
+void SpeechInputLocaleConfigImpl::InitializeLocaleMatches() {
+  NSArray* matches = [SpeechInputLocaleMatchConfig sharedInstance].matches;
+  for (SpeechInputLocaleMatch* match in matches) {
+    std::string locale = GetCanonicalLocaleForLocale(match.matchedLocaleCode);
+    auto index_iterator = locale_indices_for_codes_.find(locale);
+    if (index_iterator != locale_indices_for_codes_.end()) {
+      size_t index = index_iterator->second;
+      for (NSString* matching_locale in match.matchingLocaleCodes) {
+        // Record the regional variant matches.
+        std::string locale_code = GetCanonicalLocaleForLocale(matching_locale);
+        locale_indices_for_codes_[locale_code] = index;
+      }
+      for (NSString* matching_language in match.matchingLanguages) {
+        // Record the default locale for the matching languages.
+        std::string language = base::SysNSStringToUTF8(matching_language);
+        default_locale_indices_for_languages_[language] = index;
+      }
+    }
+  }
+}
+
+void SpeechInputLocaleConfigImpl::InitializeTextToSpeechLangauges() {
+  text_to_speech_languages_ = {"de", "en", "es", "fr", "it", "ja", "ko"};
+}
+
+}  // namespace voice