Move TranslateLanguageList to the Translate component

components/translate/core/browser/translate_language_list.cc

Index: components/translate/core/browser/translate_language_list.cc
diff --git a/chrome/browser/translate/translate_language_list.cc b/components/translate/core/browser/translate_language_list.cc
similarity index 87%
rename from chrome/browser/translate/translate_language_list.cc
rename to components/translate/core/browser/translate_language_list.cc
index 89cbf2db40f96882a5fe3994162e3e1329d04d07..c454503742e6127e69f237c9bef9fe2127148cc2 100644
--- a/chrome/browser/translate/translate_language_list.cc
+++ b/components/translate/core/browser/translate_language_list.cc
@@ -2,7 +2,7 @@
 // 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_language_list.h"
+#include "components/translate/core/browser/translate_language_list.h"
 
 #include <set>
 
@@ -13,12 +13,11 @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
-#include "chrome/browser/translate/translate_manager.h"
-#include "chrome/browser/translate/translate_url_util.h"
 #include "components/translate/core/browser/translate_browser_metrics.h"
 #include "components/translate/core/browser/translate_download_manager.h"
 #include "components/translate/core/browser/translate_event_details.h"
 #include "components/translate/core/browser/translate_url_fetcher.h"
+#include "components/translate/core/browser/translate_url_util.h"
 #include "net/base/url_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
@@ -109,107 +108,6 @@ bool update_is_disabled = false;
 // Retry parameter for fetching.
 const int kMaxRetryOn5xx = 5;
 
-// Show a message in chrome:://translate-internals Event Logs.
-void NotifyEvent(int line, const std::string& message) {
-  TranslateManager* manager = TranslateManager::GetInstance();
-  DCHECK(manager);
-
-  TranslateEventDetails details(__FILE__, line, message);
-  manager->NotifyTranslateEvent(details);
-}
-
-// Parses |language_list| containing the list of languages that the translate
-// server can translate to and from, and fills |set| with them.
-void SetSupportedLanguages(const std::string& language_list,
-                           std::set<std::string>* target_language_set,
-                           std::set<std::string>* alpha_language_set) {
-  DCHECK(target_language_set);
-  DCHECK(alpha_language_set);
-
-  // The format is:
-  // sl({
-  //   "sl": {"XX": "LanguageName", ...},
-  //   "tl": {"XX": "LanguageName", ...},
-  //   "al": {"XX": 1, ...}
-  // })
-  // Where "sl(" is set in kLanguageListCallbackName, "tl" is
-  // kTargetLanguagesKey and "al" kAlphaLanguagesKey.
-  if (!StartsWithASCII(language_list,
-                       TranslateLanguageList::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(TranslateLanguageList::kLanguageListCallbackName);
-  std::string languages_json = language_list.substr(
-      kLanguageListCallbackNameLength,
-      language_list.size() - kLanguageListCallbackNameLength - 1);
-  scoped_ptr<base::Value> json_value(
-      base::JSONReader::Read(languages_json, base::JSON_ALLOW_TRAILING_COMMAS));
-  if (json_value == NULL || !json_value->IsType(base::Value::TYPE_DICTIONARY)) {
-    NOTREACHED();
-    return;
-  }
-  // The first level dictionary contains three sub-dict, first for source
-  // languages and second for target languages, we want to use the target
-  // languages. The last is for alpha languages.
-  base::DictionaryValue* language_dict =
-      static_cast<base::DictionaryValue*>(json_value.get());
-  base::DictionaryValue* target_languages = NULL;
-  if (!language_dict->GetDictionary(TranslateLanguageList::kTargetLanguagesKey,
-                                    &target_languages) ||
-      target_languages == NULL) {
-    NOTREACHED();
-    return;
-  }
-
-  const std::string& locale =
-      TranslateDownloadManager::GetInstance()->application_locale();
-
-  // Now we can clear language list.
-  target_language_set->clear();
-  std::string message;
-  // ... and replace it with the values we just fetched from the server.
-  for (base::DictionaryValue::Iterator iter(*target_languages);
-       !iter.IsAtEnd();
-       iter.Advance()) {
-    const std::string& lang = iter.key();
-    if (!l10n_util::IsLocaleNameTranslated(lang.c_str(), locale)) {
-      TranslateBrowserMetrics::ReportUndisplayableLanguage(lang);
-      continue;
-    }
-    target_language_set->insert(lang);
-    if (message.empty())
-      message += lang;
-    else
-      message += ", " + lang;
-  }
-  NotifyEvent(__LINE__, message);
-
-  // Get the alpha languages. The "al" parameter could be abandoned.
-  base::DictionaryValue* alpha_languages = NULL;
-  if (!language_dict->GetDictionary(TranslateLanguageList::kAlphaLanguagesKey,
-                                    &alpha_languages) ||
-      alpha_languages == NULL) {
-    return;
-  }
-
-  // We assume that the alpha languages are included in the above target
-  // languages, and don't use UMA or NotifyEvent.
-  alpha_language_set->clear();
-  for (base::DictionaryValue::Iterator iter(*alpha_languages);
-       !iter.IsAtEnd(); iter.Advance()) {
-    const std::string& lang = iter.key();
-    if (!l10n_util::IsLocaleNameTranslated(lang.c_str(), locale))
-      continue;
-    alpha_language_set->insert(lang);
-  }
-}
-
 }  // namespace
 
 // This must be kept in sync with the &cb= value in the kLanguageListFetchURL.
@@ -217,7 +115,8 @@ const char TranslateLanguageList::kLanguageListCallbackName[] = "sl(";
 const char TranslateLanguageList::kTargetLanguagesKey[] = "tl";
 const char TranslateLanguageList::kAlphaLanguagesKey[] = "al";
 
-TranslateLanguageList::TranslateLanguageList() {
+TranslateLanguageList::TranslateLanguageList()
+    : resource_requests_allowed_(false), request_pending_(false) {
   // We default to our hard coded list of languages in
   // |kDefaultSupportedLanguages|. This list will be overriden by a server
   // providing supported langauges list.
@@ -231,8 +130,7 @@ TranslateLanguageList::TranslateLanguageList() {
   language_list_fetcher_->set_max_retry_on_5xx(kMaxRetryOn5xx);
 }
 
-TranslateLanguageList::~TranslateLanguageList() {
-}
+TranslateLanguageList::~TranslateLanguageList() {}
 
 void TranslateLanguageList::GetSupportedLanguages(
     std::vector<std::string>* languages) {
@@ -270,20 +168,19 @@ bool TranslateLanguageList::IsAlphaLanguage(const std::string& language) {
 
 void TranslateLanguageList::RequestLanguageList() {
   // If resource requests are not allowed, we'll get a callback when they are.
-  if (resource_request_allowed_notifier_.ResourceRequestsAllowed())
-    OnResourceRequestsAllowed();
-}
+  if (!resource_requests_allowed_)

[MAD, 2014/02/03 14:02:43]

Shouldn't we set request_pending_ to true before returning? I don't see it set
to true anywhere...

[droger, 2014/02/03 15:07:21]

Oops, thanks for catching this.

+    return;
+
+  request_pending_ = false;
 
-void TranslateLanguageList::OnResourceRequestsAllowed() {
   if (language_list_fetcher_.get() &&
       (language_list_fetcher_->state() == TranslateURLFetcher::IDLE ||
        language_list_fetcher_->state() == TranslateURLFetcher::FAILED)) {
     GURL url = GURL(kLanguageListFetchURL);
     url = TranslateURLUtil::AddHostLocaleToUrl(url);
     url = TranslateURLUtil::AddApiKeyToUrl(url);
-    url = net::AppendQueryParameter(url,
-                                    kAlphaLanguageQueryName,
-                                    kAlphaLanguageQueryValue);
+    url = net::AppendQueryParameter(
+        url, kAlphaLanguageQueryName, kAlphaLanguageQueryValue);
 
     std::string message = base::StringPrintf(
         "Language list including alpha languages fetch starts (URL: %s)",
@@ -299,6 +196,19 @@ void TranslateLanguageList::OnResourceRequestsAllowed() {
   }
 }
 
+void TranslateLanguageList::SetResourceRequestsAllowed(bool allowed) {
+  resource_requests_allowed_ = allowed;
+  if (resource_requests_allowed_ && request_pending_) {
+    RequestLanguageList();
+    DCHECK(!request_pending_);
+  }
+}
+
+scoped_ptr<TranslateLanguageList::EventCallbackList::Subscription>
+TranslateLanguageList::RegisterEventCallback(const EventCallback& callback) {
+  return callback_list_.Add(callback);
+}
+
 // static
 void TranslateLanguageList::DisableUpdate() {
   update_is_disabled = true;
@@ -323,8 +233,99 @@ void TranslateLanguageList::OnLanguageListFetchComplete(
 
   DCHECK_EQ(kFetcherId, id);
 
-  SetSupportedLanguages(data, &all_supported_languages_, &alpha_languages_);
+  SetSupportedLanguages(data);
   language_list_fetcher_.reset();
 
   last_updated_ = base::Time::Now();
 }
+
+void TranslateLanguageList::NotifyEvent(int line, const std::string& message) {
+  TranslateEventDetails details(__FILE__, line, message);
+  callback_list_.Notify(details);
+}
+
+void TranslateLanguageList::SetSupportedLanguages(
+    const std::string& language_list) {
+  // The format is:
+  // sl({
+  //   "sl": {"XX": "LanguageName", ...},
+  //   "tl": {"XX": "LanguageName", ...},
+  //   "al": {"XX": 1, ...}
+  // })
+  // Where "sl(" is set in kLanguageListCallbackName, "tl" is
+  // kTargetLanguagesKey and "al" kAlphaLanguagesKey.
+  if (!StartsWithASCII(language_list,
+                       TranslateLanguageList::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(TranslateLanguageList::kLanguageListCallbackName);
+  std::string languages_json = language_list.substr(
+      kLanguageListCallbackNameLength,
+      language_list.size() - kLanguageListCallbackNameLength - 1);
+  scoped_ptr<base::Value> json_value(
+      base::JSONReader::Read(languages_json, base::JSON_ALLOW_TRAILING_COMMAS));
+  if (json_value == NULL || !json_value->IsType(base::Value::TYPE_DICTIONARY)) {
+    NOTREACHED();
+    return;
+  }
+  // The first level dictionary contains three sub-dict, first for source
+  // languages and second for target languages, we want to use the target
+  // languages. The last is for alpha languages.
+  base::DictionaryValue* language_dict =
+      static_cast<base::DictionaryValue*>(json_value.get());
+  base::DictionaryValue* target_languages = NULL;
+  if (!language_dict->GetDictionary(TranslateLanguageList::kTargetLanguagesKey,
+                                    &target_languages) ||
+      target_languages == NULL) {
+    NOTREACHED();
+    return;
+  }
+
+  const std::string& locale =
+      TranslateDownloadManager::GetInstance()->application_locale();
+
+  // Now we can clear language list.
+  all_supported_languages_.clear();
+  std::string message;
+  // ... and replace it with the values we just fetched from the server.
+  for (base::DictionaryValue::Iterator iter(*target_languages);
+       !iter.IsAtEnd();
+       iter.Advance()) {
+    const std::string& lang = iter.key();
+    if (!l10n_util::IsLocaleNameTranslated(lang.c_str(), locale)) {
+      TranslateBrowserMetrics::ReportUndisplayableLanguage(lang);
+      continue;
+    }
+    all_supported_languages_.insert(lang);
+    if (message.empty())
+      message += lang;
+    else
+      message += ", " + lang;
+  }
+  NotifyEvent(__LINE__, message);
+
+  // Get the alpha languages. The "al" parameter could be abandoned.
+  base::DictionaryValue* alpha_languages = NULL;
+  if (!language_dict->GetDictionary(TranslateLanguageList::kAlphaLanguagesKey,
+                                    &alpha_languages) ||
+      alpha_languages == NULL) {
+    return;
+  }
+
+  // We assume that the alpha languages are included in the above target
+  // languages, and don't use UMA or NotifyEvent.
+  alpha_languages_.clear();
+  for (base::DictionaryValue::Iterator iter(*alpha_languages);
+       !iter.IsAtEnd(); iter.Advance()) {
+    const std::string& lang = iter.key();
+    if (!l10n_util::IsLocaleNameTranslated(lang.c_str(), locale))
+      continue;
+    alpha_languages_.insert(lang);
+  }
+}