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

chrome/browser/translate/translate_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_TRANSLATE_TRANSLATE_MANAGER_H_
 #define CHROME_BROWSER_TRANSLATE_TRANSLATE_MANAGER_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 68 matching lines @@
   void ClearTranslateScript() { translate_script_.clear(); }
 
   // content::NotificationObserver implementation:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // net::URLFetcherDelegate implementation:
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 
-  // Used by unit-tests to override the default delay after which the translate
-  // script is fetched again from the translation server.
+  // Used by unit-tests to override some defaults:
+  // Delay after which the translate script is fetched again from the
+  // translation server.
   void set_translate_script_expiration_delay(int delay_ms) {
     translate_script_expiration_delay_ =
         base::TimeDelta::FromMilliseconds(delay_ms);
   }
 
+  // Number of attempts before waiting for a page to be fully reloaded.
+  void set_translate_max_reload_attemps(int attempts) {
+    max_reload_check_attempts_ = attempts;
+  }
+
   // Returns true if the URL can be translated.
   static bool IsTranslatableURL(const GURL& url);
 
   // Fills |languages| with the list of languages that the translate server can
   // translate to and from.
   static void GetSupportedLanguages(std::vector<std::string>* languages);
 
   // Returns the language code that can be used with the Translate method for a
   // specified |chrome_locale|.
   static std::string GetLanguageCode(const std::string& chrome_locale);
@@ skipping 29 matching lines @@
   // in case we failed to get them from the server, or didn't get them just yet.
   static void InitSupportedLanguages();
 
   // Starts the translation process on |tab| containing the page in the
   // |page_lang| language.
   void InitiateTranslation(content::WebContents* web_contents,
                            const std::string& page_lang);
 
   // If the tab identified by |process_id| and |render_id| has been closed, this
   // does nothing, otherwise it calls InitiateTranslation.
-  void InitiateTranslationPosted(int process_id,
-                                 int render_id,
-                                 const std::string& page_lang);
+  void InitiateTranslationPosted(int process_id, int render_id,
+                                 const std::string& page_lang, int attempt);
 
   // Sends a translation request to the RenderView of |web_contents|.
   void DoTranslatePage(content::WebContents* web_contents,
                        const std::string& translate_script,
                        const std::string& source_lang,
                        const std::string& target_lang);
 
   // Shows the after translate or error infobar depending on the details.
   void PageTranslated(content::WebContents* web_contents,
                       PageTranslatedDetails* details);
@@ skipping 37 matching lines @@
 
   base::WeakPtrFactory<TranslateManager> weak_method_factory_;
 
   // The JS injected in the page to do the translation.
   std::string translate_script_;
 
   // Delay after which the translate script is fetched again
   // from the translate server.
   base::TimeDelta translate_script_expiration_delay_;
 
+  // Max number of attempts before checking if a page has been reloaded.
+  int max_reload_check_attempts_;
+
   // Set when the translate JS is currently being retrieved. NULL otherwise.
   scoped_ptr<net::URLFetcher> translate_script_request_pending_;
 
   // Set when the list of languages is currently being retrieved.
   // NULL otherwise.
   scoped_ptr<net::URLFetcher> language_list_request_pending_;
 
   // The list of pending translate requests.  Translate requests are queued when
   // the translate script is not ready and has to be fetched from the translate
   // server.
   std::vector<PendingRequest> pending_requests_;
 
   // The languages supported by the translation server.
   static base::LazyInstance<std::set<std::string> > supported_languages_;
 
   DISALLOW_COPY_AND_ASSIGN(TranslateManager);
 };
 
 #endif  // CHROME_BROWSER_TRANSLATE_TRANSLATE_MANAGER_H_