New network error page: Fix resubmit warning page

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 276 matching lines @@
   },
   {net::ERR_BLOCKED_BY_ADMINISTRATOR,
    IDS_ERRORPAGES_TITLE_BLOCKED,
    IDS_ERRORPAGES_HEADING_BLOCKED_BY_ADMINISTRATOR,
    IDS_ERRORPAGES_SUMMARY_BLOCKED_BY_ADMINISTRATOR,
    IDS_ERRORPAGES_DETAILS_BLOCKED_BY_ADMINISTRATOR,
    SUGGEST_VIEW_POLICIES | SUGGEST_CONTACT_ADMINISTRATOR,
   },
 };
 
+// Special error page to be used in the case of navigating back to a page
+// generated by a POST.  LocalizedError::HasStrings expects this net error code
+// to also appear in the array above.
+const LocalizedErrorMap repost_error = {
+  net::ERR_CACHE_MISS,
+  IDS_ERRORPAGES_TITLE_NOT_AVAILABLE,
+  IDS_HTTP_POST_WARNING_TITLE,
+  IDS_ERRORPAGES_HTTP_POST_WARNING,
+  IDS_ERRORPAGES_DETAILS_CACHE_MISS,
+  SUGGEST_RELOAD,
+};
+
 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,
   },
   {410,
    IDS_ERRORPAGES_TITLE_NOT_FOUND,
@@ skipping 51 matching lines @@
                                                    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) {
+                                        int error_code, bool is_post) {
   if (error_domain == net::kErrorDomain) {
+    // Display a different page in the special case of navigating through the
+    // history to an uncached page created by a POST.
+    if (is_post && error_code == net::ERR_CACHE_MISS)
+      return &repost_error;
     return FindErrorMapInArray(net_error_options,
                                arraysize(net_error_options),
                                error_code);
   } else if (error_domain == LocalizedError::kHttpErrorDomain) {
     return FindErrorMapInArray(http_error_options,
                                arraysize(http_error_options),
                                error_code);
   } else {
     NOTREACHED();
     return NULL;
@@ skipping 19 matching lines @@
   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";
 
 void LocalizedError::GetStrings(const WebKit::WebURLError& error,
-                                DictionaryValue* error_strings,
-                                const std::string& locale) {
+                                bool is_post,
+                                const std::string& locale,
+                                DictionaryValue* error_strings) {
   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,
     IDS_ERRORPAGES_TITLE_NOT_AVAILABLE,
     IDS_ERRORPAGES_HEADING_NOT_AVAILABLE,
     IDS_ERRORPAGES_SUMMARY_NOT_AVAILABLE,
     kErrorPagesNoDetails,
     SUGGEST_NONE,
   };
 
   const std::string error_domain = error.domain.utf8();
   int error_code = error.reason;
-  const LocalizedErrorMap* error_map =
-      LookupErrorMap(error_domain, error_code);
+  const LocalizedErrorMap* error_map = LookupErrorMap(error_domain, error_code,
+                                                      is_post);
   if (error_map)
     options = *error_map;
 
   const GURL failed_url = error.unreachableURL;
 
   // If we got "access denied" but the url was a file URL, then we say it was a
   // file instead of just using the "not available" default message. Just adding
   // ERR_ACCESS_DENIED to the map isn't sufficient, since that message may be
   // generated by some OSs when the operation doesn't involve a file URL.
   if (error_domain == net::kErrorDomain &&
@@ skipping 76 matching lines @@
     // dependent portion of the summary section.
     summary->SetString("msg",
         l10n_util::GetStringFUTF16(
             IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED_INSTRUCTIONS_TEMPLATE,
             l10n_util::GetStringUTF16(options.summary_resource_id),
             l10n_util::GetStringUTF16(platform_string_id)));
   }
 #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 (!is_post) {
+      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);
+    } else {
+      // If the page was created by a post, it can't be reloaded in the same
+      // way, so just add a suggestion instead.
+      // TODO(mmenke):  Make the reload button bring up the repost confirmation
+      //                dialog for pages resulting from posts.
+      DictionaryValue* suggest_reload_repost = new DictionaryValue;
+      suggest_reload_repost->SetString("header",
+          l10n_util::GetStringUTF16(
+              IDS_ERRORPAGES_SUGGESTION_RELOAD_REPOST_HEADER));
+      suggest_reload_repost->SetString("body",
+          l10n_util::GetStringUTF16(
+              IDS_ERRORPAGES_SUGGESTION_RELOAD_REPOST_BODY));
+      suggestions->Append(suggest_reload_repost);
+    }
   }
 
   if (options.suggestions & SUGGEST_CHECK_CONNECTION) {
     DictionaryValue* suggest_check_connection = new DictionaryValue;
     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));
@@ skipping 106 matching lines @@
       suggest_learn_more->SetString("body",
           l10n_util::GetStringUTF16(IDS_ERRORPAGES_SUGGESTION_LEARNMORE_BODY));
       suggest_learn_more->SetString("learnMoreUrl", learn_more_url.spec());
       suggestions->Append(suggest_learn_more);
     }
   }
 
   error_strings->Set("suggestions", suggestions);
 }
 
-string16 LocalizedError::GetErrorDetails(const WebKit::WebURLError& error) {
+string16 LocalizedError::GetErrorDetails(const WebKit::WebURLError& error,
+                                         bool is_post) {
   const LocalizedErrorMap* error_map =
-      LookupErrorMap(error.domain.utf8(), error.reason);
+      LookupErrorMap(error.domain.utf8(), error.reason, is_post);
   if (error_map)
     return l10n_util::GetStringUTF16(error_map->details_resource_id);
   else
     return l10n_util::GetStringUTF16(IDS_ERRORPAGES_DETAILS_UNKNOWN);
 }
 
 bool LocalizedError::HasStrings(const std::string& error_domain,
                                 int error_code) {
-  return LookupErrorMap(error_domain, error_code) != NULL;
-}
-
-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);
+  // Whether or not the there are strings for an error does not depend on
+  // whether or not the page was be generated by a POST, so just claim it was
+  // not.
+  return LookupErrorMap(error_domain, error_code, /*is_post=*/false) != NULL;
 }
 
 void LocalizedError::GetAppErrorStrings(
     const WebURLError& error,
     const GURL& display_url,
     const extensions::Extension* app,
     DictionaryValue* error_strings) {
   DCHECK(app);
 
   bool rtl = LocaleIsRTL();
@@ skipping 22 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_BODY));
   suggest_learn_more->SetString("learnMoreUrl", learn_more_url.spec());
   error_strings->Set("suggestionsLearnMore", suggest_learn_more);
 #endif  // defined(OS_CHROMEOS)
 }