Fetch the translate script regularly

chrome/browser/translate/translate_manager.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_manager.h"
 
 #include "app/resource_bundle.h"
 #include "base/compiler_specific.h"
 #include "base/histogram.h"
 #include "base/string_util.h"
@@ skipping 111 matching lines @@
 };
 
 const char* const kTranslateScriptURL =
     "http://translate.google.com/translate_a/element.js?"
     "cb=cr.googleTranslate.onTranslateElementLoad";
 const char* const kTranslateScriptHeader =
     "Google-Translate-Element-Mode: library";
 const char* const kReportLanguageDetectionErrorURL =
     "http://translate.google.com/translate_error";
 
+const int kTranslateScriptExpirationDelayMS = 24 * 60 * 60 * 1000;  // 1 day.
+
 }  // namespace
 
 // static
 base::LazyInstance<std::set<std::string> >
     TranslateManager::supported_languages_(base::LINKER_INITIALIZED);
 
 TranslateManager::~TranslateManager() {
 }
 
 // static
@@ skipping 119 matching lines @@
   translate_script_request_pending_ = false;
   bool error =
       (status.status() != URLRequestStatus::SUCCESS || response_code != 200);
 
   if (!error) {
     base::StringPiece str = ResourceBundle::GetSharedInstance().
         GetRawDataResource(IDR_TRANSLATE_JS);
     DCHECK(translate_script_.empty());
     str.CopyToString(&translate_script_);
     translate_script_ += "\n" + data;
+    // We'll expire the cached script after some time, to make sure long running
+    // browsers still get fixes that might get pushed with newer scripts.
+    MessageLoop::current()->PostDelayedTask(FROM_HERE,
+        method_factory_.NewRunnableMethod(
+            &TranslateManager::ClearTranslateScript),
+        translate_script_expiration_delay_);
   }
 
   // Process any pending requests.
   std::vector<PendingRequest>::const_iterator iter;
   for (iter = pending_requests_.begin(); iter != pending_requests_.end();
        ++iter) {
     const PendingRequest& request = *iter;
     TabContents* tab = tab_util::GetTabContentsByID(request.render_process_id,
                                                     request.render_view_id);
     if (!tab) {
@@ skipping 19 matching lines @@
   pending_requests_.clear();
 }
 
 // static
 bool TranslateManager::IsShowingTranslateInfobar(TabContents* tab) {
   return GetTranslateInfoBarDelegate(tab) != NULL;
 }
 
 TranslateManager::TranslateManager()
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+      translate_script_expiration_delay_(kTranslateScriptExpirationDelayMS),
       translate_script_request_pending_(false) {
   notification_registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                               NotificationService::AllSources());
   notification_registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
                               NotificationService::AllSources());
   notification_registrar_.Add(this, NotificationType::PAGE_TRANSLATED,
                               NotificationService::AllSources());
 }
 
 void TranslateManager::InitiateTranslation(TabContents* tab,
@@ skipping 44 matching lines @@
 
   std::string auto_translate_to = tab->language_state().AutoTranslateTo();
   if (!auto_translate_to.empty()) {
     // This page was navigated through a click from a translated page.
     TranslatePage(tab, page_lang, auto_translate_to);
     return;
   }
 
   // Prompts the user if he/she wants the page translated.
   tab->AddInfoBar(TranslateInfoBarDelegate::CreateDelegate(
-      TranslateInfoBarDelegate::kBeforeTranslate, tab,
+      TranslateInfoBarDelegate::BEFORE_TRANSLATE, tab,
       page_lang, target_lang));
 }
 
 void TranslateManager::InitiateTranslationPosted(
     int process_id, int render_id, const std::string& page_lang) {
   // The tab might have been closed.
   TabContents* tab = tab_util::GetTabContentsByID(process_id, render_id);
   if (!tab || tab->language_state().translation_pending())
     return;
 
   InitiateTranslation(tab, page_lang);
 }
 
 void TranslateManager::TranslatePage(TabContents* tab_contents,
                                       const std::string& source_lang,
                                       const std::string& target_lang) {
   NavigationEntry* entry = tab_contents->controller().GetActiveEntry();
   if (!entry) {
     NOTREACHED();
     return;
   }
 
   TranslateInfoBarDelegate* infobar = GetTranslateInfoBarDelegate(tab_contents);
   if (infobar) {
     // We don't show the translating infobar if no translate infobar is already
     // showing (that is the case when the translation was triggered by the
     // "always translate" for example).
     infobar = TranslateInfoBarDelegate::CreateDelegate(
-        TranslateInfoBarDelegate::kTranslating, tab_contents,
+        TranslateInfoBarDelegate::TRANSLATING, tab_contents,
         source_lang, target_lang);
     ShowInfoBar(tab_contents, infobar);
   }
 
   if (!translate_script_.empty()) {
     DoTranslatePage(tab_contents, translate_script_, source_lang, target_lang);
     return;
   }
 
   // The script is not available yet.  Queue that request and query for the
@@ skipping 68 matching lines @@
   } else if (!IsSupportedLanguage(details->source_language)) {
     // TODO(jcivelli): http://crbug.com/9390 We should change the "after
     //                 translate" infobar to support unknown as the original
     //                 language.
     UMA_HISTOGRAM_COUNTS("Translate.ServerReportedUnsupportedLanguage", 1);
     infobar = TranslateInfoBarDelegate::CreateErrorDelegate(
         TranslateErrors::UNSUPPORTED_LANGUAGE, tab,
         details->source_language, details->target_language);
   } else {
     infobar = TranslateInfoBarDelegate::CreateDelegate(
-        TranslateInfoBarDelegate::kAfterTranslate, tab,
+        TranslateInfoBarDelegate::AFTER_TRANSLATE, tab,
         details->source_language, details->target_language);
   }
   ShowInfoBar(tab, infobar);
 }
 
 bool TranslateManager::IsAcceptLanguage(TabContents* tab,
                                         const std::string& language) {
   PrefService* pref_service = tab->profile()->GetPrefs();
   PrefServiceLanguagesMap::const_iterator iter =
       accept_languages_.find(pref_service);
@@ skipping 80 matching lines @@
 TranslateInfoBarDelegate* TranslateManager::GetTranslateInfoBarDelegate(
     TabContents* tab) {
   for (int i = 0; i < tab->infobar_delegate_count(); ++i) {
     TranslateInfoBarDelegate* delegate =
         tab->GetInfoBarDelegateAt(i)->AsTranslateInfoBarDelegate();
     if (delegate)
       return delegate;
   }
   return NULL;
 }