New network error pages: Update format of suggestions.

chrome/common/localized_error.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/common/localized_error.h"
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/string16.h"
 #include "base/string_util.h"
@@ skipping 32 matching lines @@
     "err_ssl_weak_server_ephemeral_dh_key";
 #if defined(OS_CHROMEOS)
 static const char kAppWarningLearnMoreUrl[] =
     "chrome-extension://honijodknafkokifofgiaalefdiedpko/main.html"
     "?answer=1721911";
 #endif  // defined(OS_CHROMEOS)
 
 enum NAV_SUGGESTIONS {
   SUGGEST_NONE                  = 0,
   SUGGEST_RELOAD                = 1 << 0,
-  SUGGEST_HOSTNAME              = 1 << 1,
-  SUGGEST_CHECK_CONNECTION      = 1 << 2,
-  SUGGEST_DNS_CONFIG            = 1 << 3,
-  SUGGEST_FIREWALL_CONFIG       = 1 << 4,
-  SUGGEST_PROXY_CONFIG          = 1 << 5,
-  SUGGEST_DISABLE_EXTENSION     = 1 << 6,
-  SUGGEST_LEARNMORE             = 1 << 7,
-  SUGGEST_VIEW_POLICIES         = 1 << 8,
-  SUGGEST_CONTACT_ADMINISTRATOR = 1 << 9,
+  SUGGEST_CHECK_CONNECTION      = 1 << 1,
+  SUGGEST_DNS_CONFIG            = 1 << 2,
+  SUGGEST_FIREWALL_CONFIG       = 1 << 3,
+  SUGGEST_PROXY_CONFIG          = 1 << 4,
+  SUGGEST_DISABLE_EXTENSION     = 1 << 5,
+  SUGGEST_LEARNMORE             = 1 << 6,
+  SUGGEST_VIEW_POLICIES         = 1 << 7,
+  SUGGEST_CONTACT_ADMINISTRATOR = 1 << 8,
 };
 
 struct LocalizedErrorMap {
   int error_code;
   unsigned int title_resource_id;
   unsigned int heading_resource_id;
   unsigned int summary_resource_id;
   unsigned int details_resource_id;
   int suggestions;  // Bitmap of SUGGEST_* values.
 };
@@ skipping 198 matching lines @@
    IDS_ERRORPAGES_HEADING_ACCESS_DENIED,
    IDS_ERRORPAGES_SUMMARY_TEMPORARILY_THROTTLED,
    IDS_ERRORPAGES_DETAILS_TEMPORARILY_THROTTLED,
    SUGGEST_NONE,
   },
   {net::ERR_BLOCKED_BY_CLIENT,
    IDS_ERRORPAGES_TITLE_BLOCKED,
    IDS_ERRORPAGES_HEADING_BLOCKED,
    IDS_ERRORPAGES_SUMMARY_BLOCKED,
    IDS_ERRORPAGES_DETAILS_BLOCKED,
-   SUGGEST_DISABLE_EXTENSION,
+   SUGGEST_RELOAD | SUGGEST_DISABLE_EXTENSION,
   },
   {net::ERR_NETWORK_CHANGED,
    IDS_ERRORPAGES_TITLE_LOAD_FAILED,
    IDS_ERRORPAGES_HEADING_NETWORK_ACCESS_DENIED,
    IDS_ERRORPAGES_SUMMARY_NETWORK_CHANGED,
    IDS_ERRORPAGES_DETAILS_NETWORK_CHANGED,
    SUGGEST_RELOAD | SUGGEST_CHECK_CONNECTION,
   },
   {net::ERR_BLOCKED_BY_ADMINISTRATOR,
    IDS_ERRORPAGES_TITLE_BLOCKED,
@@ skipping 148 matching lines @@
   if (error_domain == net::kErrorDomain &&
       error_code == net::ERR_ACCESS_DENIED &&
       failed_url.scheme() == "file") {
     options.title_resource_id = IDS_ERRORPAGES_TITLE_ACCESS_DENIED;
     options.heading_resource_id = IDS_ERRORPAGES_HEADING_FILE_ACCESS_DENIED;
     options.summary_resource_id = IDS_ERRORPAGES_SUMMARY_FILE_ACCESS_DENIED;
     options.details_resource_id = IDS_ERRORPAGES_DETAILS_FILE_ACCESS_DENIED;
     options.suggestions = SUGGEST_NONE;
   }
 
-  // If there are any suggestions other than reload, populate the suggestion
-  // heading (reload has a button, rather than a suggestion in the list).
-  if ((options.suggestions & ~SUGGEST_RELOAD) != SUGGEST_NONE) {
-    error_strings->SetString(
-        "suggestionsHeading",
-        l10n_util::GetStringUTF16(IDS_ERRORPAGES_SUGGESTION_HEADING));
-  }
-
   string16 failed_url_string(UTF8ToUTF16(failed_url.spec()));
   // URLs are always LTR.
   if (rtl)
     base::i18n::WrapStringWithLTRFormatting(&failed_url_string);
   error_strings->SetString("title",
       l10n_util::GetStringFUTF16(options.title_resource_id, failed_url_string));
   error_strings->SetString("heading",
       l10n_util::GetStringUTF16(options.heading_resource_id));
 
   DictionaryValue* summary = new DictionaryValue;
@@ skipping 24 matching lines @@
     // Remove the leading "net::" from the returned string.
     RemoveChars(ascii_error_string, "net:", &ascii_error_string);
     error_string = ASCIIToUTF16(ascii_error_string);
   } else {
     DCHECK_EQ(LocalizedError::kHttpErrorDomain, error_domain);
     error_string = base::IntToString16(error_code);
   }
   error_strings->SetString("errorCode",
       l10n_util::GetStringFUTF16(IDS_ERRORPAGES_ERROR_CODE, error_string));
 
+  base::ListValue* suggestions = new base::ListValue();
+
   // Platform specific instructions for diagnosing network issues on OSX and
   // Windows.
 #if defined(OS_MACOSX) || defined(OS_WIN)
   if (error_domain == net::kErrorDomain &&
       error_code == net::ERR_INTERNET_DISCONNECTED) {
     int platform_string_id =
         IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED_PLATFORM;
 #if defined(OS_WIN)
     // Different versions of Windows have different instructions.
     base::win::Version windows_version = base::win::GetVersion();
@@ skipping 18 matching lines @@
 #endif  // defined(OS_MACOSX) || defined(OS_WIN)
 
   if (options.suggestions & SUGGEST_RELOAD) {
     DictionaryValue* reload_button = new DictionaryValue;
     reload_button->SetString("msg",
         l10n_util::GetStringUTF16(IDS_ERRORPAGES_BUTTON_RELOAD));
     reload_button->SetString("reloadUrl", failed_url_string);
     error_strings->Set("reload", reload_button);
   }
 
-  if (options.suggestions & SUGGEST_HOSTNAME) {
-    // Only show the "Go to hostname" suggestion if the failed_url has a path.
-    if (std::string() == failed_url.path()) {
-      DictionaryValue* suggest_home_page = new DictionaryValue;
-      suggest_home_page->SetString("suggestionsHomepageMsg",
-          l10n_util::GetStringUTF16(IDS_ERRORPAGES_SUGGESTION_HOMEPAGE));
-      string16 homepage(ASCIIToUTF16(failed_url.GetWithEmptyPath().spec()));
-      // URLs are always LTR.
-      if (rtl)
-        base::i18n::WrapStringWithLTRFormatting(&homepage);
-      suggest_home_page->SetString("homePage", homepage);
-      // TODO(tc): we actually want the unicode hostname
-      suggest_home_page->SetString("hostName", failed_url.host());
-      error_strings->Set("suggestionsHomepage", suggest_home_page);
-    }
-  }
-
   if (options.suggestions & SUGGEST_CHECK_CONNECTION) {
     DictionaryValue* suggest_check_connection = new DictionaryValue;
-    suggest_check_connection->SetString("msg",
-        l10n_util::GetStringUTF16(IDS_ERRORPAGES_SUGGESTION_CHECK_CONNECTION));
-    error_strings->Set("suggestionsCheckConnection", suggest_check_connection);
+    suggest_check_connection->SetString("header",
+        l10n_util::GetStringUTF16(
+            IDS_ERRORPAGES_SUGGESTION_CHECK_CONNECTION_HEADER));
+    suggest_check_connection->SetString("body",
+        l10n_util::GetStringUTF16(
+            IDS_ERRORPAGES_SUGGESTION_CHECK_CONNECTION_BODY));
+    suggestions->Append(suggest_check_connection);
   }
 
   if (options.suggestions & SUGGEST_DNS_CONFIG) {
     DictionaryValue* suggest_dns_config = new DictionaryValue;
-    suggest_dns_config->SetString("msg",
-        l10n_util::GetStringUTF16(IDS_ERRORPAGES_SUGGESTION_DNS_CONFIG));
-    error_strings->Set("suggestionsDNSConfig", suggest_dns_config);
+    suggest_dns_config->SetString("header",
+        l10n_util::GetStringUTF16(
+            IDS_ERRORPAGES_SUGGESTION_DNS_CONFIG_HEADER));
+    suggest_dns_config->SetString("body",
+        l10n_util::GetStringUTF16(
+            IDS_ERRORPAGES_SUGGESTION_DNS_CONFIG_BODY));
+    suggestions->Append(suggest_dns_config);
 
     DictionaryValue* suggest_network_prediction = GetStandardMenuItemsText();
-    suggest_network_prediction->SetString("msg",
+    suggest_network_prediction->SetString("header",
         l10n_util::GetStringUTF16(
-            IDS_ERRORPAGES_SUGGESTION_NETWORK_PREDICTION));
+            IDS_ERRORPAGES_SUGGESTION_NETWORK_PREDICTION_HEADER));
+    suggest_network_prediction->SetString("body",
+        l10n_util::GetStringUTF16(
+            IDS_ERRORPAGES_SUGGESTION_NETWORK_PREDICTION_BODY));
     suggest_network_prediction->SetString(
         "noNetworkPredictionTitle",
         l10n_util::GetStringUTF16(
             IDS_NETWORK_PREDICTION_ENABLED_DESCRIPTION));
-    error_strings->Set("suggestionsDisableNetworkPrediction",
-                       suggest_network_prediction);
+    suggestions->Append(suggest_network_prediction);
   }
 
   if (options.suggestions & SUGGEST_FIREWALL_CONFIG) {
     DictionaryValue* suggest_firewall_config = new DictionaryValue;
-    suggest_firewall_config->SetString("msg",
-        l10n_util::GetStringUTF16(IDS_ERRORPAGES_SUGGESTION_FIREWALL_CONFIG));
-    suggest_firewall_config->SetString("productName",
-        l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
-    error_strings->Set("suggestionsFirewallConfig", suggest_firewall_config);
+    suggest_firewall_config->SetString("header",
+        l10n_util::GetStringUTF16(
+            IDS_ERRORPAGES_SUGGESTION_FIREWALL_CONFIG_HEADER));
+    suggest_firewall_config->SetString("body",
+        l10n_util::GetStringUTF16(
+            IDS_ERRORPAGES_SUGGESTION_FIREWALL_CONFIG_BODY));
+    suggestions->Append(suggest_firewall_config);
   }
 
   if (options.suggestions & SUGGEST_PROXY_CONFIG) {
 #if defined(OS_CHROMEOS)
     DictionaryValue* suggest_proxy_config = new DictionaryValue();
 #else
     DictionaryValue* suggest_proxy_config = GetStandardMenuItemsText();
 #endif  // defined(OS_CHROMEOS)
-    suggest_proxy_config->SetString("msg",
-        l10n_util::GetStringFUTF16(IDS_ERRORPAGES_SUGGESTION_PROXY_CONFIG,
+    suggest_proxy_config->SetString("header",
+        l10n_util::GetStringUTF16(
+            IDS_ERRORPAGES_SUGGESTION_PROXY_CONFIG_HEADER));
+    suggest_proxy_config->SetString("body",
+        l10n_util::GetStringFUTF16(IDS_ERRORPAGES_SUGGESTION_PROXY_CONFIG_BODY,
             l10n_util::GetStringUTF16(
                 IDS_ERRORPAGES_SUGGESTION_PROXY_DISABLE_PLATFORM)));
 #if defined(OS_CHROMEOS)
     suggest_proxy_config->SetString("settingsTitle",
         l10n_util::GetStringUTF16(IDS_SETTINGS_TITLE));
     suggest_proxy_config->SetString("internetTitle",
         l10n_util::GetStringUTF16(IDS_OPTIONS_INTERNET_TAB_LABEL));
     suggest_proxy_config->SetString("optionsButton",
         l10n_util::GetStringUTF16(IDS_OPTIONS_SETTINGS_OPTIONS));
     suggest_proxy_config->SetString("networkTab",
         l10n_util::GetStringUTF16(IDS_OPTIONS_SETTINGS_INTERNET_TAB_NETWORK));
     suggest_proxy_config->SetString("proxyButton",
         l10n_util::GetStringUTF16(
             IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CHANGE_PROXY_BUTTON));
 #else
     suggest_proxy_config->SetString("proxyTitle",
         l10n_util::GetStringUTF16(IDS_OPTIONS_PROXIES_CONFIGURE_BUTTON));
 #endif  // defined(OS_CHROMEOS)
-    error_strings->Set("suggestionsProxyConfig", suggest_proxy_config);
+
+    suggestions->Append(suggest_proxy_config);
   }
 
   if (options.suggestions & SUGGEST_DISABLE_EXTENSION) {
-    DictionaryValue* suggestion = new DictionaryValue;
-    suggestion->SetString("msg",
-        l10n_util::GetStringUTF16(IDS_ERRORPAGES_SUGGESTION_DISABLE_EXTENSION));
-    suggestion->SetString("reloadUrl", failed_url_string);
-    error_strings->Set("suggestionsDisableExtension", suggestion);
+    DictionaryValue* suggest_disable_extension = new DictionaryValue;
+    // There's only a header for this suggestion.
+    suggest_disable_extension->SetString("header",
+        l10n_util::GetStringUTF16(
+            IDS_ERRORPAGES_SUGGESTION_DISABLE_EXTENSION_HEADER));
+    suggestions->Append(suggest_disable_extension);
+  }
+
+  if (options.suggestions & SUGGEST_VIEW_POLICIES) {
+    DictionaryValue* suggest_view_policies = new DictionaryValue;
+    suggest_view_policies->SetString(
+        "header",
+        l10n_util::GetStringUTF16(
+            IDS_ERRORPAGES_SUGGESTION_VIEW_POLICIES_HEADER));
+    suggest_view_policies->SetString(
+        "body",
+        l10n_util::GetStringUTF16(
+            IDS_ERRORPAGES_SUGGESTION_VIEW_POLICIES_BODY));
+    suggestions->Append(suggest_view_policies);
+  }
+
+  if (options.suggestions & SUGGEST_CONTACT_ADMINISTRATOR) {
+    DictionaryValue* suggest_contant_administrator = new DictionaryValue;
+    suggest_contant_administrator->SetString(
+        "body",
+        l10n_util::GetStringUTF16(
+            IDS_ERRORPAGES_SUGGESTION_CONTACT_ADMINISTRATOR_BODY));
+    suggestions->Append(suggest_contant_administrator);
   }
 
   if (options.suggestions & SUGGEST_LEARNMORE) {
     GURL learn_more_url;
     switch (options.error_code) {
       case net::ERR_TOO_MANY_REDIRECTS:
         learn_more_url = GURL(kRedirectLoopLearnMoreUrl);
         break;
       case net::ERR_SSL_WEAK_SERVER_EPHEMERAL_DH_KEY:
         learn_more_url = GURL(kWeakDHKeyLearnMoreUrl);
         break;
       default:
         break;
     }
 
     if (learn_more_url.is_valid()) {
       // Add the language parameter to the URL.
       std::string query = learn_more_url.query() + "&hl=" + locale;
       GURL::Replacements repl;
       repl.SetQueryStr(query);
       learn_more_url = learn_more_url.ReplaceComponents(repl);
 
       DictionaryValue* suggest_learn_more = new DictionaryValue;
-      suggest_learn_more->SetString("msg",
-          l10n_util::GetStringUTF16(IDS_ERRORPAGES_SUGGESTION_LEARNMORE));
+      // There's only a body for this suggestion.
+      suggest_learn_more->SetString("body",
+          l10n_util::GetStringUTF16(IDS_ERRORPAGES_SUGGESTION_LEARNMORE_BODY));
       suggest_learn_more->SetString("learnMoreUrl", learn_more_url.spec());
-      error_strings->Set("suggestionsLearnMore", suggest_learn_more);
+      suggestions->Append(suggest_learn_more);
     }
   }
 
-  if (options.suggestions & SUGGEST_VIEW_POLICIES) {
-    DictionaryValue* suggestion = new DictionaryValue;
-    suggestion->SetString("msg",
-                          l10n_util::GetStringUTF16(
-                              IDS_ERRORPAGES_SUGGESTION_VIEW_POLICIES));
-    error_strings->Set("suggestionsViewPolicies", suggestion);
-  }
-
-  if (options.suggestions & SUGGEST_CONTACT_ADMINISTRATOR) {
-    DictionaryValue* suggestion = new DictionaryValue;
-    suggestion->SetString("msg",
-                          l10n_util::GetStringUTF16(
-                              IDS_ERRORPAGES_SUGGESTION_CONTACT_ADMINISTRATOR));
-    error_strings->Set("suggestionsContactAdministrator", suggestion);
-  }
+  error_strings->Set("suggestions", suggestions);
 }
 
 string16 LocalizedError::GetErrorDetails(const WebKit::WebURLError& error) {
   const LocalizedErrorMap* error_map =
       LookupErrorMap(error.domain.utf8(), error.reason);
   if (error_map)
     return l10n_util::GetStringUTF16(error_map->details_resource_id);
   else
     return l10n_util::GetStringUTF16(IDS_ERRORPAGES_DETAILS_UNKNOWN);
 }
@@ skipping 51 matching lines @@
   error_strings->SetString("name", app->name());
   error_strings->SetString(
       "msg",
       l10n_util::GetStringUTF16(IDS_ERRORPAGES_APP_WARNING));
 
 #if defined(OS_CHROMEOS)
   GURL learn_more_url(kAppWarningLearnMoreUrl);
   DictionaryValue* suggest_learn_more = new DictionaryValue();
   suggest_learn_more->SetString("msg",
                                 l10n_util::GetStringUTF16(
-                                    IDS_ERRORPAGES_SUGGESTION_LEARNMORE));
+                                    IDS_ERRORPAGES_SUGGESTION_LEARNMORE_BODY));
   suggest_learn_more->SetString("learnMoreUrl", learn_more_url.spec());
   error_strings->Set("suggestionsLearnMore", suggest_learn_more);
 #endif  // defined(OS_CHROMEOS)
 }