Home | History | Annotate | Download | only in browser 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "components/translate/core/browser/translate_infobar_delegate.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/i18n/string_compare.h"
     10 #include "base/metrics/histogram.h"
     11 #include "components/infobars/core/infobar.h"
     12 #include "components/infobars/core/infobar_manager.h"
     13 #include "components/translate/core/browser/language_state.h"
     14 #include "components/translate/core/browser/translate_accept_languages.h"
     15 #include "components/translate/core/browser/translate_client.h"
     16 #include "components/translate/core/browser/translate_download_manager.h"
     17 #include "components/translate/core/browser/translate_driver.h"
     18 #include "components/translate/core/browser/translate_manager.h"
     19 #include "components/translate/core/common/translate_constants.h"
     20 #include "grit/components_strings.h"
     21 #include "ui/base/l10n/l10n_util.h"
     22 
     23 namespace translate {
     24 
     25 namespace {
     26 
     27 // Counts used to decide whether infobars should be shown.
     28 // Android and iOS implementations do not offer a drop down (for space reasons),
     29 // so we are more aggressive about showing the shortcut to never translate.
     30 // The "Always Translate" option is always shown on iOS and Android.
     31 #if defined(OS_ANDROID)
     32 const int kAlwaysTranslateMinCount = 1;
     33 const int kNeverTranslateMinCount = 1;
     34 #elif defined(OS_IOS)
     35 // The iOS implementation, like the Android implementation, shows the "Never
     36 // translate" infobar after two denials. There is an offset of one because on
     37 // Android the last event is not counted.
     38 const int kAlwaysTranslateMinCount = 1;
     39 const int kNeverTranslateMinCount = 2;
     40 #else
     41 const int kAlwaysTranslateMinCount = 3;
     42 const int kNeverTranslateMinCount = 3;
     43 #endif
     44 
     45 }  // namespace
     46 
     47 const size_t TranslateInfoBarDelegate::kNoIndex = TranslateUIDelegate::kNoIndex;
     48 
     49 TranslateInfoBarDelegate::~TranslateInfoBarDelegate() {
     50 }
     51 
     52 // static
     53 void TranslateInfoBarDelegate::Create(
     54     bool replace_existing_infobar,
     55     const base::WeakPtr<TranslateManager>& translate_manager,
     56     infobars::InfoBarManager* infobar_manager,
     57     bool is_off_the_record,
     58     translate::TranslateStep step,
     59     const std::string& original_language,
     60     const std::string& target_language,
     61     TranslateErrors::Type error_type,
     62     bool triggered_from_menu) {
     63   DCHECK(translate_manager);
     64   DCHECK(infobar_manager);
     65 
     66   // Check preconditions.
     67   if (step != translate::TRANSLATE_STEP_TRANSLATE_ERROR) {
     68     DCHECK(TranslateDownloadManager::IsSupportedLanguage(target_language));
     69     if (!TranslateDownloadManager::IsSupportedLanguage(original_language)) {
     70       // The original language can only be "unknown" for the "translating"
     71       // infobar, which is the case when the user started a translation from the
     72       // context menu.
     73       DCHECK(step == translate::TRANSLATE_STEP_TRANSLATING ||
     74              step == translate::TRANSLATE_STEP_AFTER_TRANSLATE);
     75       DCHECK_EQ(translate::kUnknownLanguageCode, original_language);
     76     }
     77   }
     78 
     79   // Do not create the after translate infobar if we are auto translating.
     80   TranslateClient* translate_client = translate_manager->translate_client();
     81   if (((step == translate::TRANSLATE_STEP_AFTER_TRANSLATE) ||
     82        (step == translate::TRANSLATE_STEP_TRANSLATING)) &&
     83       translate_manager->GetLanguageState().InTranslateNavigation()) {
     84     return;
     85   }
     86 
     87   // Find any existing translate infobar delegate.
     88   infobars::InfoBar* old_infobar = NULL;
     89   TranslateInfoBarDelegate* old_delegate = NULL;
     90   for (size_t i = 0; i < infobar_manager->infobar_count(); ++i) {
     91     old_infobar = infobar_manager->infobar_at(i);
     92     old_delegate = old_infobar->delegate()->AsTranslateInfoBarDelegate();
     93     if (old_delegate) {
     94       if (!replace_existing_infobar)
     95         return;
     96       break;
     97     }
     98   }
     99 
    100   // Add the new delegate.
    101   scoped_ptr<infobars::InfoBar> infobar(translate_client->CreateInfoBar(
    102       scoped_ptr<TranslateInfoBarDelegate>(new TranslateInfoBarDelegate(
    103           translate_manager, is_off_the_record, step, old_delegate,
    104           original_language, target_language, error_type,
    105           triggered_from_menu))));
    106   if (old_delegate)
    107     infobar_manager->ReplaceInfoBar(old_infobar, infobar.Pass());
    108   else
    109     infobar_manager->AddInfoBar(infobar.Pass());
    110 }
    111 
    112 void TranslateInfoBarDelegate::UpdateOriginalLanguageIndex(
    113     size_t language_index) {
    114   ui_delegate_.UpdateOriginalLanguageIndex(language_index);
    115 }
    116 
    117 void TranslateInfoBarDelegate::UpdateTargetLanguageIndex(
    118     size_t language_index) {
    119   ui_delegate_.UpdateTargetLanguageIndex(language_index);
    120 }
    121 
    122 void TranslateInfoBarDelegate::Translate() {
    123   ui_delegate_.Translate();
    124 }
    125 
    126 void TranslateInfoBarDelegate::RevertTranslation() {
    127   ui_delegate_.RevertTranslation();
    128   infobar()->RemoveSelf();
    129 }
    130 
    131 void TranslateInfoBarDelegate::ReportLanguageDetectionError() {
    132   if (translate_manager_)
    133     translate_manager_->ReportLanguageDetectionError();
    134 }
    135 
    136 void TranslateInfoBarDelegate::TranslationDeclined() {
    137   ui_delegate_.TranslationDeclined(false);
    138 }
    139 
    140 bool TranslateInfoBarDelegate::IsTranslatableLanguageByPrefs() {
    141   TranslateClient* client = translate_manager_->translate_client();
    142   scoped_ptr<TranslatePrefs> translate_prefs(client->GetTranslatePrefs());
    143   TranslateAcceptLanguages* accept_languages =
    144       client->GetTranslateAcceptLanguages();
    145   return translate_prefs->CanTranslateLanguage(accept_languages,
    146                                                original_language_code());
    147 }
    148 
    149 void TranslateInfoBarDelegate::ToggleTranslatableLanguageByPrefs() {
    150   if (ui_delegate_.IsLanguageBlocked()) {
    151     ui_delegate_.SetLanguageBlocked(false);
    152   } else {
    153     ui_delegate_.SetLanguageBlocked(true);
    154     infobar()->RemoveSelf();
    155   }
    156 }
    157 
    158 bool TranslateInfoBarDelegate::IsSiteBlacklisted() {
    159   return ui_delegate_.IsSiteBlacklisted();
    160 }
    161 
    162 void TranslateInfoBarDelegate::ToggleSiteBlacklist() {
    163   if (ui_delegate_.IsSiteBlacklisted()) {
    164     ui_delegate_.SetSiteBlacklist(false);
    165   } else {
    166     ui_delegate_.SetSiteBlacklist(true);
    167     infobar()->RemoveSelf();
    168   }
    169 }
    170 
    171 bool TranslateInfoBarDelegate::ShouldAlwaysTranslate() {
    172   return ui_delegate_.ShouldAlwaysTranslate();
    173 }
    174 
    175 void TranslateInfoBarDelegate::ToggleAlwaysTranslate() {
    176   ui_delegate_.SetAlwaysTranslate(!ui_delegate_.ShouldAlwaysTranslate());
    177 }
    178 
    179 void TranslateInfoBarDelegate::AlwaysTranslatePageLanguage() {
    180   DCHECK(!ui_delegate_.ShouldAlwaysTranslate());
    181   ui_delegate_.SetAlwaysTranslate(true);
    182   Translate();
    183 }
    184 
    185 void TranslateInfoBarDelegate::NeverTranslatePageLanguage() {
    186   DCHECK(!ui_delegate_.IsLanguageBlocked());
    187   ui_delegate_.SetLanguageBlocked(true);
    188   infobar()->RemoveSelf();
    189 }
    190 
    191 base::string16 TranslateInfoBarDelegate::GetMessageInfoBarText() {
    192   if (step_ == translate::TRANSLATE_STEP_TRANSLATING) {
    193     base::string16 target_language_name =
    194         language_name_at(target_language_index());
    195     return l10n_util::GetStringFUTF16(IDS_TRANSLATE_INFOBAR_TRANSLATING_TO,
    196                                       target_language_name);
    197   }
    198 
    199   DCHECK_EQ(translate::TRANSLATE_STEP_TRANSLATE_ERROR, step_);
    200   UMA_HISTOGRAM_ENUMERATION("Translate.ShowErrorInfobar",
    201                             error_type_,
    202                             TranslateErrors::TRANSLATE_ERROR_MAX);
    203   ui_delegate_.OnErrorShown(error_type_);
    204   switch (error_type_) {
    205     case TranslateErrors::NETWORK:
    206       return l10n_util::GetStringUTF16(
    207           IDS_TRANSLATE_INFOBAR_ERROR_CANT_CONNECT);
    208     case TranslateErrors::INITIALIZATION_ERROR:
    209     case TranslateErrors::TRANSLATION_ERROR:
    210       return l10n_util::GetStringUTF16(
    211           IDS_TRANSLATE_INFOBAR_ERROR_CANT_TRANSLATE);
    212     case TranslateErrors::UNKNOWN_LANGUAGE:
    213       return l10n_util::GetStringUTF16(
    214           IDS_TRANSLATE_INFOBAR_UNKNOWN_PAGE_LANGUAGE);
    215     case TranslateErrors::UNSUPPORTED_LANGUAGE:
    216       return l10n_util::GetStringFUTF16(
    217           IDS_TRANSLATE_INFOBAR_UNSUPPORTED_PAGE_LANGUAGE,
    218           language_name_at(target_language_index()));
    219     case TranslateErrors::IDENTICAL_LANGUAGES:
    220       return l10n_util::GetStringFUTF16(
    221           IDS_TRANSLATE_INFOBAR_ERROR_SAME_LANGUAGE,
    222           language_name_at(target_language_index()));
    223     default:
    224       NOTREACHED();
    225       return base::string16();
    226   }
    227 }
    228 
    229 base::string16 TranslateInfoBarDelegate::GetMessageInfoBarButtonText() {
    230   if (step_ != translate::TRANSLATE_STEP_TRANSLATE_ERROR) {
    231     DCHECK_EQ(translate::TRANSLATE_STEP_TRANSLATING, step_);
    232   } else if ((error_type_ != TranslateErrors::IDENTICAL_LANGUAGES) &&
    233              (error_type_ != TranslateErrors::UNKNOWN_LANGUAGE)) {
    234     return l10n_util::GetStringUTF16(
    235         (error_type_ == TranslateErrors::UNSUPPORTED_LANGUAGE) ?
    236         IDS_TRANSLATE_INFOBAR_REVERT : IDS_TRANSLATE_INFOBAR_RETRY);
    237   }
    238   return base::string16();
    239 }
    240 
    241 void TranslateInfoBarDelegate::MessageInfoBarButtonPressed() {
    242   DCHECK_EQ(translate::TRANSLATE_STEP_TRANSLATE_ERROR, step_);
    243   if (error_type_ == TranslateErrors::UNSUPPORTED_LANGUAGE) {
    244     RevertTranslation();
    245     return;
    246   }
    247   // This is the "Try again..." case.
    248   DCHECK(translate_manager_);
    249   translate_manager_->TranslatePage(
    250       original_language_code(), target_language_code(), false);
    251 }
    252 
    253 bool TranslateInfoBarDelegate::ShouldShowMessageInfoBarButton() {
    254   return !GetMessageInfoBarButtonText().empty();
    255 }
    256 
    257 bool TranslateInfoBarDelegate::ShouldShowNeverTranslateShortcut() {
    258   DCHECK_EQ(translate::TRANSLATE_STEP_BEFORE_TRANSLATE, step_);
    259   return !is_off_the_record_ &&
    260       (prefs_->GetTranslationDeniedCount(original_language_code()) >=
    261           kNeverTranslateMinCount);
    262 }
    263 
    264 bool TranslateInfoBarDelegate::ShouldShowAlwaysTranslateShortcut() {
    265   DCHECK_EQ(translate::TRANSLATE_STEP_BEFORE_TRANSLATE, step_);
    266   return !is_off_the_record_ &&
    267       (prefs_->GetTranslationAcceptedCount(original_language_code()) >=
    268           kAlwaysTranslateMinCount);
    269 }
    270 
    271 // static
    272 void TranslateInfoBarDelegate::GetAfterTranslateStrings(
    273     std::vector<base::string16>* strings,
    274     bool* swap_languages,
    275     bool autodetermined_source_language) {
    276   DCHECK(strings);
    277 
    278   if (autodetermined_source_language) {
    279     size_t offset;
    280     base::string16 text = l10n_util::GetStringFUTF16(
    281         IDS_TRANSLATE_INFOBAR_AFTER_MESSAGE_AUTODETERMINED_SOURCE_LANGUAGE,
    282         base::string16(),
    283         &offset);
    284 
    285     strings->push_back(text.substr(0, offset));
    286     strings->push_back(text.substr(offset));
    287     return;
    288   }
    289   DCHECK(swap_languages);
    290 
    291   std::vector<size_t> offsets;
    292   base::string16 text = l10n_util::GetStringFUTF16(
    293       IDS_TRANSLATE_INFOBAR_AFTER_MESSAGE, base::string16(), base::string16(),
    294       &offsets);
    295   DCHECK_EQ(2U, offsets.size());
    296 
    297   *swap_languages = (offsets[0] > offsets[1]);
    298   if (*swap_languages)
    299     std::swap(offsets[0], offsets[1]);
    300 
    301   strings->push_back(text.substr(0, offsets[0]));
    302   strings->push_back(text.substr(offsets[0], offsets[1] - offsets[0]));
    303   strings->push_back(text.substr(offsets[1]));
    304 }
    305 
    306 TranslateDriver* TranslateInfoBarDelegate::GetTranslateDriver() {
    307   if (!translate_manager_)
    308     return NULL;
    309 
    310   return translate_manager_->translate_client()->GetTranslateDriver();
    311 }
    312 
    313 TranslateInfoBarDelegate::TranslateInfoBarDelegate(
    314     const base::WeakPtr<TranslateManager>& translate_manager,
    315     bool is_off_the_record,
    316     translate::TranslateStep step,
    317     TranslateInfoBarDelegate* old_delegate,
    318     const std::string& original_language,
    319     const std::string& target_language,
    320     TranslateErrors::Type error_type,
    321     bool triggered_from_menu)
    322     : infobars::InfoBarDelegate(),
    323       is_off_the_record_(is_off_the_record),
    324       step_(step),
    325       background_animation_(NONE),
    326       ui_delegate_(translate_manager, original_language, target_language),
    327       translate_manager_(translate_manager),
    328       error_type_(error_type),
    329       prefs_(translate_manager->translate_client()->GetTranslatePrefs()),
    330       triggered_from_menu_(triggered_from_menu) {
    331   DCHECK_NE((step_ == translate::TRANSLATE_STEP_TRANSLATE_ERROR),
    332             (error_type_ == TranslateErrors::NONE));
    333   DCHECK(translate_manager_);
    334 
    335   if (old_delegate && (old_delegate->is_error() != is_error()))
    336     background_animation_ = is_error() ? NORMAL_TO_ERROR : ERROR_TO_NORMAL;
    337 }
    338 
    339 void TranslateInfoBarDelegate::InfoBarDismissed() {
    340   if (step_ != translate::TRANSLATE_STEP_BEFORE_TRANSLATE)
    341     return;
    342 
    343   // The user closed the infobar without clicking the translate button.
    344   TranslationDeclined();
    345   UMA_HISTOGRAM_BOOLEAN("Translate.DeclineTranslateCloseInfobar", true);
    346 }
    347 
    348 int TranslateInfoBarDelegate::GetIconID() const {
    349   return translate_manager_->translate_client()->GetInfobarIconID();
    350 }
    351 
    352 infobars::InfoBarDelegate::Type TranslateInfoBarDelegate::GetInfoBarType()
    353     const {
    354   return PAGE_ACTION_TYPE;
    355 }
    356 
    357 bool TranslateInfoBarDelegate::ShouldExpire(
    358     const NavigationDetails& details) const {
    359   // Note: we allow closing this infobar even if the main frame navigation
    360   // was programmatic and not initiated by the user - crbug.com/70261 .
    361   if (!details.is_navigation_to_different_page && !details.is_main_frame)
    362     return false;
    363 
    364   return infobars::InfoBarDelegate::ShouldExpireInternal(details);
    365 }
    366 
    367 TranslateInfoBarDelegate*
    368     TranslateInfoBarDelegate::AsTranslateInfoBarDelegate() {
    369   return this;
    370 }
    371 
    372 }  // namespace translate
    373