Show a localized and detailed error page when a page load fails due to ERR_NETWORK_CHANGED.

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_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
+#include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "googleurl/src/gurl.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURLError.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/glue/webkit_glue.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
-using WebKit::WebURLError;

[jochen (gone - plz use gerrit), 2013/01/14 13:45:37]

please leave this in. 

[Joao da Silva, 2013/01/14 13:49:45]

Done. This was removed because the 2 out of 3 uses of WebURLError are qualified
with WebKit:: in this file.

-
 namespace {
 
 static const char kRedirectLoopLearnMoreUrl[] =
     "https://www.google.com/support/chrome/bin/answer.py?answer=95626";
 static const char kWeakDHKeyLearnMoreUrl[] =
     "http://sites.google.com/a/chromium.org/dev/"
     "err_ssl_weak_server_ephemeral_dh_key";
 #if defined(OS_CHROMEOS)
 static const char kAppWarningLearnMoreUrl[] =
     "chrome-extension://honijodknafkokifofgiaalefdiedpko/main.html"
@@ skipping 223 matching lines @@
    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,
   },
+  {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,
+  },
 };
 
 const LocalizedErrorMap http_error_options[] = {
   {403,
    IDS_ERRORPAGES_TITLE_ACCESS_DENIED,
    IDS_ERRORPAGES_HEADING_ACCESS_DENIED,
    IDS_ERRORPAGES_SUMMARY_FORBIDDEN,
    IDS_ERRORPAGES_DETAILS_FORBIDDEN,
    SUGGEST_NONE,
   },
@@ skipping 90 matching lines @@
     return string16();
   }
   return l10n_util::GetStringFUTF16(
       error_page_template,
       base::IntToString16(error_code),
       ASCIIToUTF16(error_string),
       details);
 }
 
 const LocalizedErrorMap* FindErrorMapInArray(const LocalizedErrorMap* maps,
-                                                   size_t num_maps,
-                                                   int error_code) {
+                                             size_t num_maps,
+                                             int error_code) {
   for (size_t i = 0; i < num_maps; ++i) {
     if (maps[i].error_code == error_code)
       return &maps[i];
   }
   return NULL;
 }
 
 const LocalizedErrorMap* LookupErrorMap(const std::string& error_domain,
                                         int error_code) {
   if (error_domain == net::kErrorDomain) {
@@ skipping 28 matching lines @@
       l10n_util::GetStringUTF16(IDS_SETTINGS_TITLE));
   standard_menu_items_text->SetString("advancedTitle",
       l10n_util::GetStringUTF16(IDS_SETTINGS_SHOW_ADVANCED_SETTINGS));
   return standard_menu_items_text;
 }
 
 }  // namespace
 
 const char LocalizedError::kHttpErrorDomain[] = "http";
 
+// static
 void LocalizedError::GetStrings(const WebKit::WebURLError& error,
                                 DictionaryValue* error_strings,
                                 const std::string& locale) {
   bool rtl = LocaleIsRTL();
   error_strings->SetString("textdirection", rtl ? "rtl" : "ltr");
 
   // Grab the strings and settings that depend on the error type.  Init
   // options with default values.
   LocalizedErrorMap options = {
     0,
@@ skipping 205 matching lines @@
 
       DictionaryValue* suggest_learn_more = new DictionaryValue;
       suggest_learn_more->SetString("msg",
           l10n_util::GetStringUTF16(IDS_ERRORPAGES_SUGGESTION_LEARNMORE));
       suggest_learn_more->SetString("learnMoreUrl", learn_more_url.spec());
       error_strings->Set("suggestionsLearnMore", suggest_learn_more);
     }
   }
 }
 
+// static
 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);
 }
 
+// static
 bool LocalizedError::HasStrings(const std::string& error_domain,
                                 int error_code) {
   return LookupErrorMap(error_domain, error_code) != NULL;
 }
 
+// static
 void LocalizedError::GetFormRepostStrings(const GURL& display_url,
                                           DictionaryValue* error_strings) {
   bool rtl = LocaleIsRTL();
   error_strings->SetString("textdirection", rtl ? "rtl" : "ltr");
 
   string16 failed_url(ASCIIToUTF16(display_url.spec()));
   // URLs are always LTR.
   if (rtl)
     base::i18n::WrapStringWithLTRFormatting(&failed_url);
   error_strings->SetString(
       "title", l10n_util::GetStringFUTF16(IDS_ERRORPAGES_TITLE_NOT_AVAILABLE,
                                           failed_url));
   error_strings->SetString(
       "heading", l10n_util::GetStringUTF16(IDS_HTTP_POST_WARNING_TITLE));
   DictionaryValue* summary = new DictionaryValue;
   summary->SetString(
       "msg", l10n_util::GetStringUTF16(IDS_ERRORPAGES_HTTP_POST_WARNING));
   error_strings->Set("summary", summary);
 }
 
+// static
 void LocalizedError::GetAppErrorStrings(
-    const WebURLError& error,
+    const WebKit::WebURLError& error,
     const GURL& display_url,
     const extensions::Extension* app,
     DictionaryValue* error_strings) {
   DCHECK(app);
 
   bool rtl = LocaleIsRTL();
   error_strings->SetString("textdirection", rtl ? "rtl" : "ltr");
 
   string16 failed_url(ASCIIToUTF16(display_url.spec()));
   // URLs are always LTR.
@@ skipping 14 matching lines @@
 #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));
   suggest_learn_more->SetString("learnMoreUrl", learn_more_url.spec());
   error_strings->Set("suggestionsLearnMore", suggest_learn_more);
 #endif  // defined(OS_CHROMEOS)
 }