[ios] Adds configuration helper files for voice search.

ios/chrome/browser/ui/voice/speech_input_locale_config_impl.mm

+// 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/ui/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/ui/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.size())

[sdefresne, 2016/10/17 16:12:39]

Can you change this to use tokens.empty()?

  if (tokens.empty())
    return std::string();
  return tokens[0];

[rohitrao (ping after 24h), 2016/10/17 17:42:27]

Done.

+    return tokens[0];
+  return std::string();
+}
+
+// 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
+SpeechInputLocaleConfig* SpeechInputLocaleConfig::GetInstance() {

[sdefresne, 2016/10/17 16:12:40]

I really dislike having the GetInstance in the subclass implementation file, can
you move it to speech_input_locale_config.cc (renaming the file to
speech_input_locale_input_config.mm I guess).

[rohitrao (ping after 24h), 2016/10/17 17:42:27]

Done.

+  return SpeechInputLocaleConfigImpl::GetInstance();
+}
+
+// static
+SpeechInputLocaleConfigImpl* SpeechInputLocaleConfigImpl::GetInstance() {
+  return base::Singleton<SpeechInputLocaleConfigImpl>::get();
+}
+
+SpeechInputLocaleConfigImpl::SpeechInputLocaleConfigImpl() {
+  InitializeAvailableLocales();
+  InitializeLocaleMatches();
+  InitializeTextToSpeechLangauges();
+}
+
+SpeechInputLocaleConfigImpl::~SpeechInputLocaleConfigImpl() {}
+
+SpeechInputLocale SpeechInputLocaleConfigImpl::GetDefaultLocale() {
+  return GetMatchingLocale(GetDefaultLocaleCode());
+}
+
+const std::vector<SpeechInputLocale>&
+SpeechInputLocaleConfigImpl::GetAvailableLocales() {
+  return available_locales_;
+}
+
+SpeechInputLocale SpeechInputLocaleConfigImpl::GetLocaleForCode(

[sdefresne, 2016/10/17 16:12:40]

This method implementation does not match the comment in the super class.

   // Returns the SpeechInputLocale to use for |locale_code|. If |locale_code|
is
   // not contained in GetAvailableLocales()'s return value, then the
   // SpeechInputLocaleConfig will attempt to match with an appropriate
subsitute
   // (e.g. "en-NZ" => "en-AU").
   virtual SpeechInputLocale GetLocaleForCode(
       const std::string& locale_code) = 0;
 
It looks like the method that has the implementation described in the comment is
GetMatchingLocale().

Should GetLocaleForCode be changed to have the same implementation as
GetMatchingLocale() (and then the code migrated to call the method from the
public interface instead of the better method from the implementation class).

[rohitrao (ping after 24h), 2016/10/17 17:42:27]

Will follow up with Kurt on this.

+    const std::string& locale_code) {
+  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() {
+  return text_to_speech_languages_;
+}
+
+bool SpeechInputLocaleConfigImpl::IsTextToSpeechEnabledForCode(
+    const std::string& locale_code) {
+  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) {
+  // 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.
+  size_t locale_index = locale_indices_for_codes_[kEnglishUS];
+  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() {
+  // 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"};
+}
+}

[sdefresne, 2016/10/17 16:12:39]

nit: blank line before closing brace of the namespace and // namespace voice
comment

[rohitrao (ping after 24h), 2016/10/17 17:42:27]

Done.