Translate: language list smart updater

chrome/browser/translate/translate_language_list.cc

 // Copyright 2013 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_language_list.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
@@ skipping 89 matching lines @@
 // Constant URL string to fetch server supporting language list.
 const char kLanguageListFetchURL[] =
     "https://translate.googleapis.com/translate_a/l?client=chrome&cb=sl";
 
 // Used in kTranslateScriptURL to request supporting languages list including
 // "alpha languages".
 const char kAlphaLanguageQueryName[] = "alpha";
 const char kAlphaLanguageQueryValue[] = "1";
 
 // Retry parameter for fetching supporting language list.
-const int kMaxRetryLanguageListFetch = 5;
+const int kMaxRetryLanguageListFetchOn5xx = 5;
+
+// Retry parameter for LanguageListFetcher.
+const int kMaxRetryLanguageListFetcher = 16;
 
 // Assign following IDs to URLFetchers so that tests can distinguish each
 // request in order to simiulate respectively.
 const int kFetcherIdForLanguageList = 1;
 const int kFetcherIdForAlphaLanguageList = 2;
 
 // Show a message in chrome:://translate-internals Event Logs.
 void NotifyEvent(int line, const std::string& message) {
   TranslateManager* manager = TranslateManager::GetInstance();
   DCHECK(manager);
@@ skipping 65 matching lines @@
       message += ", " + lang;
   }
   NotifyEvent(__LINE__, message);
 }
 
 }  // namespace
 
 TranslateLanguageList::LanguageListFetcher::LanguageListFetcher(
     bool include_alpha_languages)
   : include_alpha_languages_(include_alpha_languages),
-    state_(IDLE) {
+    state_(IDLE),
+    retry_count_(0) {
 }
 
 TranslateLanguageList::LanguageListFetcher::~LanguageListFetcher() {
 }
 
 bool TranslateLanguageList::LanguageListFetcher::Request(
     const TranslateLanguageList::LanguageListFetcher::Callback& callback) {
-  // This function is not supporsed to be called before previous operaion is not
+  // This function is not supposed to be called before previous operaion is not
   // finished.
   if (state_ == REQUESTING) {
     NOTREACHED();
     return false;
   }
 
+  if (retry_count_ >= kMaxRetryLanguageListFetcher) {
+    NotifyEvent(__LINE__, "Request is omitted due to retry limit");
+    return false;
+  }
+  retry_count_++;
+
   state_ = REQUESTING;
   callback_ = callback;
 
   GURL url = GURL(kLanguageListFetchURL);
   url = TranslateURLUtil::AddHostLocaleToUrl(url);
   url = TranslateURLUtil::AddApiKeyToUrl(url);
   if (include_alpha_languages_) {
     url = net::AppendQueryParameter(url,
                                     kAlphaLanguageQueryName,
                                     kAlphaLanguageQueryValue);
   }
 
   std::string message = base::StringPrintf(
       "%s list fetch starts (URL: %s)",
       include_alpha_languages_ ? "Language" : "Alpha language",
       url.spec().c_str());
   NotifyEvent(__LINE__, message);
 
   fetcher_.reset(net::URLFetcher::Create(
       include_alpha_languages_ ? kFetcherIdForAlphaLanguageList :
                                  kFetcherIdForLanguageList,
       url,
       net::URLFetcher::GET,
       this));
   fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                          net::LOAD_DO_NOT_SAVE_COOKIES);
   fetcher_->SetRequestContext(g_browser_process->system_request_context());
-  fetcher_->SetMaxRetriesOn5xx(kMaxRetryLanguageListFetch);
+  // Set retry parameter for HTTP status code 5xx. This doesn't work against
+  // 106 (net::ERR_INTERNET_DISCONNECTED) and so on.
+  // TranslateLanguageList handles network status, and implements retry.
+  fetcher_->SetMaxRetriesOn5xx(kMaxRetryLanguageListFetchOn5xx);
   fetcher_->Start();
 
   return true;
 }
 
 void TranslateLanguageList::LanguageListFetcher::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(fetcher_.get() == source);
 
   std::string data;
   if (source->GetStatus().status() == net::URLRequestStatus::SUCCESS &&
       source->GetResponseCode() == net::HTTP_OK) {
     state_ = COMPLETED;
     source->GetResponseAsString(&data);
     std::string message = base::StringPrintf(
         "%s list is updated",
         include_alpha_languages_ ? "Alpha language" : "Language");
     NotifyEvent(__LINE__, message);
   } else {
     state_ = FAILED;
     std::string message = base::StringPrintf(
         "Failed to Fetch languages from: %s",
         source->GetURL().spec().c_str());
     NotifyEvent(__LINE__, message);
   }
 
+  // Transfer URLFetcher's ownership before invoking a callback.
   scoped_ptr<const net::URLFetcher> delete_ptr(fetcher_.release());
   callback_.Run(include_alpha_languages_, state_ == COMPLETED, data);
 }
 
 // This must be kept in sync with the &cb= value in the kLanguageListFetchURL.
 const char TranslateLanguageList::kLanguageListCallbackName[] = "sl(";
 const char TranslateLanguageList::kTargetLanguagesKey[] = "tl";
 
 TranslateLanguageList::TranslateLanguageList() {
   // We default to our hard coded list of languages in
   // |kDefaultSupportedLanguages|. This list will be overriden by a server
   // providing supported langauges list.
   for (size_t i = 0; i < arraysize(kDefaultSupportedLanguages); ++i)
     supported_languages_.insert(kDefaultSupportedLanguages[i]);
   UpdateSupportedLanguages();
 
   language_list_fetcher_.reset(new LanguageListFetcher(false));
   alpha_language_list_fetcher_.reset(new LanguageListFetcher(true));
+
+  resource_request_allowed_notifier_.Init(this);
 }
 
 TranslateLanguageList::~TranslateLanguageList() {
 }
 
 void TranslateLanguageList::GetSupportedLanguages(
     std::vector<std::string>* languages) {
   DCHECK(languages && languages->empty());
   std::set<std::string>::const_iterator iter = all_supported_languages_.begin();
   for (; iter != all_supported_languages_.end(); ++iter)
     languages->push_back(*iter);
+
+  // Update language lists if they are not updated after Chrome was launched
+  // for later requests.
+  if (language_list_fetcher_.get() || alpha_language_list_fetcher_.get())
+    RequestLanguageList();
 }
 
 std::string TranslateLanguageList::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);
 }
 
 bool TranslateLanguageList::IsSupportedLanguage(const std::string& language) {
   return all_supported_languages_.count(language) != 0;
 }
 
 bool TranslateLanguageList::IsAlphaLanguage(const std::string& language) {
   // |language| should exist only in the alpha language list.
   return supported_alpha_languages_.count(language) != 0 &&
          supported_languages_.count(language) == 0;
 }
 
 void TranslateLanguageList::RequestLanguageList() {
+  // If resource requests are not allowed, we'll get a callback when they are.
+  if (resource_request_allowed_notifier_.ResourceRequestsAllowed())
+    OnResourceRequestsAllowed();
+}
+
+void TranslateLanguageList::OnResourceRequestsAllowed() {
   if (language_list_fetcher_.get() &&
       (language_list_fetcher_->state() == LanguageListFetcher::IDLE ||
        language_list_fetcher_->state() == LanguageListFetcher::FAILED)) {
     language_list_fetcher_->Request(
         base::Bind(&TranslateLanguageList::OnLanguageListFetchComplete,
                    base::Unretained(this)));
   }
 
   if (alpha_language_list_fetcher_.get() &&
       (alpha_language_list_fetcher_->state() == LanguageListFetcher::IDLE ||
        alpha_language_list_fetcher_->state() == LanguageListFetcher::FAILED)) {
     alpha_language_list_fetcher_->Request(
         base::Bind(&TranslateLanguageList::OnLanguageListFetchComplete,
                    base::Unretained(this)));
   }
 }
 
 void TranslateLanguageList::OnLanguageListFetchComplete(
     bool include_alpha_languages,
     bool success,
     const std::string& data) {
-  if (!success)
+  if (!success) {
+    resource_request_allowed_notifier_.ResourceRequestsAllowed();
+    // Since it fails just now, omit to schedule resource requests if
+    // ResourceRequestAllowedNotifier think it's ready. Otherwise, a callback
+    // will be invoked later to reuest resources again.

[MAD, 2013/06/17 14:48:41]

reuest -> request?

[Takashi Toyoshima, 2013/06/19 10:06:15]

Done.

+    // The LanguageListFetcher has a limit |kMaxRetryLanguageListFetcher| and
+    // aborts re-try not to invoke OnLanguageListFetchComplete anymore if it's
+    // asked to re-try too many times.
     return;
+  }
 
   if (!include_alpha_languages) {
     SetSupportedLanguages(data, &supported_languages_);
     language_list_fetcher_.reset();
   } else {
     SetSupportedLanguages(data, &supported_alpha_languages_);
     alpha_language_list_fetcher_.reset();
   }
   UpdateSupportedLanguages();
 
   last_updated_ = base::Time::Now();
 }
 
 void TranslateLanguageList::UpdateSupportedLanguages() {
   all_supported_languages_.clear();
   std::set<std::string>::const_iterator iter;
   for (iter = supported_languages_.begin();
        iter != supported_languages_.end();
        ++iter) {
     all_supported_languages_.insert(*iter);
   }
   for (iter = supported_alpha_languages_.begin();
        iter != supported_alpha_languages_.end();
        ++iter) {
     all_supported_languages_.insert(*iter);
   }
 }