Refactoring: Create TranslateScript from TranslateManager

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 <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/time.h"
 #include "chrome/common/translate/translate_errors.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
-#include "net/url_request/url_fetcher_delegate.h"
 
 template <typename T> struct DefaultSingletonTraits;
 class GURL;
 struct LanguageDetectionDetails;
 struct PageTranslatedDetails;
 class PrefService;
 class Profile;
 struct ShortcutConfiguration;
 class TranslateAcceptLanguages;
 struct TranslateErrorDetails;
 struct TranslateEventDetails;
 class TranslateInfoBarDelegate;
 class TranslateLanguageList;
+class TranslateScript;
 
 namespace content {
 class WebContents;
 }
 
 namespace net {
 class URLFetcher;
 }
 
 // The TranslateManager class is responsible for showing an info-bar when a page
 // in a language different than the user language is loaded.  It triggers the
 // page translation the user requests.
 // It is a singleton.
 
-class TranslateManager : public content::NotificationObserver,
-                         public net::URLFetcherDelegate {
+class TranslateManager : public content::NotificationObserver {
  public:
   // Returns the singleton instance.
   static TranslateManager* GetInstance();
 
   virtual ~TranslateManager();
 
   // 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
@@ skipping 37 matching lines @@
   // Reverts the contents of the page in |web_contents| to its original
   // language.
   void RevertTranslation(content::WebContents* web_contents);
 
   // Reports to the Google translate server that a page language was incorrectly
   // detected.  This call is initiated by the user selecting the "report" menu
   // under options in the translate infobar.
   void ReportLanguageDetectionError(content::WebContents* web_contents);
 
   // Clears the translate script, so it will be fetched next time we translate.
-  void ClearTranslateScript() { translate_script_.clear(); }
+  void ClearTranslateScript();
 
   // 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 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);
-  }
+  void SetTranslateScriptExpirationDelay(int 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;
   }
 
   // The observer class for TranslateManager.
   class Observer {
    public:
     virtual void OnLanguageDetection(
@@ skipping 41 matching lines @@
   // 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);
 
-  // Fetches the JS translate script (the script that is injected in the page
-  // to translate it).
-  void RequestTranslateScript();
+  void OnTranslateScriptFetchComplete(bool success, const std::string& data);
+
+  // Processes any pending requests.
+  void ProcessPendingRequests(bool error);
 
   // Notifies to the observers when a language is detected.
   void NotifyLanguageDetection(const LanguageDetectionDetails& details);
 
   // Notifies to the observers when translate failed.
   void NotifyTranslateError(const TranslateErrorDetails& details);
 
   // Returns the language to translate to. The language returned is the
   // first language found in the following list that is supported by the
   // translation service:
   //     the UI language
   //     the accept-language list
   // If no language is found then an empty string is returned.
   static std::string GetTargetLanguage(PrefService* prefs);
 
   // Returns the different parameters used to decide whether extra shortcuts
   // are needed.
   static ShortcutConfiguration ShortcutConfig();
 
   content::NotificationRegistrar notification_registrar_;
 
   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_;
-
   // 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_;
 
   // List of registered observers.
   ObserverList<Observer> observer_list_;
 
   // An instance of TranslateLanguageList which manages supported language list.
   scoped_ptr<TranslateLanguageList> language_list_;
 
+  // An instance of TranslateScript which manages JavaScript source for
+  // Translate.
+  scoped_ptr<TranslateScript> script_;
+
   // An instance of TranslateAcceptLanguages which manages Accept languages of
   // each profiles.
   scoped_ptr<TranslateAcceptLanguages> accept_languages_;
 
   DISALLOW_COPY_AND_ASSIGN(TranslateManager);
 };
 
 #endif  // CHROME_BROWSER_TRANSLATE_TRANSLATE_MANAGER_H_