Translate: split supporting language list handling to TranslateLanguageList

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>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
-#include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/time.h"
 #include "chrome/common/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;
@@ skipping 18 matching lines @@
 
 class TranslateManager : public content::NotificationObserver,
                          public net::URLFetcherDelegate {
  public:
   // Returns the singleton instance.
   static TranslateManager* GetInstance();
 
   virtual ~TranslateManager();
 
   // Let the caller decide if and when we should fetch the language list from
-  // the translate server. This is a NOOP if switches::kDisableTranslate is
-  // set or if prefs::kEnableTranslate is set to false.
-  // It will not retry more than kMaxRetryLanguageListFetch times.
+  // the translate server. This is a NOOP if switches::kDisableTranslate is set
+  // or if prefs::kEnableTranslate is set to false.
   void FetchLanguageListFromTranslateServer(PrefService* prefs);
 
   // Allows caller to cleanup pending URLFetcher objects to make sure they
   // get released in the appropriate thread... Mainly for tests.
   void CleanupPendingUlrFetcher();
 
   // Translates the page contents from |source_lang| to |target_lang|.
   // The actual translation might be performed asynchronously if the translate
   // script is not yet available.
   void TranslatePage(content::WebContents* web_contents,
@@ skipping 29 matching lines @@
   }
 
   // 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);
-
-  // Returns true if |language| is supported by the translation server.
-  static bool IsSupportedLanguage(const std::string& language);
-
-  // static const values shared with our browser tests.
-  static const char kLanguageListCallbackName[];
-  static const char kTargetLanguagesKey[];
  protected:
   TranslateManager();
 
  private:
   friend struct DefaultSingletonTraits<TranslateManager>;
 
   // Structure that describes a translate request.
   // Translation may be deferred while the translate script is being retrieved
   // from the translate server.
   struct PendingRequest {
     int render_process_id;
     int render_view_id;
     int page_id;
     std::string source_lang;
     std::string target_lang;
   };
 
-  // Fills supported_languages_ with the list of languages that the translate
-  // server can translate to and from.
-  static void SetSupportedLanguages(const std::string& language_list);
-
-  // Initializes the list of supported languages if it wasn't initialized before
-  // 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, int attempt);
 
@@ skipping 52 matching lines @@
   // 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_