CrOS online EULA: support localization, change timeout

chrome/browser/ui/webui/about_ui.cc

 // 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.
 
 #include "chrome/browser/ui/webui/about_ui.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 85 matching lines @@
 using content::WebContents;
 
 namespace {
 
 const char kCreditsJsPath[] = "credits.js";
 const char kMemoryJsPath[] = "memory.js";
 const char kMemoryCssPath[] = "about_memory.css";
 const char kStatsJsPath[] = "stats.js";
 const char kStringsJsPath[] = "strings.js";
 // chrome://terms falls back to offline page after kOnlineTermsTimeoutSec.
-const int kOnlineTermsTimeoutSec = 10;
+const int kOnlineTermsTimeoutSec = 7;
 
 // When you type about:memory, it actually loads this intermediate URL that
 // redirects you to the final page. This avoids the problem where typing
 // "about:memory" on the new tab page or any other page where a process
 // transition would occur to the about URL will cause some confusion.
 //
 // The problem is that during the processing of the memory page, there are two
 // processes active, the original and the destination one. This can create the
 // impression that we're using more resources than we actually are. This
 // redirect solves the problem by eliminating the process transition during the
@@ skipping 21 matching lines @@
   void BindProcessMetrics(DictionaryValue* data,
                           ProcessMemoryInformation* info);
   void AppendProcess(ListValue* child_data, ProcessMemoryInformation* info);
 
   content::URLDataSource::GotDataCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(AboutMemoryHandler);
 };
 
 #if defined(OS_CHROMEOS)
+
+// Contains pairs of corresponding locales for Chrome and Google URLs.
+struct Chrome2GoogleLocaleMapping {
+  const char* chrome_locale;
+  const char* google_locale;
+};
+
+// List of locales constant which are different for Google URL
+const Chrome2GoogleLocaleMapping locale_mapping[] = {

[Evan Stade, 2013/05/06 18:06:05]

When I launch (desktop) Chrome in a foreign locale, URLs like
https://support.google.com/chromeos/?p=simple_scrolling (which don't have any
kind of embedded locale) automatically redirect me to the correctly localized
site. It's handled server-side using the accept-language HTTP header. The same
should be done here.

[Nikita (slow), 2013/05/06 18:10:15]

Evan, per my understanding it seems to be that this EULA content is served from
a different  frontend that doesn't support such behavior (static content).

For instance hl=[locale] works for online help center (your example) but doesn't
work here.

Of course we would like to get there and have server side support this the same
way it is supported on online Help center frontend but we need to have some
solution on Chrome side for now (M28).

+    {"de-AT", "de"},
+    {"de-CH", "de"},
+    {"de-DE", "de"},
+    {"en-GB", "en_uk"},
+    {"fr-CA", "fr"},
+    {"fr-CH", "fr"},
+    {"fr-FR", "fr"},
+    {"he", "iw"},
+    {"it-CH", "it"},
+    {"it-IT", "it"}
+};
+
+// Returns server side locale if it's different from the Chrome one.
+// Otherwise, returns NULL.
+const char* TranslateChromeLangToGoogle(const char* chrome_locale) {
+  for (std::size_t i = 0; i < arraysize(locale_mapping); ++i) {
+    if (LowerCaseEqualsASCII(chrome_locale,
+                             locale_mapping[i].chrome_locale)) {
+      return locale_mapping[i].google_locale;
+    }
+  }
+  return NULL;
+}
+
 // Helper class that fetches the online Chrome OS terms. Empty string is
 // returned once fetching failed or exceeded |kOnlineTermsTimeoutSec|.
 class ChromeOSOnlineTermsHandler : public net::URLFetcherDelegate {
  public:
   typedef base::Callback<void (ChromeOSOnlineTermsHandler*)> FetchCallback;
 
-  explicit ChromeOSOnlineTermsHandler(const FetchCallback& callback)
+  explicit ChromeOSOnlineTermsHandler(const FetchCallback& callback,
+                                      const std::string& locale)
       : fetch_callback_(callback) {
-    eula_fetcher_.reset(net::URLFetcher::Create(
-        GURL(l10n_util::GetStringUTF16(IDS_EULA_POLICY_URL)),
-        net::URLFetcher::GET,
-        this));
+    const char* google_lang = TranslateChromeLangToGoogle(locale.c_str());
+    if (!google_lang)
+      google_lang = locale.c_str();
+    std::string eula_URL = base::StringPrintf(chrome::kOnlineEulaURLPath,
+                                              google_lang);
+    eula_fetcher_.reset(net::URLFetcher::Create(GURL(eula_URL),
+                                                net::URLFetcher::GET,
+                                                this));
     eula_fetcher_->SetRequestContext(
         g_browser_process->system_request_context());
     eula_fetcher_->AddExtraRequestHeader("Accept: text/html");
     eula_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                                 net::LOAD_DO_NOT_SAVE_COOKIES |
                                 net::LOAD_DISABLE_CACHE);
     eula_fetcher_->Start();
     // Abort the download attempt if it takes longer than one minute.
     download_timer_.Start(FROM_HERE,
                           base::TimeDelta::FromSeconds(kOnlineTermsTimeoutSec),
@@ skipping 80 matching lines @@
     } else if (CommandLine::ForCurrentProcess()->HasSwitch(
                    chromeos::switches::kDisableOnlineEULA)) {
       // Fallback to the local file.
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
           base::Bind(&ChromeOSTermsHandler::LoadEulaFileOnFileThread, this));
     } else {
       // Try to load online version of ChromeOS terms first.
       // ChromeOSOnlineTermsHandler object destroys itself.
       new ChromeOSOnlineTermsHandler(
-          base::Bind(&ChromeOSTermsHandler::OnOnlineEULAFetched, this));
+          base::Bind(&ChromeOSTermsHandler::OnOnlineEULAFetched, this),
+          locale_);
     }
   }
 
   void OnOnlineEULAFetched(ChromeOSOnlineTermsHandler* loader) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     loader->GetResponseResult(&contents_);
     if (contents_.empty()) {
       // Load local ChromeOS terms from the file.
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
@@ skipping 913 matching lines @@
   Profile* profile = Profile::FromWebUI(web_ui);
 
 #if defined(ENABLE_THEMES)
   // Set up the chrome://theme/ source.
   ThemeSource* theme = new ThemeSource(profile);
   content::URLDataSource::Add(profile, theme);
 #endif
 
   content::URLDataSource::Add(profile, new AboutUIHTMLSource(name, profile));
 }