Get the list of supported languages from the translate server.

chrome/browser/translate/translate_manager.h

 // Copyright (c) 2011 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_
 #pragma once
 
 #include <map>
 #include <set>
@@ skipping 21 matching lines @@
 // It is a singleton.
 
 class TranslateManager : public NotificationObserver,
                          public URLFetcher::Delegate {
  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.
+  void FetchLanguageListFromTranslateServer(PrefService* prefs);
+
   // 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(TabContents* tab_contents,
                      const std::string& source_lang,
                      const std::string& target_lang);
 
   // Reverts the contents of the page in |tab_contents| to its original
   // language.
   void RevertTranslation(TabContents* tab_contents);
@@ skipping 35 matching lines @@
   // 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* const kLanguageListCallbackName;
+  static const char* const 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(TabContents* tab, 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);
 
   // Sends a translation request to the RenderView of |tab_contents|.
   void DoTranslatePage(TabContents* tab_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(TabContents* tab, PageTranslatedDetails* details);
+  // Shows the after translate or error infobar depending on the details.
+  void PageTranslated(TabContents* tab, PageTranslatedDetails* details);
 
   // Returns true if the passed language has been configured by the user as an
   // accept language.
   bool IsAcceptLanguage(TabContents* tab, const std::string& language);
 
   // Initializes the |accept_languages_| language table based on the associated
   // preference in |prefs|.
   void InitAcceptLanguages(PrefService* prefs);
 
   // Fetches the JS translate script (the script that is injected in the page
@@ skipping 26 matching lines @@
   // The JS injected in the page to do the translation.
   std::string translate_script_;
 
   // Delay in milli-seconds after which the translate script is fetched again
   // from the translate server.
   int translate_script_expiration_delay_;
 
   // Whether the translate JS is currently being retrieved.
   bool translate_script_request_pending_;
 
+  // Whether the list of languages is currently being retrieved.
+  bool 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_