Implement the 2016Q2 Translate UI designe spec out in

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::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";
 
 // This property is deprecated but there is still some usages. Don't use this
@@ skipping 50 matching lines @@
     const std::string& main_part = tokens[0];
     if (seen.find(main_part) == seen.end()) {
       expanded_languages->push_back(main_part);
       seen.insert(main_part);
     }
   }
 }
 
 }  // namespace
 
+const base::Feature kTranslateUI2016Q2{
+    "TranslateUI2016Q2", base::FEATURE_DISABLED_BY_DEFAULT};
+

[msw, 2016/04/29 20:00:02]

nit remove extra blank line

[ftang, 2016/04/29 22:37:02]

Done.

+
 DenialTimeUpdate::DenialTimeUpdate(PrefService* prefs,
                                    const std::string& language,
                                    size_t max_denial_count)
     : denial_time_dict_update_(
           prefs,
           TranslatePrefs::kPrefTranslateLastDeniedTimeForLanguage),
       language_(language),
       max_denial_count_(max_denial_count),
       time_list_(nullptr) {}
 
@@ skipping 66 matching lines @@
   ClearBlacklistedSites();
   ClearWhitelistedLanguagePairs();
 
   std::vector<std::string> languages;
   GetLanguageList(&languages);
   for (std::vector<std::string>::const_iterator it = languages.begin();
       it != languages.end(); ++it) {
     const std::string& language = *it;
     ResetTranslationAcceptedCount(language);
     ResetTranslationDeniedCount(language);
+    ResetTranslationIgnoredCount(language);
   }
 
   prefs_->ClearPref(kPrefTranslateLastDeniedTimeForLanguage);
   prefs_->ClearPref(kPrefTranslateTooOftenDeniedForLanguage);
 }
 
 bool TranslatePrefs::IsBlockedLanguage(
     const std::string& original_language) const {
   return IsValueBlacklisted(kPrefTranslateBlockedLanguages,
                             original_language);
@@ skipping 114 matching lines @@
   int count = 0;
   dict->GetInteger(language, &count);
   dict->SetInteger(language, count + 1);
 }
 
 void TranslatePrefs::ResetTranslationDeniedCount(const std::string& language) {
   DictionaryPrefUpdate update(prefs_, kPrefTranslateDeniedCount);
   update.Get()->SetInteger(language, 0);
 }
 
+int TranslatePrefs::GetTranslationIgnoredCount(
+    const std::string& language) const {
+  const base::DictionaryValue* dict =
+      prefs_->GetDictionary(kPrefTranslateIgnoredCount);
+  int count = 0;
+  return dict->GetInteger(language, &count) ? count : 0;
+}
+
+void TranslatePrefs::IncrementTranslationIgnoredCount(
+    const std::string& language) {
+  DictionaryPrefUpdate update(prefs_, kPrefTranslateIgnoredCount);
+  base::DictionaryValue* dict = update.Get();
+
+  int count = 0;
+  dict->GetInteger(language, &count);
+  dict->SetInteger(language, count + 1);
+}
+
+void TranslatePrefs::ResetTranslationIgnoredCount(const std::string& language) {
+  DictionaryPrefUpdate update(prefs_, kPrefTranslateIgnoredCount);
+  update.Get()->SetInteger(language, 0);

[msw, 2016/04/29 20:00:02]

Perhaps you can actually clear the pref value here... but it's not necessary.

[ftang, 2016/04/29 22:37:02]

Acknowledged.

+}
+
 int TranslatePrefs::GetTranslationAcceptedCount(const std::string& language) {
   const base::DictionaryValue* dict =
       prefs_->GetDictionary(kPrefTranslateAcceptedCount);
   int count = 0;
   return dict->GetInteger(language, &count) ? count : 0;
 }
 
 void TranslatePrefs::IncrementTranslationAcceptedCount(
     const std::string& language) {
   DictionaryPrefUpdate update(prefs_, kPrefTranslateAcceptedCount);
@@ skipping 22 matching lines @@
     return;
 
   if (now - oldest_denial_time <= base::TimeDelta::FromDays(1)) {
     DictionaryPrefUpdate update(prefs_,
                                 kPrefTranslateTooOftenDeniedForLanguage);
     update.Get()->SetBoolean(language, true);
   }
 }
 
 bool TranslatePrefs::IsTooOftenDenied(const std::string& language) const {
-  const base::DictionaryValue* dict =
-    prefs_->GetDictionary(kPrefTranslateTooOftenDeniedForLanguage);
-  bool result = false;
-  return dict->GetBoolean(language, &result) ? result : false;
+  if (base::FeatureList::IsEnabled(kTranslateUI2016Q2)) {
+    // In the new logic, we only hide the Bubble if user denied for more than

[msw, 2016/04/29 20:00:02]

nit: no caps for 'bubble'; 'if the user denied it more than 3 times or the user
ignored it more'...

[ftang, 2016/04/29 22:37:02]

Done.

+    // 3 times or user ignored more than 10 times.
+    return (GetTranslationDeniedCount(language) > 3) ||

[msw, 2016/04/29 20:00:02]

Should this ever propagate to kPrefTranslateTooOftenDeniedForLanguage?

[ftang, 2016/04/29 22:37:02]

No

[msw, 2016/04/29 23:43:39]

I'm not really sure how this is supposed to work, and it's non-obvious that the
'translation denied count' shouldn't affect the 'denied too often' flag, please
explain in a comment.

+           (GetTranslationIgnoredCount(language) > 10);
+  } else {
+    const base::DictionaryValue* dict =
+      prefs_->GetDictionary(kPrefTranslateTooOftenDeniedForLanguage);
+    bool result = false;
+    return dict->GetBoolean(language, &result) ? result : false;
+  }
 }
 
 void TranslatePrefs::ResetDenialState() {

[msw, 2016/04/29 20:00:02]

Shouldn't this also have some effect on the new UI?

[ftang, 2016/04/29 22:37:02]

no

[msw, 2016/04/29 23:43:39]

Ditto, I don't know understand why 'reset denial state' shouldn't change the
recorded 'translation denied count', please explain in a comment.

   prefs_->ClearPref(kPrefTranslateLastDeniedTimeForLanguage);
   prefs_->ClearPref(kPrefTranslateTooOftenDeniedForLanguage);
 }
 
 void TranslatePrefs::GetLanguageList(
     std::vector<std::string>* languages) const {
   DCHECK(languages);
   DCHECK(languages->empty());
 
 #if defined(OS_CHROMEOS)
@@ skipping 68 matching lines @@
                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterListPref(kPrefTranslateSiteBlacklist,
                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       kPrefTranslateWhitelists,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       kPrefTranslateDeniedCount,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(
+      kPrefTranslateIgnoredCount,
+      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);
 }
 
@@ skipping 177 matching lines @@
   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());
 }
 
 }  // namespace translate