Move TranslateLanguageList to the Translate component

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/time.h"
 #include "chrome/browser/ui/translate/translate_bubble_model.h"
 #include "components/translate/core/common/translate_errors.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.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:
   // 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
-  // translate to and from.
-  static void GetSupportedLanguages(std::vector<std::string>* languages);
-
-  // Returns the last-updated time when Chrome receives a language list from a
-  // Translate server. Returns null time if Chrome hasn't received any lists.
-  static base::Time GetSupportedLanguagesLastUpdated();
-
-  // 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);
-
-  // Returns true if |language| is supported by the translation server as a
-  // alpha language.
-  static bool IsAlphaLanguage(const std::string& language);
-
   // Returns true if |language| is an Accept language for the user profile.
   static bool IsAcceptLanguage(Profile* profile, const std::string& language);
 
   // 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 language to automatically translate to. |original_language| is
   // the webpage's original language.
   static std::string GetAutoTargetLanguage(const std::string& original_language,
                                            PrefService* prefs);
 
   // Returns true if the new translate bubble is enabled.
   static bool IsTranslateBubbleEnabled();
 
-  // 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.
-  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,
                      const std::string& source_lang,
                      const std::string& target_lang);
@@ skipping 25 matching lines @@
     max_reload_check_attempts_ = attempts;
   }
 
   // The observer class for TranslateManager.
   class Observer {
    public:
     virtual void OnLanguageDetection(
         const LanguageDetectionDetails& details) = 0;
     virtual void OnTranslateError(
         const TranslateErrorDetails& details) = 0;
-    virtual void OnTranslateEvent(
-        const TranslateEventDetails& details) = 0;
   };
 
   // Adds/removes observer.
   void AddObserver(Observer* obs);
   void RemoveObserver(Observer* obs);
 
-  // Notifies to the observers when translate event happens.
-  void NotifyTranslateEvent(const TranslateEventDetails& details);
-
  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 {
@@ skipping 47 matching lines @@
   int max_reload_check_attempts_;
 
   // 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_;
 
   base::WeakPtrFactory<TranslateManager> weak_method_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TranslateManager);
 };
 
 #endif  // CHROME_BROWSER_TRANSLATE_TRANSLATE_MANAGER_H_