using ulp to improve TranslateManager GetTargetLanguage() and InitiateTranslation()

components/translate/core/browser/translate_prefs.cc

 // Copyright 2014 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 "components/translate/core/browser/translate_prefs.h"
 
 #include <set>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/translate/core/browser/translate_accept_languages.h"
 #include "components/translate/core/browser/translate_download_manager.h"
 #include "components/translate/core/browser/translate_experiment.h"
 #include "components/translate/core/common/translate_util.h"
 
 namespace translate {
 
+const char TranslatePrefs::kPrefLanguageProfile[] = "language_profile";
 const char TranslatePrefs::kPrefTranslateSiteBlacklist[] =
     "translate_site_blacklist";
 const char TranslatePrefs::kPrefTranslateWhitelists[] = "translate_whitelists";
 const char TranslatePrefs::kPrefTranslateDeniedCount[] =
     "translate_denied_count_for_language";
 const char TranslatePrefs::kPrefTranslateIgnoredCount[] =
     "translate_ignored_count_for_language";
 const char TranslatePrefs::kPrefTranslateAcceptedCount[] =
     "translate_accepted_count";
 const char TranslatePrefs::kPrefTranslateBlockedLanguages[] =
     "translate_blocked_languages";
 const char TranslatePrefs::kPrefTranslateLastDeniedTimeForLanguage[] =
     "translate_last_denied_time_for_language";
 const char TranslatePrefs::kPrefTranslateTooOftenDeniedForLanguage[] =
     "translate_too_often_denied_for_language";
+
 const char kTranslateUI2016Q2TrialName[] = "TranslateUI2016Q2";
 const char kAlwaysTranslateOfferThreshold[] =
     "always_translate_offer_threshold";
 
+// For reading ULP prefs.
+const char kConfidence[] = "confidence";
+const char kLanguage[] = "language";
+const char kPreference[] = "preference";
+const char kProbability[] = "probability";
+const char kReading[] = "reading";
+
 // The below properties used to be used but now are deprecated. Don't use them
 // since an old profile might have some values there.
 //
 // * translate_last_denied_time
 // * translate_too_often_denied
 // * translate_language_blacklist
 
 namespace {
 
 // Expands language codes to make these more suitable for Accept-Language.
@@ skipping 415 matching lines @@
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       kPrefTranslateAcceptedCount,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterListPref(kPrefTranslateBlockedLanguages,
                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(kPrefTranslateLastDeniedTimeForLanguage);
   registry->RegisterDictionaryPref(
       kPrefTranslateTooOftenDeniedForLanguage,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterDictionaryPref(
+      kPrefLanguageProfile, user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 }
 
 // static
 void TranslatePrefs::MigrateUserPrefs(PrefService* user_prefs,
                                       const char* accept_languages_pref) {
   // Old format of kPrefTranslateWhitelists
   // - original language -> list of target langs to auto-translate
   // - list of langs is in order of being enabled i.e. last in list is the
   //   most recent language that user enabled via
   //   Always translate |source_lang| to |target_lang|"
@@ skipping 75 matching lines @@
 bool TranslatePrefs::IsListEmpty(const char* pref_id) const {
   const base::ListValue* blacklist = prefs_->GetList(pref_id);
   return (blacklist == NULL || blacklist->empty());
 }
 
 bool TranslatePrefs::IsDictionaryEmpty(const char* pref_id) const {
   const base::DictionaryValue* dict = prefs_->GetDictionary(pref_id);
   return (dict == NULL || dict->empty());
 }
 
+double TranslatePrefs::GetReadingFromUserLanguageProfile(
+    LanguageAndProbabilityList* out_value) const {
+  const base::DictionaryValue* dict =
+      prefs_->GetDictionary(kPrefLanguageProfile);
+  const base::DictionaryValue* entries = nullptr;
+
+  // Return 0.0 if no ULP prefs.
+  if (!dict)
+    return 0.0;
+
+  // Return 0.0 if no such list.
+  if (!dict->GetDictionary(kReading, &entries))
+    return 0.0;
+
+  double confidence = 0.0;
+  // Return 0.0 if cannot find confidence.
+  if (!entries->GetDouble(kConfidence, &confidence))
+    return 0.0;
+
+  const base::ListValue* preference = nullptr;
+  // Return the confidence if there are no item on the 'preference' field.
+  if (!entries->GetList(kPreference, &preference))
+    return confidence;
+
+  // Use a map to fold the probability of all the same normalized language
+  // code together.
+  std::map<std::string, double> probability_map;
+  // Iterate through the preference.
+  for (const auto& entry : *preference) {
+    const base::DictionaryValue* item = nullptr;
+    std::string language;
+    double probability = 0.0;
+    if (entry->GetAsDictionary(&item) &&
+        item->GetString(kLanguage, &language) &&
+        item->GetDouble(kProbability, &probability)) {
+      // Normalize the the language code known and supported by
+      // Translate.
+      translate::ToTranslateLanguageSynonym(&language);
+      // Discard if the normalized version is unsupported.
+      if (TranslateDownloadManager::IsSupportedLanguage(language)) {
+        probability_map[language] += probability;
+      }
+    }
+  }
+  for (const auto& it : probability_map)
+    out_value->push_back(it);
+  std::sort(out_value->begin(), out_value->end(),
+            [](const LanguageAndProbability& left,
+               const LanguageAndProbability& right) {
+              return left.second > right.second;
+            });
+  return confidence;
+}
+
 }  // namespace translate