[Translate] When reloading a page Wait until some content has actually been re-loaded before trigg…

chrome/browser/translate/translate_manager.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_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
@@ skipping 149 matching lines @@
 // application locale.
 const char kHostLocaleQueryName[] = "hl";
 
 // Used in kReportLanguageDetectionErrorURL to specify the original page
 // language.
 const char kSourceLanguageQueryName[] = "sl";
 
 // Used in kReportLanguageDetectionErrorURL to specify the page URL.
 const char kUrlQueryName[] = "u";
 
+// The delay in ms that we'll wait to check if a page has finished loading
+// before attempting a translation.
+const int kTranslateLoadCheckDelayMs = 150;
+
+// The maximum number of attempts we'll do to see if the page has finshed
+// loading before giving up the translation
+const int kMaxTranslateLoadCheckAttempts = 20;
+
 const int kMaxRetryLanguageListFetch = 5;
 const int kTranslateScriptExpirationDelayDays = 1;
 
 GURL AddApiKeyToUrl(const GURL& url) {
   return net::AppendQueryParameter(url, kApiKeyName, google_apis::GetAPIKey());
 }
 
 GURL AddHostLocaleToUrl(const GURL& url) {
   return net::AppendQueryParameter(
       url,
@@ skipping 156 matching lines @@
           translate_tab_helper->language_state().translation_declined()) {
         // Some sites (such as Google map) may trigger sub-frame navigations
         // when the user interacts with the page.  We don't want to show a new
         // infobar if the user already dismissed one in that case.
         return;
       }
       if (entry->GetTransitionType() != content::PAGE_TRANSITION_RELOAD &&
           load_details->type != content::NAVIGATION_TYPE_SAME_PAGE) {
         return;
       }
+
       // When doing a page reload, TAB_LANGUAGE_DETERMINED is not sent,
       // so the translation needs to be explicitly initiated, but only when the
       // page is translatable.
       if (!translate_tab_helper->language_state().page_translatable())
         return;
       // Note that we delay it as the TranslateManager gets this notification
       // before the WebContents and the WebContents processing might remove the
       // current infobars.  Since InitTranslation might add an infobar, it must
       // be done after that.
       MessageLoop::current()->PostTask(FROM_HERE,
           base::Bind(
               &TranslateManager::InitiateTranslationPosted,
               weak_method_factory_.GetWeakPtr(),
               controller->GetWebContents()->GetRenderProcessHost()->GetID(),
               controller->GetWebContents()->GetRenderViewHost()->GetRoutingID(),
-              translate_tab_helper->language_state().original_language()));
+              translate_tab_helper->language_state().original_language(), 0));
       break;
     }
     case chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED: {
       WebContents* tab = content::Source<WebContents>(source).ptr();
       // We may get this notifications multiple times.  Make sure to translate
       // only once.
       TranslateTabHelper* translate_tab_helper =
           TranslateTabHelper::FromWebContents(tab);
       if (!translate_tab_helper)
         return;
@@ skipping 60 matching lines @@
           GetRawDataResource(IDR_TRANSLATE_JS);
       DCHECK(translate_script_.empty());
       str.CopyToString(&translate_script_);
       std::string argument = "('";
       std::string api_key = google_apis::GetAPIKey();
       argument += net::EscapeQueryParamValue(api_key, true);
       argument += "');\n";
       std::string data;
       source->GetResponseAsString(&data);
       translate_script_ += argument + 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,
           base::Bind(&TranslateManager::ClearTranslateScript,
                      weak_method_factory_.GetWeakPtr()),
           translate_script_expiration_delay_);
     }
     // Process any pending requests.
     std::vector<PendingRequest>::const_iterator iter;
@@ skipping 39 matching lines @@
       std::string data;
       source->GetResponseAsString(&data);
       SetSupportedLanguages(data);
     } else {
       VLOG(9) << "Failed to Fetch languages from: " << kLanguageListFetchURL;
     }
   }
 }
 
 TranslateManager::TranslateManager()
-    : weak_method_factory_(this),
-      translate_script_expiration_delay_(
-          base::TimeDelta::FromDays(kTranslateScriptExpirationDelayDays)) {
+  : weak_method_factory_(this),
+    translate_script_expiration_delay_(base::TimeDelta::FromDays(
+        kTranslateScriptExpirationDelayDays)),
+    max_reload_check_attempts_(kMaxTranslateLoadCheckAttempts) {
   notification_registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                               content::NotificationService::AllSources());
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
                               content::NotificationService::AllSources());
   notification_registrar_.Add(this, chrome::NOTIFICATION_PAGE_TRANSLATED,
                               content::NotificationService::AllSources());
 }
 
 void TranslateManager::InitiateTranslation(WebContents* web_contents,
@@ skipping 62 matching lines @@
 
   // Prompts the user if he/she wants the page translated.
   TranslateInfoBarDelegate::Create(
       InfoBarService::FromWebContents(web_contents), false,
       TranslateInfoBarDelegate::BEFORE_TRANSLATE, TranslateErrors::NONE,
       profile->GetPrefs(), ShortcutConfig(),
       language_code, target_lang);
 }
 
 void TranslateManager::InitiateTranslationPosted(
-    int process_id, int render_id, const std::string& page_lang) {
+    int process_id, int render_id, const std::string& page_lang, int attempt) {
   // The tab might have been closed.
   WebContents* web_contents =
       tab_util::GetWebContentsByID(process_id, render_id);
   if (!web_contents)
     return;
 
   TranslateTabHelper* translate_tab_helper =
       TranslateTabHelper::FromWebContents(web_contents);
   if (translate_tab_helper->language_state().translation_pending())
     return;
 
+  // During a reload we need some content to be already loaded before the

[MAD, 2013/05/09 14:05:24]

The text seem to imply that as soon as "some" content is loaded we can run, but
we actually wait until loading is done... I would rephrase the comment.

[Miguel Garcia, 2013/05/10 12:00:02]

Done.

+  // translate script is executed. Otherwise we will run the translate script on
+  // an empty DOM which will fail. Therefore we wait a bit to see if the page
+  // has finished.
+  if ((web_contents->IsLoading()) && attempt < kMaxTranslateLoadCheckAttempts) {
+    int backoff = attempt * max_reload_check_attempts_;
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE, base::Bind(&TranslateManager::InitiateTranslationPosted,
+                              weak_method_factory_.GetWeakPtr(), process_id,
+                              render_id, page_lang, ++attempt),
+        base::TimeDelta::FromMilliseconds(backoff));
+    return;
+  }
+
   InitiateTranslation(web_contents, GetLanguageCode(page_lang));
 }
 
 void TranslateManager::TranslatePage(WebContents* web_contents,
                                      const std::string& source_lang,
                                      const std::string& target_lang) {
   NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
   if (!entry) {
     NOTREACHED();
     return;
@@ skipping 241 matching lines @@
   }
   // Use default URL when command-line argument is not specified, or specified
   // URL is invalid.
   if (translate_script_url.is_empty())
     translate_script_url = GURL(kTranslateScriptURL);
 
   translate_script_url = net::AppendQueryParameter(
       translate_script_url,
       kCallbackQueryName,
       kCallbackQueryValue);
+
   translate_script_url = AddHostLocaleToUrl(translate_script_url);
   translate_script_url = AddApiKeyToUrl(translate_script_url);
 
   translate_script_request_pending_.reset(net::URLFetcher::Create(
       0, translate_script_url, net::URLFetcher::GET, this));
   translate_script_request_pending_->SetLoadFlags(
       net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES);
   translate_script_request_pending_->SetRequestContext(
       g_browser_process->system_request_context());
   translate_script_request_pending_->SetExtraRequestHeaders(
@@ skipping 34 matching lines @@
   // reason so we are more aggressive showing the shortcuts for never translate.
   #if defined(OS_ANDROID)
   config.never_translate_min_count = 1;
   #else
   config.never_translate_min_count = 3;
   #endif  // defined(OS_ANDROID)
 
   config.always_translate_min_count = 3;
   return config;
 }