Fetch the translate script regularly

chrome/browser/translate/translate_infobar_delegate.cc

 // Copyright (c) 2010 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 "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/histogram.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/translate/translate_infobar_view.h"
 #include "chrome/browser/translate/translate_manager.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 
 // static
 TranslateInfoBarDelegate* TranslateInfoBarDelegate::CreateDelegate(
     Type type,
     TabContents* tab_contents,
     const std::string& original_language,
     const std::string& target_language) {
-  DCHECK(type != kTranslationError);
+  DCHECK(type != TRANSLATION_ERROR);
   if (!TranslateManager::IsSupportedLanguage(original_language) ||
       !TranslateManager::IsSupportedLanguage(target_language)) {
     return NULL;
   }
   TranslateInfoBarDelegate* delegate =
       new TranslateInfoBarDelegate(type, TranslateErrors::NONE,
                                    tab_contents,
                                    original_language, target_language);
   DCHECK(delegate->original_language_index() != -1);
   DCHECK(delegate->target_language_index() != -1);
   return delegate;
 }
 
 TranslateInfoBarDelegate* TranslateInfoBarDelegate::CreateErrorDelegate(
     TranslateErrors::Type error,
     TabContents* tab_contents,
     const std::string& original_language,
     const std::string& target_language) {
-  return new TranslateInfoBarDelegate(kTranslationError, error, tab_contents,
+  return new TranslateInfoBarDelegate(TRANSLATION_ERROR, error, tab_contents,
                                       original_language, target_language);
 }
 
 TranslateInfoBarDelegate::TranslateInfoBarDelegate(
     Type type,
     TranslateErrors::Type error,
     TabContents* tab_contents,
     const std::string& original_language,
     const std::string& target_language)
     : InfoBarDelegate(tab_contents),
       type_(type),
-      background_animation_(kNone),
+      background_animation_(NONE),
       tab_contents_(tab_contents),
       original_language_index_(-1),
       initial_original_language_index_(-1),
       target_language_index_(-1),
       error_(error),
       infobar_view_(NULL),
       prefs_(tab_contents_->profile()->GetPrefs()) {
-  DCHECK((type_ != kTranslationError && error == TranslateErrors::NONE) ||
-         (type_ == kTranslationError && error != TranslateErrors::NONE));
+  DCHECK((type_ != TRANSLATION_ERROR && error == TranslateErrors::NONE) ||
+         (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;
 
     string16 language_name = GetLanguageDisplayableName(language_code);
@@ skipping 39 matching lines @@
 
 std::string TranslateInfoBarDelegate::GetTargetLanguageCode() const {
   return GetLanguageCodeAt(target_language_index());
 }
 
 void TranslateInfoBarDelegate::SetOriginalLanguage(int language_index) {
   DCHECK(language_index < static_cast<int>(languages_.size()));
   original_language_index_ = language_index;
   if (infobar_view_)
     infobar_view_->OriginalLanguageChanged();
-  if (type_ == kAfterTranslate)
+  if (type_ == AFTER_TRANSLATE)
     Translate();
 }
 
 void TranslateInfoBarDelegate::SetTargetLanguage(int language_index) {
   DCHECK(language_index < static_cast<int>(languages_.size()));
   target_language_index_ = language_index;
   if (infobar_view_)
     infobar_view_->TargetLanguageChanged();
-  if (type_ == kAfterTranslate)
+  if (type_ == AFTER_TRANSLATE)
     Translate();
 }
 
 bool TranslateInfoBarDelegate::IsError() {
-  return type_ == kTranslationError;
+  return type_ == TRANSLATION_ERROR;
 }
 
 void TranslateInfoBarDelegate::Translate() {
   const std::string& original_language_code = GetOriginalLanguageCode();
   prefs_.ResetTranslationDeniedCount(original_language_code);
   prefs_.IncrementTranslationAcceptedCount(original_language_code);
 
   Singleton<TranslateManager>::get()->TranslatePage(
       tab_contents_,
       GetLanguageCodeAt(original_language_index()),
@@ skipping 17 matching lines @@
 
   // 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.)
   tab_contents_->language_state().set_translation_declined(true);
 }
 
 void TranslateInfoBarDelegate::InfoBarDismissed() {
-  if (type_ != kBeforeTranslate)
+  if (type_ != BEFORE_TRANSLATE)
     return;
 
   // The user closed the infobar without clicking the translate button.
   TranslationDeclined();
   UMA_HISTOGRAM_COUNTS("Translate.DeclineTranslateCloseInfobar", 1);
 }
 
 void TranslateInfoBarDelegate::InfoBarClosed() {
   delete this;
 }
@@ skipping 63 matching lines @@
 
 void TranslateInfoBarDelegate::NeverTranslatePageLanguage() {
   std::string original_lang = GetOriginalLanguageCode();
   DCHECK(!prefs_.IsLanguageBlacklisted(original_lang));
   prefs_.BlacklistLanguage(original_lang);
   tab_contents_->RemoveInfoBar(this);
 }
 
 string16 TranslateInfoBarDelegate::GetMessageInfoBarText() {
   switch (type_) {
-    case kTranslating:
+    case TRANSLATING:
       return l10n_util::GetStringFUTF16(
           IDS_TRANSLATE_INFOBAR_TRANSLATING_TO,
           GetLanguageDisplayableNameAt(target_language_index_));
-    case kTranslationError:
+    case TRANSLATION_ERROR:
       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(
@@ skipping 11 matching lines @@
           return string16();
       }
     default:
       NOTREACHED();
       return string16();
   }
 }
 
 string16 TranslateInfoBarDelegate::GetMessageInfoBarButtonText() {
   switch (type_) {
-    case kTranslating:
+    case TRANSLATING:
       return string16();
-    case kTranslationError:
+    case TRANSLATION_ERROR:
       if (error_ == TranslateErrors::IDENTICAL_LANGUAGES ||
           error_ == TranslateErrors::UNKNOWN_LANGUAGE) {
         // No retry button, we would fail again with the same error.
         return string16();
       }
       if (error_ == TranslateErrors::UNSUPPORTED_LANGUAGE)
         return l10n_util::GetStringUTF16(IDS_TRANSLATE_INFOBAR_REVERT);
       return l10n_util::GetStringUTF16(IDS_TRANSLATE_INFOBAR_RETRY);
     default:
       NOTREACHED();
       return string16();
   }
 }
 
 void TranslateInfoBarDelegate::MessageInfoBarButtonPressed() {
-  DCHECK(type_ == kTranslationError);
+  DCHECK(type_ == TRANSLATION_ERROR);
   if (error_ == TranslateErrors::UNSUPPORTED_LANGUAGE) {
     RevertTranslation();
     return;
   }
   // This is the "Try again..." case.
   Singleton<TranslateManager>::get()->TranslatePage(
       tab_contents_, GetOriginalLanguageCode(), GetTargetLanguageCode());
 }
 
 bool TranslateInfoBarDelegate::ShouldShowNeverTranslateButton() {
-  DCHECK(type_ == kBeforeTranslate);
+  DCHECK(type_ == BEFORE_TRANSLATE);
   return prefs_.GetTranslationDeniedCount(GetOriginalLanguageCode()) >= 3;
 }
 
 bool TranslateInfoBarDelegate::ShouldShowAlwaysTranslateButton() {
-  DCHECK(type_ == kBeforeTranslate);
+  DCHECK(type_ == BEFORE_TRANSLATE);
   return prefs_.GetTranslationAcceptedCount(GetOriginalLanguageCode()) >= 3;
 }
 
 void TranslateInfoBarDelegate::UpdateBackgroundAnimation(
     TranslateInfoBarDelegate* previous_infobar) {
   if (!previous_infobar || previous_infobar->IsError() == IsError()) {
-    background_animation_ = kNone;
+    background_animation_ = NONE;
     return;
   }
-  background_animation_ = IsError() ? kNormalToError: kErrorToNormal;
+  background_animation_ = IsError() ? NORMAL_TO_ERROR: ERROR_TO_NORMAL;
 }
 
 std::string TranslateInfoBarDelegate::GetPageHost() {
   NavigationEntry* entry = tab_contents_->controller().GetActiveEntry();
   return entry ? entry->url().HostNoBrackets() : std::string();
 }
 
 // static
 string16 TranslateInfoBarDelegate::GetLanguageDisplayableName(
     const std::string& language_code) {
@@ skipping 18 matching lines @@
     std::swap(offsets[0], offsets[1]);
     *swap_languages = true;
   } else {
     *swap_languages = false;
   }
 
   strings->push_back(text.substr(0, offsets[0]));
   strings->push_back(text.substr(offsets[0], offsets[1] - offsets[0]));
   strings->push_back(text.substr(offsets[1]));
 }