Implement the 2016Q2 Translate UI designe spec out in

components/translate/core/browser/translate_ui_delegate.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_ui_delegate.h"
 
 #include "base/i18n/string_compare.h"
 #include "base/metrics/histogram_macros.h"
 #include "components/translate/core/browser/language_state.h"
 #include "components/translate/core/browser/translate_client.h"
@@ skipping 53 matching lines @@
   std::vector<std::string> language_codes;
   TranslateDownloadManager::GetSupportedLanguages(&language_codes);
 
   // Preparing for the alphabetical order in the locale.
   std::string locale =
       TranslateDownloadManager::GetInstance()->application_locale();
   std::unique_ptr<icu::Collator> collator = CreateCollator(locale);
 
   languages_.reserve(language_codes.size());
   for (std::vector<std::string>::const_iterator iter = language_codes.begin();
-       iter != language_codes.end();
-       ++iter) {
+       iter != language_codes.end(); ++iter) {
     std::string language_code = *iter;
 
     base::string16 language_name =
         l10n_util::GetDisplayNameForLocale(language_code, locale, true);
     // Insert the language in languages_ in alphabetical order.
     std::vector<LanguageNamePair>::iterator iter2;
     if (collator) {
       for (iter2 = languages_.begin(); iter2 != languages_.end(); ++iter2) {
-        int result = base::i18n::CompareString16WithCollator(*collator,
-                                                             language_name,
-                                                             iter2->second);
+        int result = base::i18n::CompareString16WithCollator(
+            *collator, language_name, iter2->second);
         if (result == UCOL_LESS)
           break;
       }
     } else {
       // |locale| may not be supported by ICU collator (crbug/54833). In this
       // case, let's order the languages in UTF-8.
       for (iter2 = languages_.begin(); iter2 != languages_.end(); ++iter2) {
         if (language_name.compare(iter2->second) < 0)
           break;
       }
     }
     languages_.insert(iter2, LanguageNamePair(language_code, language_name));
   }
   for (std::vector<LanguageNamePair>::const_iterator iter = languages_.begin();
-       iter != languages_.end();
-       ++iter) {
+       iter != languages_.end(); ++iter) {
     std::string language_code = iter->first;
     if (language_code == original_language) {
       original_language_index_ = iter - languages_.begin();
       initial_original_language_index_ = original_language_index_;
     }
     if (language_code == target_language)
       target_language_index_ = iter - languages_.begin();
   }
 
   prefs_ = translate_manager_->translate_client()->GetTranslatePrefs();
 }
 
 TranslateUIDelegate::~TranslateUIDelegate() {}
 
 void TranslateUIDelegate::OnErrorShown(TranslateErrors::Type error_type) {
   DCHECK_LE(TranslateErrors::NONE, error_type);
   DCHECK_LT(error_type, TranslateErrors::TRANSLATE_ERROR_MAX);
 
   if (error_type == TranslateErrors::NONE)
     return;
 
-  UMA_HISTOGRAM_ENUMERATION(
-      kShowErrorUI, error_type, TranslateErrors::TRANSLATE_ERROR_MAX);
+  UMA_HISTOGRAM_ENUMERATION(kShowErrorUI, error_type,
+                            TranslateErrors::TRANSLATE_ERROR_MAX);
 }
 
 const LanguageState& TranslateUIDelegate::GetLanguageState() {
   return translate_manager_->GetLanguageState();
 }
 
 size_t TranslateUIDelegate::GetNumberOfLanguages() const {
   return languages_.size();
 }
 
@@ skipping 48 matching lines @@
 }
 
 base::string16 TranslateUIDelegate::GetLanguageNameAt(size_t index) const {
   if (index == kNoIndex)
     return base::string16();
   DCHECK_LT(index, GetNumberOfLanguages());
   return languages_[index].second;
 }
 
 std::string TranslateUIDelegate::GetOriginalLanguageCode() const {
-  return (GetOriginalLanguageIndex() == kNoIndex) ?
-      translate::kUnknownLanguageCode :
-      GetLanguageCodeAt(GetOriginalLanguageIndex());
+  return (GetOriginalLanguageIndex() == kNoIndex)
+             ? translate::kUnknownLanguageCode
+             : GetLanguageCodeAt(GetOriginalLanguageIndex());
 }
 
 std::string TranslateUIDelegate::GetTargetLanguageCode() const {
   return (GetTargetLanguageIndex() == kNoIndex)
              ? translate::kUnknownLanguageCode
              : GetLanguageCodeAt(GetTargetLanguageIndex());
 }
 
 void TranslateUIDelegate::Translate() {
   if (!translate_driver_->IsOffTheRecord()) {
     prefs_->ResetTranslationDeniedCount(GetOriginalLanguageCode());
+    prefs_->ResetTranslationIgnoredCount(GetOriginalLanguageCode());
     prefs_->IncrementTranslationAcceptedCount(GetOriginalLanguageCode());
   }
 
   if (translate_manager_) {
-    translate_manager_->TranslatePage(
-        GetOriginalLanguageCode(), GetTargetLanguageCode(), false);
+    translate_manager_->TranslatePage(GetOriginalLanguageCode(),
+                                      GetTargetLanguageCode(), false);
     UMA_HISTOGRAM_BOOLEAN(kPerformTranslate, true);
   }
 }
 
 void TranslateUIDelegate::RevertTranslation() {
   if (translate_manager_) {
     translate_manager_->RevertTranslation();
     UMA_HISTOGRAM_BOOLEAN(kRevertTranslation, true);
   }
 }
 
 void TranslateUIDelegate::TranslationDeclined(bool explicitly_closed) {
-  if (explicitly_closed && !translate_driver_->IsOffTheRecord()) {
+  if (!translate_driver_->IsOffTheRecord()) {
     const std::string& language = GetOriginalLanguageCode();
-    prefs_->ResetTranslationAcceptedCount(language);
-    prefs_->IncrementTranslationDeniedCount(language);
-    prefs_->UpdateLastDeniedTime(language);
+    if (explicitly_closed) {
+      prefs_->ResetTranslationAcceptedCount(language);
+      prefs_->IncrementTranslationDeniedCount(language);
+      prefs_->UpdateLastDeniedTime(language);
+    } else {
+      prefs_->IncrementTranslationIgnoredCount(language);
+    }
   }
 
   // Remember that the user declined the translation so as to prevent showing a
   // translate UI for that page again.  (TranslateManager initiates translations
   // when getting a LANGUAGE_DETERMINED from the page, which happens when a load
   // stops. That could happen multiple times, including after the user already
   // declined the translation.)
   if (explicitly_closed && translate_manager_) {
     translate_manager_->GetLanguageState().set_translation_declined(true);
     UMA_HISTOGRAM_BOOLEAN(kDeclineTranslate, true);
   }
 
   if (!explicitly_closed) {
     UMA_HISTOGRAM_BOOLEAN(kDeclineTranslateDismissUI, true);
   }
 }
 
 bool TranslateUIDelegate::IsLanguageBlocked() {
   return prefs_->IsBlockedLanguage(GetOriginalLanguageCode());
 }
 
 void TranslateUIDelegate::SetLanguageBlocked(bool value) {
   if (value) {
     prefs_->BlockLanguage(GetOriginalLanguageCode());
-    if (translate_manager_) {
+    // In the new UI, we will keep showing the translate omnibar icon
+    // even if the language is blocked so in case the user just wants to
+    // translate that page the user can invoke the translate bubble from
+    // the omnibar icon.
+    if (!base::FeatureList::IsEnabled(kTranslateUI2016Q2) &&
+        translate_manager_) {
       translate_manager_->GetLanguageState().SetTranslateEnabled(false);
     }
   } else {
     prefs_->UnblockLanguage(GetOriginalLanguageCode());
   }
 
   UMA_HISTOGRAM_BOOLEAN(kNeverTranslateLang, true);
 }
 
 bool TranslateUIDelegate::IsSiteBlacklisted() {
   std::string host = GetPageHost();
   return !host.empty() && prefs_->IsSiteBlacklisted(host);
 }
 
 void TranslateUIDelegate::SetSiteBlacklist(bool value) {
   std::string host = GetPageHost();
   if (host.empty())
     return;
 
   if (value) {
     prefs_->BlacklistSite(host);
-    if (translate_manager_) {
+    // In the new UI, we will keep showing the translate omnibar icon
+    // even if the site is blocked so in case the user just wants to
+    // translate that page the user can invoke the translate bubble from
+    // the omnibar icon.
+    if (!base::FeatureList::IsEnabled(kTranslateUI2016Q2) &&
+        translate_manager_) {
       translate_manager_->GetLanguageState().SetTranslateEnabled(false);
     }
   } else {
     prefs_->RemoveSiteFromBlacklist(host);
   }
 
   UMA_HISTOGRAM_BOOLEAN(kNeverTranslateSite, true);
 }
 
 bool TranslateUIDelegate::ShouldAlwaysTranslate() {
   return prefs_->IsLanguagePairWhitelisted(GetOriginalLanguageCode(),
                                            GetTargetLanguageCode());
 }
 
+bool TranslateUIDelegate::ShouldAlwaysTranslateBeCheckedByDefault() {
+  // After 2 clicks on Translate for the same language.
+  // We check for == 2 instead of >= 2 because if the user translates with the
+  // "Always do this?" on, then the next time the bubble won't show up.
+  // The only chance the bubble will show up is after the user manually unchecks
+  // "Always do this?". In that case, since it is after user explictly unchecks,
+  // we should show as it as unchecked so we only check == 2 instead of >= 2.
+  return ShouldAlwaysTranslate() ||
+         prefs_->GetTranslationAcceptedCount(GetOriginalLanguageCode()) == 2;
+}
+
 void TranslateUIDelegate::SetAlwaysTranslate(bool value) {
   const std::string& original_lang = GetOriginalLanguageCode();
   const std::string& target_lang = GetTargetLanguageCode();
   if (value)
     prefs_->WhitelistLanguagePair(original_lang, target_lang);
   else
     prefs_->RemoveLanguagePairFromWhitelist(original_lang, target_lang);
 
   UMA_HISTOGRAM_BOOLEAN(kAlwaysTranslateLang, true);
 }
 
 std::string TranslateUIDelegate::GetPageHost() {
   if (!translate_driver_->HasCurrentPage())
     return std::string();
   return translate_driver_->GetLastCommittedURL().HostNoBrackets();
 }
 
 }  // namespace translate