Simplify the translate infobar code some.

chrome/browser/translate/translate_infobar_delegate.cc

 // Copyright (c) 2012 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 "chrome/browser/translate/translate_infobar_delegate.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/infobars/infobar_tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/translate/translate_infobar_view.h"
 #include "chrome/browser/translate/translate_manager.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
-#include "chrome/common/chrome_constants.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::NavigationEntry;
 
@@ skipping 37 matching lines @@
                                       error,
                                       infobar_helper,
                                       prefs,
                                       original_language,
                                       target_language);
 }
 
 TranslateInfoBarDelegate::~TranslateInfoBarDelegate() {
 }
 
-std::string TranslateInfoBarDelegate::GetLanguageCodeAt(size_t index) const {
-  DCHECK_LT(index, GetLanguageCount());
-  return languages_[index].first;
-}
-
-string16 TranslateInfoBarDelegate::GetLanguageDisplayableNameAt(
-    size_t index) const {
-  DCHECK_LT(index, GetLanguageCount());
-  return languages_[index].second;
-}
-
-std::string TranslateInfoBarDelegate::GetOriginalLanguageCode() const {
-  return (original_language_index() == kNoIndex) ?
-      chrome::kUnknownLanguageCode :
-      GetLanguageCodeAt(original_language_index());
-}
-
-std::string TranslateInfoBarDelegate::GetTargetLanguageCode() const {
-  return GetLanguageCodeAt(target_language_index());
-}
-
-void TranslateInfoBarDelegate::SetOriginalLanguage(size_t language_index) {
-  DCHECK_LT(language_index, GetLanguageCount());
-  original_language_index_ = language_index;
-  if (infobar_view_)
-    infobar_view_->OriginalLanguageChanged();
-  if (type_ == AFTER_TRANSLATE)
-    Translate();
-}
-
-void TranslateInfoBarDelegate::SetTargetLanguage(size_t language_index) {
-  DCHECK_LT(language_index, GetLanguageCount());
-  DCHECK_GE(language_index, 0U);
-  target_language_index_ = language_index;
-  if (infobar_view_)
-    infobar_view_->TargetLanguageChanged();
-  if (type_ == AFTER_TRANSLATE)
-    Translate();
-}
-
 void TranslateInfoBarDelegate::Translate() {
-  const std::string& original_language_code = GetOriginalLanguageCode();
   if (!owner()->GetWebContents()->GetBrowserContext()->IsOffTheRecord()) {
-    prefs_.ResetTranslationDeniedCount(original_language_code);
-    prefs_.IncrementTranslationAcceptedCount(original_language_code);
+    prefs_.ResetTranslationDeniedCount(original_language_code());
+    prefs_.IncrementTranslationAcceptedCount(original_language_code());
   }
 
   TranslateManager::GetInstance()->TranslatePage(owner()->GetWebContents(),
-      GetLanguageCodeAt(original_language_index()),
-      GetLanguageCodeAt(target_language_index()));
+                                                 original_language_code(),
+                                                 target_language_code());
 }
 
 void TranslateInfoBarDelegate::RevertTranslation() {
   TranslateManager::GetInstance()->RevertTranslation(owner()->GetWebContents());
   RemoveSelf();
 }
 
 void TranslateInfoBarDelegate::ReportLanguageDetectionError() {
   TranslateManager::GetInstance()->
       ReportLanguageDetectionError(owner()->GetWebContents());
 }
 
 void TranslateInfoBarDelegate::TranslationDeclined() {
-  const std::string& original_language_code = GetOriginalLanguageCode();
   if (!owner()->GetWebContents()->GetBrowserContext()->IsOffTheRecord()) {
-    prefs_.ResetTranslationAcceptedCount(original_language_code);
-    prefs_.IncrementTranslationDeniedCount(original_language_code);
+    prefs_.ResetTranslationAcceptedCount(original_language_code());
+    prefs_.IncrementTranslationDeniedCount(original_language_code());
   }
 
   // Remember that the user declined the translation so as to prevent showing a
   // translate infobar 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.)
   TranslateTabHelper* helper = TabContents::FromWebContents(
       owner()->GetWebContents())->translate_tab_helper();
   helper->language_state().set_translation_declined(true);
 }
 
 bool TranslateInfoBarDelegate::IsLanguageBlacklisted() {
-  return prefs_.IsLanguageBlacklisted(GetOriginalLanguageCode());
+  return prefs_.IsLanguageBlacklisted(original_language_code());
 }
 
 void TranslateInfoBarDelegate::ToggleLanguageBlacklist() {
-  const std::string& original_lang = GetOriginalLanguageCode();
+  const std::string& original_lang = original_language_code();
   if (prefs_.IsLanguageBlacklisted(original_lang)) {
     prefs_.RemoveLanguageFromBlacklist(original_lang);
   } else {
     prefs_.BlacklistLanguage(original_lang);
     RemoveSelf();
   }
 }
 
 bool TranslateInfoBarDelegate::IsSiteBlacklisted() {
   std::string host = GetPageHost();
   return !host.empty() && prefs_.IsSiteBlacklisted(host);
 }
 
 void TranslateInfoBarDelegate::ToggleSiteBlacklist() {
   std::string host = GetPageHost();
   if (host.empty())
     return;
 
   if (prefs_.IsSiteBlacklisted(host)) {
     prefs_.RemoveSiteFromBlacklist(host);
   } else {
     prefs_.BlacklistSite(host);
     RemoveSelf();
   }
 }
 
 bool TranslateInfoBarDelegate::ShouldAlwaysTranslate() {
-  return prefs_.IsLanguagePairWhitelisted(GetOriginalLanguageCode(),
-                                          GetTargetLanguageCode());
+  return prefs_.IsLanguagePairWhitelisted(original_language_code(),
+                                          target_language_code());
 }
 
 void TranslateInfoBarDelegate::ToggleAlwaysTranslate() {
-  const std::string& original_lang = GetOriginalLanguageCode();
-  const std::string& target_lang = GetTargetLanguageCode();
+  const std::string& original_lang = original_language_code();
+  const std::string& target_lang = target_language_code();
   if (prefs_.IsLanguagePairWhitelisted(original_lang, target_lang))
     prefs_.RemoveLanguagePairFromWhitelist(original_lang, target_lang);
   else
     prefs_.WhitelistLanguagePair(original_lang, target_lang);
 }
 
 void TranslateInfoBarDelegate::AlwaysTranslatePageLanguage() {
-  const std::string& original_lang = GetOriginalLanguageCode();
-  const std::string& target_lang = GetTargetLanguageCode();
+  const std::string& original_lang = original_language_code();
+  const std::string& target_lang = target_language_code();
   DCHECK(!prefs_.IsLanguagePairWhitelisted(original_lang, target_lang));
   prefs_.WhitelistLanguagePair(original_lang, target_lang);
   Translate();
 }
 
 void TranslateInfoBarDelegate::NeverTranslatePageLanguage() {
-  std::string original_lang = GetOriginalLanguageCode();
+  std::string original_lang = original_language_code();
   DCHECK(!prefs_.IsLanguageBlacklisted(original_lang));
   prefs_.BlacklistLanguage(original_lang);
   RemoveSelf();
 }
 
 string16 TranslateInfoBarDelegate::GetMessageInfoBarText() {
   if (type_ == TRANSLATING) {
     return l10n_util::GetStringFUTF16(IDS_TRANSLATE_INFOBAR_TRANSLATING_TO,
-        GetLanguageDisplayableNameAt(target_language_index_));
+                                      language_name_at(target_language_index_));
   }
 
   DCHECK_EQ(TRANSLATION_ERROR, type_);
   switch (error_) {
     case TranslateErrors::NETWORK:
       return l10n_util::GetStringUTF16(
           IDS_TRANSLATE_INFOBAR_ERROR_CANT_CONNECT);
     case TranslateErrors::INITIALIZATION_ERROR:
     case TranslateErrors::TRANSLATION_ERROR:
       return l10n_util::GetStringUTF16(
           IDS_TRANSLATE_INFOBAR_ERROR_CANT_TRANSLATE);
     case TranslateErrors::UNKNOWN_LANGUAGE:
       return l10n_util::GetStringUTF16(
           IDS_TRANSLATE_INFOBAR_UNKNOWN_PAGE_LANGUAGE);
     case TranslateErrors::UNSUPPORTED_LANGUAGE:
       return l10n_util::GetStringFUTF16(
           IDS_TRANSLATE_INFOBAR_UNSUPPORTED_PAGE_LANGUAGE,
-          GetLanguageDisplayableNameAt(target_language_index_));
+          language_name_at(target_language_index_));
     case TranslateErrors::IDENTICAL_LANGUAGES:
       return l10n_util::GetStringFUTF16(
           IDS_TRANSLATE_INFOBAR_ERROR_SAME_LANGUAGE,
-          GetLanguageDisplayableNameAt(target_language_index_));
+          language_name_at(target_language_index_));
     default:
       NOTREACHED();
       return string16();
   }
 }
 
 string16 TranslateInfoBarDelegate::GetMessageInfoBarButtonText() {
   if (type_ != TRANSLATION_ERROR) {
     DCHECK_EQ(TRANSLATING, type_);
   } else if ((error_ != TranslateErrors::IDENTICAL_LANGUAGES) &&
              (error_ != TranslateErrors::UNKNOWN_LANGUAGE)) {
     return l10n_util::GetStringUTF16(
         (error_ == TranslateErrors::UNSUPPORTED_LANGUAGE) ?
         IDS_TRANSLATE_INFOBAR_REVERT : IDS_TRANSLATE_INFOBAR_RETRY);
   }
   return string16();
 }
 
 void TranslateInfoBarDelegate::MessageInfoBarButtonPressed() {
   DCHECK_EQ(TRANSLATION_ERROR, type_);
   if (error_ == TranslateErrors::UNSUPPORTED_LANGUAGE) {
     RevertTranslation();
     return;
   }
   // This is the "Try again..." case.
   TranslateManager::GetInstance()->TranslatePage(owner()->GetWebContents(),
-      GetOriginalLanguageCode(), GetTargetLanguageCode());
+      original_language_code(), target_language_code());
 }
 
 bool TranslateInfoBarDelegate::ShouldShowMessageInfoBarButton() {
   return !GetMessageInfoBarButtonText().empty();
 }
 
 bool TranslateInfoBarDelegate::ShouldShowNeverTranslateButton() {
   DCHECK_EQ(BEFORE_TRANSLATE, type_);
   return !owner()->GetWebContents()->GetBrowserContext()->IsOffTheRecord() &&
-      (prefs_.GetTranslationDeniedCount(GetOriginalLanguageCode()) >= 3);
+      (prefs_.GetTranslationDeniedCount(original_language_code()) >= 3);
 }
 
 bool TranslateInfoBarDelegate::ShouldShowAlwaysTranslateButton() {
   DCHECK_EQ(BEFORE_TRANSLATE, type_);
   return !owner()->GetWebContents()->GetBrowserContext()->IsOffTheRecord() &&
-      (prefs_.GetTranslationAcceptedCount(GetOriginalLanguageCode()) >= 3);
+      (prefs_.GetTranslationAcceptedCount(original_language_code()) >= 3);
 }
 
 void TranslateInfoBarDelegate::UpdateBackgroundAnimation(
     TranslateInfoBarDelegate* previous_infobar) {
   if (!previous_infobar || previous_infobar->IsError() == IsError())
     background_animation_ = NONE;
   else
     background_animation_ = IsError() ? NORMAL_TO_ERROR : ERROR_TO_NORMAL;
 }
 
@@ skipping 32 matching lines @@
     PrefService* prefs,
     const std::string& original_language,
     const std::string& target_language)
     : InfoBarDelegate(infobar_helper),
       type_(type),
       background_animation_(NONE),
       original_language_index_(kNoIndex),
       initial_original_language_index_(kNoIndex),
       target_language_index_(kNoIndex),
       error_(error),
-      infobar_view_(NULL),
       prefs_(prefs) {
   DCHECK_NE((type_ == TRANSLATION_ERROR), (error == TranslateErrors::NONE));
 
   std::vector<std::string> language_codes;
   TranslateManager::GetSupportedLanguages(&language_codes);
 
   languages_.reserve(language_codes.size());
   for (std::vector<std::string>::const_iterator iter = language_codes.begin();
        iter != language_codes.end(); ++iter) {
     std::string language_code = *iter;
@@ skipping 51 matching lines @@
 TranslateInfoBarDelegate*
     TranslateInfoBarDelegate::AsTranslateInfoBarDelegate() {
   return this;
 }
 
 std::string TranslateInfoBarDelegate::GetPageHost() {
   NavigationEntry* entry =
       owner()->GetWebContents()->GetController().GetActiveEntry();
   return entry ? entry->GetURL().HostNoBrackets() : std::string();
 }