Get the list of supported languages from the translate server.

chrome/browser/translate/translate_manager.cc

 // 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.
 
 #include "chrome/browser/translate/translate_manager.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
+#include "base/json/json_reader.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
+#include "base/values.h"
 #include "chrome/browser/autofill/autofill_manager.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/language_state.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/translate/page_translated_details.h"
 #include "chrome/browser/translate/translate_infobar_delegate.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
@@ skipping 94 matching lines @@
     "yi",     // Yiddish
 };
 
 const char* const kTranslateScriptURL =
     "http://translate.google.com/translate_a/element.js?"
     "cb=cr.googleTranslate.onTranslateElementLoad";
 const char* const kTranslateScriptHeader =
     "Google-Translate-Element-Mode: library";
 const char* const kReportLanguageDetectionErrorURL =
     "http://translate.google.com/translate_error";
-
+const char* const kLanguageListFetchURL =
+    "http://translate.googleapis.com/translate_a/l?client=chrome&cb=sl";
+const int kMaxRetryLanguageListFetch = 5;
 const int kTranslateScriptExpirationDelayMS = 24 * 60 * 60 * 1000;  // 1 day.
 
 }  // namespace
 
+// This must be kept in sync with the &cb= value in the kLanguageListFetchURL.
+const char* const TranslateManager::kLanguageListCallbackName = "sl(";
+const char* const TranslateManager::kTargetLanguagesKey = "tl";
+
 // static
 base::LazyInstance<std::set<std::string> >
     TranslateManager::supported_languages_(base::LINKER_INITIALIZED);
 
 TranslateManager::~TranslateManager() {
 }
 
 // static
 TranslateManager* TranslateManager::GetInstance() {
   return Singleton<TranslateManager>::get();
 }
 
 // static
 bool TranslateManager::IsTranslatableURL(const GURL& url) {
   // A URLs is translatable unless it is one of the following:
   // - an internal URL (chrome:// and others)
   // - the devtools (which is considered UI)
   // - an FTP page (as FTP pages tend to have long lists of filenames that may
   //   confuse the CLD)
   return !url.SchemeIs(chrome::kChromeUIScheme) &&
          !url.SchemeIs(chrome::kChromeDevToolsScheme) &&
          !url.SchemeIs(chrome::kFtpScheme);
 }
 
 // static
+void TranslateManager::SetSupportedLanguages(const std::string& language_list) {
+  // The format is:
+  // sl({'sl': {'XX': 'LanguageName', ...}, 'tl': {'XX': 'LanguageName', ...}})
+  // Where "sl(" is set in kLanguageListCallbackName
+  // and 'tl' is kTargetLanguagesKey
+  if (!StartsWithASCII(language_list, kLanguageListCallbackName, false) ||
+      !EndsWith(language_list, ")", false)) {
+    // We don't have a NOTREACHED here since this can happen in ui_tests, even
+    // though the the BrowserMain function won't call us with parameters.ui_task
+    // is NULL some tests don't set it, so we must bail here.
+    return;
+  }
+  static const size_t kLanguageListCallbackNameLength =
+      strlen(kLanguageListCallbackName);
+  std::string languages_json = language_list.substr(
+      kLanguageListCallbackNameLength,
+      language_list.size() - kLanguageListCallbackNameLength - 1);
+  // JSON doesn't support single quotes though this is what is used on the
+  // translate server so we must replace them with double quotes.
+  ReplaceSubstringsAfterOffset(&languages_json, 0, "'", "\"");
+  scoped_ptr<Value> json_value(base::JSONReader::Read(languages_json, true));
+  if (json_value == NULL || !json_value->IsType(Value::TYPE_DICTIONARY)) {
+    NOTREACHED();
+    return;
+  }
+  // The first level dictionary contains two sub-dict, one for source languages
+  // and the other for target languages, we want to use the target languages.
+  DictionaryValue* language_dict =
+      static_cast<DictionaryValue*>(json_value.get());
+  DictionaryValue* target_languages = NULL;
+  if (!language_dict->GetDictionary(kTargetLanguagesKey, &target_languages) ||
+      target_languages == NULL) {
+    NOTREACHED();
+    return;
+  }
+  // Now we can clear our current state...
+  std::set<std::string>* supported_languages = supported_languages_.Pointer();
+  supported_languages->clear();
+  // ... and replace it with the values we just fetched from the server.
+  DictionaryValue::key_iterator iter = target_languages->begin_keys();
+  for (; iter != target_languages->end_keys(); ++iter)
+    supported_languages_.Pointer()->insert(*iter);
+}
+
+// static
+void TranslateManager::InitSupportedLanguages() {
+  // If our list of supported languages have not been set yet, we default
+  // to our hard coded list of languages in kSupportedLanguages.
+  if (supported_languages_.Pointer()->empty()) {
+    for (size_t i = 0; i < arraysize(kSupportedLanguages); ++i)
+      supported_languages_.Pointer()->insert(kSupportedLanguages[i]);
+  }
+}
+
+// static
 void TranslateManager::GetSupportedLanguages(
     std::vector<std::string>* languages) {
   DCHECK(languages && languages->empty());
-  for (size_t i = 0; i < arraysize(kSupportedLanguages); ++i)
-    languages->push_back(kSupportedLanguages[i]);
+  InitSupportedLanguages();
+  std::set<std::string>* supported_languages = supported_languages_.Pointer();
+  std::set<std::string>::const_iterator iter = supported_languages->begin();
+  for (; iter != supported_languages->end(); ++iter)
+    languages->push_back(*iter);
 }
 
 // static
 std::string TranslateManager::GetLanguageCode(
     const std::string& chrome_locale) {
   // Only remove the country code for country specific languages we don't
   // support specifically yet.
   if (IsSupportedLanguage(chrome_locale))
     return chrome_locale;
 
   size_t hypen_index = chrome_locale.find('-');
   if (hypen_index == std::string::npos)
     return chrome_locale;
   return chrome_locale.substr(0, hypen_index);
 }
 
 // static
 bool TranslateManager::IsSupportedLanguage(const std::string& page_language) {
-  std::set<std::string>* supported_languages = supported_languages_.Pointer();
-  if (supported_languages->empty()) {
-    for (size_t i = 0; i < arraysize(kSupportedLanguages); ++i)
-      supported_languages->insert(kSupportedLanguages[i]);
-  }
-  return supported_languages->find(page_language) != supported_languages->end();
+  InitSupportedLanguages();
+  return supported_languages_.Pointer()->count(page_language) != 0;
 }
 
 void TranslateManager::Observe(NotificationType type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::NAV_ENTRY_COMMITTED: {
       NavigationController* controller =
           Source<NavigationController>(source).ptr();
       content::LoadCommittedDetails* load_details =
@@ skipping 85 matching lines @@
   }
 }
 
 void TranslateManager::OnURLFetchComplete(const URLFetcher* source,
                                           const GURL& url,
                                           const net::URLRequestStatus& status,
                                           int response_code,
                                           const net::ResponseCookies& cookies,
                                           const std::string& data) {
   scoped_ptr<const URLFetcher> delete_ptr(source);
-  DCHECK(translate_script_request_pending_);
-  translate_script_request_pending_ = false;
+  DCHECK(translate_script_request_pending_ || language_list_request_pending_);
+  // We quickly recognize that we are handling a translate script request
+  // if we don't have a language_list_request_pending_. Otherwise we do the
+  // more expensive check of confirming we got the kTranslateScriptURL in the
+  // rare case where we would have both requests pending at the same time.
+  bool translate_script_request = !language_list_request_pending_ ||
+      url == GURL(kTranslateScriptURL);
+  // Here we make sure that if we didn't get the translate_script_request,
+  // we actually got a language_list_request.
+  DCHECK(translate_script_request || url == GURL(kLanguageListFetchURL));
+  if (translate_script_request)
+    translate_script_request_pending_ = false;
+  else
+    language_list_request_pending_ = false;
+
   bool error =
       (status.status() != net::URLRequestStatus::SUCCESS ||
        response_code != 200);
 
-  if (!error) {
-    base::StringPiece str = ResourceBundle::GetSharedInstance().
-        GetRawDataResource(IDR_TRANSLATE_JS);
-    DCHECK(translate_script_.empty());
-    str.CopyToString(&translate_script_);
-    translate_script_ += "\n" + data;
-    // We'll expire the cached script after some time, to make sure long running
-    // browsers still get fixes that might get pushed with newer scripts.
-    MessageLoop::current()->PostDelayedTask(FROM_HERE,
-        method_factory_.NewRunnableMethod(
-            &TranslateManager::ClearTranslateScript),
-        translate_script_expiration_delay_);
+  if (translate_script_request) {
+    if (!error) {
+      base::StringPiece str = ResourceBundle::GetSharedInstance().
+          GetRawDataResource(IDR_TRANSLATE_JS);
+      DCHECK(translate_script_.empty());
+      str.CopyToString(&translate_script_);
+      translate_script_ += "\n" + data;
+      // We'll expire the cached script after some time, to make sure long
+      // running browsers still get fixes that might get pushed with newer
+      // scripts.
+      MessageLoop::current()->PostDelayedTask(FROM_HERE,
+          method_factory_.NewRunnableMethod(
+              &TranslateManager::ClearTranslateScript),
+          translate_script_expiration_delay_);
+    }
+    // Process any pending requests.
+    std::vector<PendingRequest>::const_iterator iter;
+    for (iter = pending_requests_.begin(); iter != pending_requests_.end();
+         ++iter) {
+      const PendingRequest& request = *iter;
+      TabContents* tab = tab_util::GetTabContentsByID(request.render_process_id,
+                                                      request.render_view_id);
+      if (!tab) {
+        // The tab went away while we were retrieving the script.
+        continue;
+      }
+      NavigationEntry* entry = tab->controller().GetActiveEntry();
+      if (!entry || entry->page_id() != request.page_id) {
+        // We navigated away from the page the translation was triggered on.
+        continue;
+      }
+
+      if (error) {
+        ShowInfoBar(tab, TranslateInfoBarDelegate::CreateErrorDelegate(
+            TranslateErrors::NETWORK, tab,
+            request.source_lang, request.target_lang));
+      } else {
+        // Translate the page.
+        DoTranslatePage(tab, translate_script_,
+                        request.source_lang, request.target_lang);
+      }
+    }
+    pending_requests_.clear();
+  } else {  // if (translate_script_request)
+    if (!error)
+      SetSupportedLanguages(data);
+    else
+      VLOG(1) << "Failed to Fetch languages from: " << kLanguageListFetchURL;
   }
-
-  // Process any pending requests.
-  std::vector<PendingRequest>::const_iterator iter;
-  for (iter = pending_requests_.begin(); iter != pending_requests_.end();
-       ++iter) {
-    const PendingRequest& request = *iter;
-    TabContents* tab = tab_util::GetTabContentsByID(request.render_process_id,
-                                                    request.render_view_id);
-    if (!tab) {
-      // The tab went away while we were retrieving the script.
-      continue;
-    }
-    NavigationEntry* entry = tab->controller().GetActiveEntry();
-    if (!entry || entry->page_id() != request.page_id) {
-      // We navigated away from the page the translation was triggered on.
-      continue;
-    }
-
-    if (error) {
-      ShowInfoBar(tab, TranslateInfoBarDelegate::CreateErrorDelegate(
-          TranslateErrors::NETWORK, tab,
-          request.source_lang, request.target_lang));
-    } else {
-      // Translate the page.
-      DoTranslatePage(tab, translate_script_,
-                      request.source_lang, request.target_lang);
-    }
-  }
-  pending_requests_.clear();
 }
 
 // static
 bool TranslateManager::IsShowingTranslateInfobar(TabContents* tab) {
   return GetTranslateInfoBarDelegate(tab) != NULL;
 }
 
 TranslateManager::TranslateManager()
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       translate_script_expiration_delay_(kTranslateScriptExpirationDelayMS),
-      translate_script_request_pending_(false) {
+      translate_script_request_pending_(false),
+      language_list_request_pending_(false) {
   notification_registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                               NotificationService::AllSources());
   notification_registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
                               NotificationService::AllSources());
   notification_registrar_.Add(this, NotificationType::PAGE_TRANSLATED,
                               NotificationService::AllSources());
 }
 
 void TranslateManager::InitiateTranslation(TabContents* tab,
                                            const std::string& page_lang) {
@@ skipping 252 matching lines @@
     // black-listed.
     // TODO(jungshik): Once we determine that it's safe to remove English from
     // the default Accept-Language values for most locales, remove this
     // special-casing.
     if (accept_lang != "en" || is_ui_english)
       accept_langs_set.insert(accept_lang);
   }
   accept_languages_[prefs] = accept_langs_set;
 }
 
+void TranslateManager::FetchLanguageListFromTranslateServer(
+    PrefService* prefs) {
+  if (language_list_request_pending_)
+    return;
+
+  // We don't want to do this when translate is disabled.
+  DCHECK(prefs != NULL);
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kDisableTranslate) ||
+      (prefs != NULL && !prefs->GetBoolean(prefs::kEnableTranslate))) {
+    return;
+  }
+
+  language_list_request_pending_ = true;
+  URLFetcher* fetcher = URLFetcher::Create(1, GURL(kLanguageListFetchURL),
+                                           URLFetcher::GET, this);
+  fetcher->set_request_context(Profile::GetDefaultRequestContext());
+  fetcher->set_max_retries(kMaxRetryLanguageListFetch);
+  fetcher->Start();
+}
+
 void TranslateManager::RequestTranslateScript() {
   if (translate_script_request_pending_)
     return;
 
   translate_script_request_pending_ = true;
   URLFetcher* fetcher = URLFetcher::Create(0, GURL(kTranslateScriptURL),
                                            URLFetcher::GET, this);
   fetcher->set_request_context(Profile::GetDefaultRequestContext());
   fetcher->set_extra_request_headers(kTranslateScriptHeader);
   fetcher->Start();
@@ skipping 26 matching lines @@
   TabContentsWrapper* wrapper =
       TabContentsWrapper::GetCurrentWrapperForContents(tab);
   for (size_t i = 0; i < wrapper->infobar_count(); ++i) {
     TranslateInfoBarDelegate* delegate =
         wrapper->GetInfoBarDelegateAt(i)->AsTranslateInfoBarDelegate();
     if (delegate)
       return delegate;
   }
   return NULL;
 }