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)
+
 // 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));
+    std::string eula_URL = base::StringPrintf(chrome::kOnlineEulaURLPath,

[Evan Stade, 2013/05/07 21:52:17]

I thought the idea was to rely on acceptlanguages

[vasilii, 2013/05/08 07:36:30]

No, they have prepared a list of URL in Chrome format.

+                                              locale.c_str());
+    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));
 }