Switch to using the new Link Doctor API.

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/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/manifest_handlers/icons_handler.h"
 #include "chrome/common/net/net_error_info.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/webui/web_ui_util.h"
-#include "url/gurl.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 using blink::WebURLError;
 
 // Some error pages have no details.
 const unsigned int kErrorPagesNoDetails = 0;
 
@@ skipping 446 matching lines @@
        error_domain == chrome_common_net::kDnsProbeErrorDomain))
     return "icon-offline";
 
   return "icon-generic";
 }
 
 }  // namespace
 
 const char LocalizedError::kHttpErrorDomain[] = "http";
 
+LocalizedError::ErrorPageParams::ErrorPageParams() : suggest_reload(false) {
+}
+
+LocalizedError::ErrorPageParams::~ErrorPageParams() {
+}
+
 void LocalizedError::GetStrings(int error_code,
                                 const std::string& error_domain,
                                 const GURL& failed_url,
                                 bool is_post,
                                 const std::string& locale,
                                 const std::string& accept_languages,
+                                scoped_ptr<ErrorPageParams> params,
                                 base::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,
@@ skipping 42 matching lines @@
   summary->SetString("hostName", net::IDNToUnicode(failed_url.host(),
                                                    accept_languages));
   summary->SetString("productName",
                      l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
 
   error_strings->SetString(
       "more", l10n_util::GetStringUTF16(IDS_ERRORPAGES_BUTTON_MORE));
   error_strings->SetString(
       "less", l10n_util::GetStringUTF16(IDS_ERRORPAGES_BUTTON_LESS));
   error_strings->Set("summary", summary);
-#if defined(OS_CHROMEOS)
-  error_strings->SetString(
-      "diagnose", l10n_util::GetStringUTF16(IDS_ERRORPAGES_BUTTON_DIAGNOSE));
-#endif  // defined(OS_CHROMEOS)
 
   if (options.details_resource_id != kErrorPagesNoDetails) {
     error_strings->SetString(
         "errorDetails", l10n_util::GetStringUTF16(options.details_resource_id));
   }
 
   base::string16 error_string;
   if (error_domain == net::kErrorDomain) {
     // Non-internationalized error string, for debugging Chrome itself.
     std::string ascii_error_string = net::ErrorToString(error_code);
     // Remove the leading "net::" from the returned string.
     base::RemoveChars(ascii_error_string, "net:", &ascii_error_string);
     error_string = base::ASCIIToUTF16(ascii_error_string);
   } else if (error_domain == chrome_common_net::kDnsProbeErrorDomain) {
     std::string ascii_error_string =
         chrome_common_net::DnsProbeStatusToString(error_code);
     error_string = base::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
+  // Platform specific information 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();
     if (windows_version < base::win::VERSION_VISTA) {
       // XP, XP64, and Server 2003.
       platform_string_id =
           IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED_PLATFORM_XP;
     } else if (windows_version == base::win::VERSION_VISTA) {
       // Vista
       platform_string_id =
           IDS_ERRORPAGES_SUMMARY_INTERNET_DISCONNECTED_PLATFORM_VISTA;
     }
 #endif  // defined(OS_WIN)
     // Lead with the general error description, and suffix with the platform
     // 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) {
+  bool use_default_suggestions = true;
+  bool suggest_reload = options.suggestions & SUGGEST_RELOAD;
+  base::ListValue* suggestions = NULL;
+  if (params) {
+    if (params->override_suggestions) {
+      suggestions = params->override_suggestions.release();
+      use_default_suggestions = false;
+    }
+    suggest_reload = params->suggest_reload;
+    if (params->search_url.is_valid()) {
+      error_strings->SetString("searchHeader",
+          l10n_util::GetStringUTF16(IDS_ERRORPAGES_SUGGESTION_GOOGLE_SEARCH));
+      error_strings->SetString("searchUrl", params->search_url.spec());
+      error_strings->SetString("searchTerms", params->search_terms);
+    }
+  } else {
+    suggestions = new base::ListValue();
+  }
+
+  error_strings->Set("suggestions", suggestions);
+
+  if (suggest_reload) {
     if (!is_post) {
       base::DictionaryValue* reload_button = new base::DictionaryValue;
       reload_button->SetString("msg",
           l10n_util::GetStringUTF16(IDS_ERRORPAGES_BUTTON_RELOAD));
       reload_button->SetString("reloadUrl", failed_url.spec());
       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.
       base::DictionaryValue* suggest_reload_repost = new base::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);
+      // Add at the front, so it appears before other suggestions, in the case
+      // suggestions are being overridden by |params|.
+      suggestions->Insert(0, suggest_reload_repost);
     }
   }
 
+  if (!use_default_suggestions)
+    return;
+
+#if defined(OS_CHROMEOS)
+  // TODO(mmenke):  Investigate showing this when there are link doctor results.

[Deprecated (see juliatuttle), 2014/02/04 17:44:21]

I wouldn't show it along with link doctor results -- if we can get link doctor
results, it's probably not a local network issue?

[mmenke, 2014/02/04 19:43:56]

Think you're right, removed comment.

+  error_strings->SetString(
+      "diagnose", l10n_util::GetStringUTF16(IDS_ERRORPAGES_BUTTON_DIAGNOSE));
+#endif  // defined(OS_CHROMEOS)
+
   if (options.suggestions & SUGGEST_CHECK_CONNECTION) {
     base::DictionaryValue* suggest_check_connection = new base::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));
     suggestions->Append(suggest_check_connection);
   }
@@ skipping 103 matching lines @@
       learn_more_url = learn_more_url.ReplaceComponents(repl);
 
       base::DictionaryValue* suggest_learn_more = new base::DictionaryValue;
       // 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());
       suggestions->Append(suggest_learn_more);
     }
   }
-
-  error_strings->Set("suggestions", suggestions);
 }
 
 base::string16 LocalizedError::GetErrorDetails(const blink::WebURLError& error,
                                                bool is_post) {
   const LocalizedErrorMap* error_map =
       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);
@@ skipping 39 matching lines @@
 #if defined(OS_CHROMEOS)
   GURL learn_more_url(kAppWarningLearnMoreUrl);
   base::DictionaryValue* suggest_learn_more = new base::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)
 }