Revert 262846, as the revert has now been merged to M35.

trunk/src/chrome/renderer/net/net_error_helper_core_unittest.cc

Index: trunk/src/chrome/renderer/net/net_error_helper_core_unittest.cc
===================================================================
--- trunk/src/chrome/renderer/net/net_error_helper_core_unittest.cc	(revision 263955)
+++ trunk/src/chrome/renderer/net/net_error_helper_core_unittest.cc	(working copy)
@@ -4,10 +4,12 @@
 
 #include "chrome/renderer/net/net_error_helper_core.h"
 
+#include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/timer/mock_timer.h"
 #include "base/timer/timer.h"
+#include "base/values.h"
 #include "chrome/common/net/net_error_info.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -19,9 +21,52 @@
 
 const char kFailedUrl[] = "http://failed/";
 const char kFailedHttpsUrl[] = "https://failed/";
-const char kLinkDoctorUrl[] = "http://link.doctor/";
-const char kLinkDoctorBody[] = "Link Doctor Body";
+const char kNavigationCorrectionUrl[] = "http://navigation.corrections/";
+const char kSearchUrl[] = "http://www.google.com/search";
+const char kSuggestedSearchTerms[] = "Happy Goats";
 
+struct NavigationCorrection {
+  const char* correction_type;
+  const char* url_correction;
+  bool is_porn;
+  bool is_soft_porn;
+
+  base::Value* ToValue() const {
+    base::DictionaryValue* dict = new base::DictionaryValue();
+    dict->SetString("correctionType", correction_type);
+    dict->SetString("urlCorrection", url_correction);
+    dict->SetBoolean("isPorn", is_porn);
+    dict->SetBoolean("isSoftPorn", is_soft_porn);
+    return dict;
+  }
+};
+
+const NavigationCorrection kDefaultCorrections[] = {
+  {"reloadPage", kFailedUrl, false, false},
+  {"urlCorrection", "http://somewhere_else/", false, false},
+  {"contentOverlap", "http://somewhere_else_entirely/", false, false},
+
+  // Porn should be ignored.
+  {"emphasizedUrlCorrection", "http://porn/", true, false},
+  {"sitemap", "http://more_porn/", false, true},
+
+  {"webSearchQuery", kSuggestedSearchTerms, false, false},
+};
+
+std::string SuggestionsToResponse(const NavigationCorrection* corrections,
+                                  int num_corrections) {
+  base::ListValue* url_corrections = new base::ListValue();
+  for (int i = 0; i < num_corrections; ++i)
+    url_corrections->Append(corrections[i].ToValue());
+
+  scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue());
+  response->Set("result.UrlCorrections", url_corrections);
+
+  std::string json;
+  base::JSONWriter::Write(response.get(), &json);
+  return json;
+}
+
 // Creates a string from an error that is used as a mock locally generated
 // error page for that error.
 std::string ErrorToString(const WebURLError& error, bool is_failed_post) {
@@ -103,16 +148,27 @@
   const std::string& last_error_html() const { return last_error_html_; }
   int error_html_update_count() const { return error_html_update_count_; }
 
-  void LinkDoctorLoadSuccess() {
-    LinkDoctorLoadFinished(kLinkDoctorBody);
+  const LocalizedError::ErrorPageParams* last_error_page_params() const {
+    return last_error_page_params_.get();
   }
 
-  void LinkDoctorLoadFailure() {
-    LinkDoctorLoadFinished("");
+  base::MockTimer* timer() { return timer_; }
+
+  void NavigationCorrectionsLoadSuccess(
+      const NavigationCorrection* corrections, int num_corrections) {
+    NavigationCorrectionsLoadFinished(
+        SuggestionsToResponse(corrections, num_corrections));
   }
 
-  base::MockTimer* timer() { return timer_; }
+  void NavigationCorrectionsLoadFailure() {
+    NavigationCorrectionsLoadFinished("");
+  }
 
+  void NavigationCorrectionsLoadFinished(const std::string& result) {
+    url_being_fetched_ = GURL();
+    core().OnNavigationCorrectionsFetched(result, "en", false);
+  }
+
   void DoErrorLoad(net::Error error) {
     core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                        NetErrorHelperCore::NON_ERROR_PAGE);
@@ -140,16 +196,37 @@
     core().OnNetErrorInfo(final_status);
   }
 
+  void EnableNavigationCorrections() {
+    SetNavigationCorrectionURL(GURL(kNavigationCorrectionUrl));
+  }
+
+  void DisableNavigationCorrections() {
+    SetNavigationCorrectionURL(GURL());
+  }
+
+  void ExpectDefaultNavigationCorrections() const {
+    // Checks that the last error page params correspond to kDefaultSuggestions.
+    ASSERT_TRUE(last_error_page_params());
+    EXPECT_TRUE(last_error_page_params()->suggest_reload);
+    EXPECT_EQ(2u, last_error_page_params()->override_suggestions->GetSize());
+    EXPECT_EQ(GURL(kSearchUrl), last_error_page_params()->search_url);
+    EXPECT_EQ(kSuggestedSearchTerms, last_error_page_params()->search_terms);
+  }
+
  private:
-  void LinkDoctorLoadFinished(const std::string& result) {
-    url_being_fetched_ = GURL();
-    core().OnAlternateErrorPageFetched(result);
+  void SetNavigationCorrectionURL(const GURL& navigation_correction_url) {
+    core().OnSetNavigationCorrectionInfo(navigation_correction_url,
+                                         "en", "us", "api_key",
+                                         GURL(kSearchUrl));
   }
 
   // NetErrorHelperCore::Delegate implementation:
-  virtual void GenerateLocalizedErrorPage(const WebURLError& error,
-                                          bool is_failed_post,
-                                          std::string* html) const OVERRIDE {
+  virtual void GenerateLocalizedErrorPage(
+      const WebURLError& error,
+      bool is_failed_post,
+      scoped_ptr<LocalizedError::ErrorPageParams> params,
+      std::string* html) const OVERRIDE {
+    last_error_page_params_.reset(params.release());
     *html = ErrorToString(error, is_failed_post);
   }
 
@@ -166,19 +243,24 @@
   virtual void UpdateErrorPage(const WebURLError& error,
                                bool is_failed_post) OVERRIDE {
     update_count_++;
+    last_error_page_params_.reset(NULL);
     last_error_html_ = ErrorToString(error, is_failed_post);
   }
 
-  virtual void FetchErrorPage(const GURL& url) OVERRIDE {
+  virtual void FetchNavigationCorrections(
+      const GURL& navigation_correction_url,
+      const std::string& navigation_correction_request_body) OVERRIDE {
     EXPECT_TRUE(url_being_fetched_.is_empty());
-    EXPECT_TRUE(url.is_valid());
-    EXPECT_NE(std::string::npos, url.spec().find(kLinkDoctorUrl));
+    EXPECT_TRUE(request_body_.empty());
+    EXPECT_EQ(GURL(kNavigationCorrectionUrl), navigation_correction_url);
 
-    url_being_fetched_ = url;
+    url_being_fetched_ = navigation_correction_url;
+    request_body_ = navigation_correction_request_body;
   }
 
-  virtual void CancelFetchErrorPage() OVERRIDE {
+  virtual void CancelFetchNavigationCorrections() OVERRIDE {
     url_being_fetched_ = GURL();
+    request_body_.clear();
   }
 
   virtual void ReloadPage() OVERRIDE {
@@ -190,6 +272,7 @@
   NetErrorHelperCore core_;
 
   GURL url_being_fetched_;
+  std::string request_body_;
 
   // Contains the information passed to the last call to UpdateErrorPage, as a
   // string.
@@ -202,14 +285,17 @@
   // Number of times |last_error_html_| has been changed.
   int error_html_update_count_;
 
+  // Mutable because GenerateLocalizedErrorPage is const.
+  mutable scoped_ptr<LocalizedError::ErrorPageParams> last_error_page_params_;
+
   int reload_count_;
 
   int enable_stale_load_bindings_count_;
 };
 
 //------------------------------------------------------------------------------
-// Basic tests that don't update the error page for probes or load the Link
-// Doctor.
+// Basic tests that don't update the error page for probes or load navigation
+// corrections.
 //------------------------------------------------------------------------------
 
 TEST_F(NetErrorHelperCoreTest, Null) {
@@ -224,8 +310,8 @@
   EXPECT_EQ(0, error_html_update_count());
 }
 
-TEST_F(NetErrorHelperCoreTest, SuccessfulPageLoadWithLinkDoctor) {
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+TEST_F(NetErrorHelperCoreTest, SuccessfulPageLoadWithNavigationCorrections) {
+  EnableNavigationCorrections();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
@@ -258,8 +344,8 @@
   EXPECT_EQ(1, enable_stale_load_bindings_count());
 }
 
-TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsErrorWithLinkDoctor) {
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsErrorWithCorrections) {
+  EnableNavigationCorrections();
 
   // Original page starts loading.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
@@ -339,8 +425,8 @@
   EXPECT_EQ(0, error_html_update_count());
 }
 
-TEST_F(NetErrorHelperCoreTest, SubFrameDnsErrorWithLinkDoctor) {
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+TEST_F(NetErrorHelperCoreTest, SubFrameDnsErrorWithCorrections) {
+  EnableNavigationCorrections();
 
   // Original page starts loading.
   core().OnStartLoad(NetErrorHelperCore::SUB_FRAME,
@@ -399,7 +485,7 @@
 
 //------------------------------------------------------------------------------
 // Tests for updating the error page in response to DNS probe results.  None
-// of these have the Link Doctor enabled.
+// of these have navigation corrections enabled.
 //------------------------------------------------------------------------------
 
 // Test case where the error page finishes loading before receiving any DNS
@@ -887,13 +973,13 @@
 }
 
 //------------------------------------------------------------------------------
-// Link Doctor tests.
+// Navigation correction tests.
 //------------------------------------------------------------------------------
 
-// Check that the Link Doctor is not used for HTTPS URLs.
-TEST_F(NetErrorHelperCoreTest, NoLinkDoctorForHttps) {
+// Check that corrections are not used for HTTPS URLs.
+TEST_F(NetErrorHelperCoreTest, NoCorrectionsForHttps) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableNavigationCorrections();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
@@ -908,6 +994,7 @@
   probe_error.unreachableURL = GURL(kFailedHttpsUrl);
   EXPECT_EQ(ErrorToString(probe_error, false), html);
   EXPECT_FALSE(is_url_being_fetched());
+  EXPECT_FALSE(last_error_page_params());
 
   // The blank page loads, no error page is loaded.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
@@ -915,23 +1002,25 @@
   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_FALSE(is_url_being_fetched());
+  EXPECT_FALSE(last_error_page_params());
 
   // Page is updated in response to DNS probes as normal.
   EXPECT_EQ(0, update_count());
   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
   EXPECT_EQ(2, update_count());
+  EXPECT_FALSE(last_error_page_params());
   blink::WebURLError final_probe_error =
       ProbeError(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
   final_probe_error.unreachableURL = GURL(kFailedHttpsUrl);
   EXPECT_EQ(ErrorToString(final_probe_error, false), last_error_html());
 }
 
-// The blank page loads, then the Link Doctor request succeeds and is loaded.
-// Then the probe results come in.
-TEST_F(NetErrorHelperCoreTest, LinkDoctorSucceedsBeforeProbe) {
+// The blank page loads, then the navigation corrections request succeeds and is
+// loaded.  Then the probe results come in.
+TEST_F(NetErrorHelperCoreTest, CorrectionsReceivedBeforeProbe) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableNavigationCorrections();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
@@ -942,26 +1031,31 @@
                       false, &html);
   EXPECT_TRUE(html.empty());
   EXPECT_FALSE(is_url_being_fetched());
+  EXPECT_FALSE(last_error_page_params());
 
   // The blank page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
-                     NetErrorHelperCore::ERROR_PAGE);
+                      NetErrorHelperCore::ERROR_PAGE);
   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 
-  // Link doctor retrieval starts when the error page finishes loading.
+  // Corrections retrieval starts when the error page finishes loading.
   EXPECT_FALSE(is_url_being_fetched());
+  EXPECT_FALSE(last_error_page_params());
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_TRUE(is_url_being_fetched());
+  EXPECT_FALSE(last_error_page_params());
 
-  // Link Doctor is retrieved.
-  LinkDoctorLoadSuccess();
+  // Corrections are retrieved.
+  NavigationCorrectionsLoadSuccess(kDefaultCorrections,
+                                   arraysize(kDefaultCorrections));
   EXPECT_EQ(1, error_html_update_count());
-  EXPECT_EQ(kLinkDoctorBody, last_error_html());
+  EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
+  ExpectDefaultNavigationCorrections();
   EXPECT_FALSE(is_url_being_fetched());
 
-  // Link Doctor page loads.
+  // Corrections load.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
-                     NetErrorHelperCore::ERROR_PAGE);
+                      NetErrorHelperCore::ERROR_PAGE);
   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
@@ -974,14 +1068,14 @@
 }
 
 // The blank page finishes loading, then probe results come in, and then
-// the Link Doctor request succeeds.
-TEST_F(NetErrorHelperCoreTest, LinkDoctorSucceedsAfterProbes) {
+// the navigation corrections request succeeds.
+TEST_F(NetErrorHelperCoreTest, CorrectionsRetrievedAfterProbes) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableNavigationCorrections();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
-  // It fails, and a Link Doctor page is requested.
+  // It fails, and corrections are requested.
   std::string html;
   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
                       NetError(net::ERR_NAME_NOT_RESOLVED),
@@ -994,22 +1088,25 @@
   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_TRUE(is_url_being_fetched());
+  EXPECT_FALSE(last_error_page_params());
 
-
   // Probe statuses should be ignored.
   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
   EXPECT_EQ(0, update_count());
   EXPECT_EQ(0, error_html_update_count());
+  EXPECT_FALSE(last_error_page_params());
 
-  // Link Doctor is retrieved.
+  // Corrections are retrieved.
   EXPECT_TRUE(is_url_being_fetched());
-  LinkDoctorLoadSuccess();
+  NavigationCorrectionsLoadSuccess(kDefaultCorrections,
+                                   arraysize(kDefaultCorrections));
   EXPECT_EQ(1, error_html_update_count());
-  EXPECT_EQ(kLinkDoctorBody, last_error_html());
+  EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
+  ExpectDefaultNavigationCorrections();
   EXPECT_FALSE(is_url_being_fetched());
 
-  // Link Doctor page loads.
+  // Corrections load.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::ERROR_PAGE);
   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
@@ -1018,15 +1115,15 @@
   EXPECT_EQ(0, update_count());
 }
 
-// The Link Doctor request fails and then the error page loads for an error that
+// The corrections request fails and then the error page loads for an error that
 // does not trigger DNS probes.
-TEST_F(NetErrorHelperCoreTest, LinkDoctorFailsLoadNoProbes) {
+TEST_F(NetErrorHelperCoreTest, CorrectionsFailLoadNoProbes) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableNavigationCorrections();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
-  // It fails, and a Link Doctor page is requested.
+  // It fails, and corrections are requested.
   std::string html;
   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
                       NetError(net::ERR_CONNECTION_FAILED),
@@ -1039,13 +1136,14 @@
   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
-  // Link Doctor load fails, final error page is shown.
+  // Corrections request fails, final error page is shown.
   EXPECT_TRUE(is_url_being_fetched());
-  LinkDoctorLoadFailure();
+  NavigationCorrectionsLoadFailure();
   EXPECT_EQ(1, error_html_update_count());
   EXPECT_EQ(last_error_html(), NetErrorString(net::ERR_CONNECTION_FAILED));
   EXPECT_FALSE(is_url_being_fetched());
   EXPECT_EQ(0, update_count());
+  EXPECT_FALSE(last_error_page_params());
 
   // Error page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
@@ -1061,15 +1159,15 @@
   EXPECT_EQ(1, error_html_update_count());
 }
 
-// The Link Doctor request fails and then the error page loads before probe
+// The corrections request fails and then the error page loads before probe
 // results are received.
-TEST_F(NetErrorHelperCoreTest, LinkDoctorFailsLoadBeforeProbe) {
+TEST_F(NetErrorHelperCoreTest, CorrectionsFailLoadBeforeProbe) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableNavigationCorrections();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
-  // It fails, and a Link Doctor page is requested.
+  // It fails, and corrections are requested.
   std::string html;
   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
                       NetError(net::ERR_NAME_NOT_RESOLVED),
@@ -1082,9 +1180,9 @@
   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
-  // Link Doctor load fails, probe pending page shown.
+  // Corrections request fails, probe pending page shown.
   EXPECT_TRUE(is_url_being_fetched());
-  LinkDoctorLoadFailure();
+  NavigationCorrectionsLoadFailure();
   EXPECT_EQ(1, error_html_update_count());
   EXPECT_EQ(last_error_html(),
             ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE));
@@ -1114,14 +1212,14 @@
   EXPECT_EQ(1, error_html_update_count());
 }
 
-// The Link Doctor request fails after receiving probe results.
-TEST_F(NetErrorHelperCoreTest, LinkDoctorFailsAfterProbe) {
+// The corrections request fails after receiving probe results.
+TEST_F(NetErrorHelperCoreTest, CorrectionsFailAfterProbe) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableNavigationCorrections();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
-  // It fails, and a Link Doctor page is requested.
+  // It fails, and corrections are requested.
   std::string html;
   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
                       NetError(net::ERR_NAME_NOT_RESOLVED),
@@ -1139,9 +1237,9 @@
   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
   EXPECT_EQ(0, update_count());
 
-  // Link Doctor load fails, probe pending page shown.
+  // Corrections request fails, probe pending page shown.
   EXPECT_TRUE(is_url_being_fetched());
-  LinkDoctorLoadFailure();
+  NavigationCorrectionsLoadFailure();
   EXPECT_EQ(1, error_html_update_count());
   EXPECT_EQ(last_error_html(),
             ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE));
@@ -1162,15 +1260,15 @@
   EXPECT_EQ(1, error_html_update_count());
 }
 
-// An error page load that would normally load the Link Doctor is interrupted
+// An error page load that would normally load correction is interrupted
 // by a new navigation before the blank page commits.
-TEST_F(NetErrorHelperCoreTest, LinkDoctorInterruptedBeforeCommit) {
+TEST_F(NetErrorHelperCoreTest, CorrectionsInterruptedBeforeCommit) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableNavigationCorrections();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
-  // It fails, and a Link Doctor page is requested.
+  // It fails, and corrections are requested.
   std::string html;
   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
                       NetError(net::ERR_NAME_NOT_RESOLVED),
@@ -1200,15 +1298,15 @@
   EXPECT_EQ(0, error_html_update_count());
 }
 
-// An error page load that would normally load the Link Doctor is interrupted
+// An error page load that would normally load corrections is interrupted
 // by a new navigation before the blank page finishes loading.
-TEST_F(NetErrorHelperCoreTest, LinkDoctorInterruptedBeforeLoad) {
+TEST_F(NetErrorHelperCoreTest, CorrectionsInterruptedBeforeLoad) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableNavigationCorrections();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
-  // It fails, and a Link Doctor page is requested.
+  // It fails, and corrections are requested.
   std::string html;
   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
                       NetError(net::ERR_NAME_NOT_RESOLVED),
@@ -1234,15 +1332,15 @@
   EXPECT_EQ(0, error_html_update_count());
 }
 
-// The Link Doctor request is cancelled due to a new navigation.  The new
-// navigation fails and then loads the link doctor page again (Successfully).
-TEST_F(NetErrorHelperCoreTest, LinkDoctorInterrupted) {
+// The corrections request is cancelled due to a new navigation.  The new
+// navigation fails and then loads corrections successfully.
+TEST_F(NetErrorHelperCoreTest, CorrectionsInterrupted) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableNavigationCorrections();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
-  // It fails, and a Link Doctor page is requested.
+  // It fails, and corrections are requested.
   std::string html;
   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
                       NetError(net::ERR_NAME_NOT_RESOLVED),
@@ -1266,8 +1364,7 @@
                      NetErrorHelperCore::NON_ERROR_PAGE);
   EXPECT_FALSE(is_url_being_fetched());
 
-  // It fails, and a Link Doctor page is requested again once a blank page is
-  // loaded.
+  // It fails, and corrections are requested again once a blank page is loaded.
   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
                       NetError(net::ERR_NAME_NOT_RESOLVED),
                       false, &html);
@@ -1279,10 +1376,12 @@
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_TRUE(is_url_being_fetched());
 
-  // Link Doctor load succeeds.
-  LinkDoctorLoadSuccess();
+  // Corrections request succeeds.
+  NavigationCorrectionsLoadSuccess(kDefaultCorrections,
+                                   arraysize(kDefaultCorrections));
   EXPECT_EQ(1, error_html_update_count());
-  EXPECT_EQ(kLinkDoctorBody, last_error_html());
+  EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
+  ExpectDefaultNavigationCorrections();
   EXPECT_FALSE(is_url_being_fetched());
 
   // Probe statuses come in, and are ignored.
@@ -1291,16 +1390,16 @@
   EXPECT_EQ(0, update_count());
 }
 
-// The Link Doctor request is cancelled due to call to Stop().  The cross
+// The corrections request is cancelled due to call to Stop().  The cross
 // process navigation is cancelled, and then a new load fails and tries to load
-// the link doctor page again (Which fails).
-TEST_F(NetErrorHelperCoreTest, LinkDoctorStopped) {
+// corrections again, unsuccessfully.
+TEST_F(NetErrorHelperCoreTest, CorrectionsStopped) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableNavigationCorrections();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
-  // It fails, and a Link Doctor page is requested.
+  // It fails, and corrections are requested.
   std::string html;
   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
                       NetError(net::ERR_NAME_NOT_RESOLVED),
@@ -1326,7 +1425,7 @@
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
-  // It fails, and a Link Doctor page is requested again.
+  // It fails, and corrections are requested again.
   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
                       NetError(net::ERR_NAME_NOT_RESOLVED),
                       false, &html);
@@ -1339,8 +1438,8 @@
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
   EXPECT_TRUE(is_url_being_fetched());
 
-  // Link Doctor load fails, probe pending page shown.
-  LinkDoctorLoadFailure();
+  // Corrections request fails, probe pending page shown.
+  NavigationCorrectionsLoadFailure();
   EXPECT_EQ(1, error_html_update_count());
   EXPECT_EQ(last_error_html(),
             ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE));
@@ -1365,6 +1464,260 @@
   EXPECT_EQ(1, error_html_update_count());
 }
 
+// Check the case corrections are disabled while the blank page (Loaded
+// before the corrections page) is being loaded.
+TEST_F(NetErrorHelperCoreTest, CorrectionsDisabledBeforeFetch) {
+  // Original page starts loading.
+  EnableNavigationCorrections();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+
+  // It fails, and corrections are requested.
+  std::string html;
+  core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
+                      NetError(net::ERR_NAME_NOT_RESOLVED),
+                      false, &html);
+  EXPECT_TRUE(html.empty());
+
+  // The blank page loads.
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::ERROR_PAGE);
+  // Corrections is disabled.
+  DisableNavigationCorrections();
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+  EXPECT_TRUE(is_url_being_fetched());
+  EXPECT_FALSE(last_error_page_params());
+
+  // Corrections are retrieved.
+  NavigationCorrectionsLoadSuccess(kDefaultCorrections,
+                                   arraysize(kDefaultCorrections));
+  EXPECT_EQ(1, error_html_update_count());
+  EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
+  EXPECT_FALSE(is_url_being_fetched());
+  ExpectDefaultNavigationCorrections();
+
+  // Corrections load.
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+  EXPECT_EQ(1, error_html_update_count());
+  EXPECT_EQ(0, update_count());
+}
+
+// Check the case corrections is disabled while fetching the corrections for
+// a failed page load.
+TEST_F(NetErrorHelperCoreTest, CorrectionsDisabledDuringFetch) {
+  // Original page starts loading.
+  EnableNavigationCorrections();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+
+  // It fails, and corrections are requested.
+  std::string html;
+  core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
+                      NetError(net::ERR_NAME_NOT_RESOLVED),
+                      false, &html);
+  EXPECT_TRUE(html.empty());
+
+  // The blank page loads.
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+  EXPECT_TRUE(is_url_being_fetched());
+  EXPECT_FALSE(last_error_page_params());
+
+  // Corrections are disabled.
+  DisableNavigationCorrections();
+
+  // Corrections are retrieved.
+  NavigationCorrectionsLoadSuccess(kDefaultCorrections,
+                                   arraysize(kDefaultCorrections));
+  EXPECT_EQ(1, error_html_update_count());
+  EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
+  EXPECT_FALSE(is_url_being_fetched());
+  ExpectDefaultNavigationCorrections();
+
+  // Corrections load.
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+  EXPECT_EQ(1, error_html_update_count());
+  EXPECT_EQ(0, update_count());
+}
+
+// Checks corrections are is used when there are no search suggestions.
+TEST_F(NetErrorHelperCoreTest, CorrectionsWithoutSearch) {
+  const NavigationCorrection kCorrections[] = {
+    {"urlCorrection", "http://somewhere_else/", false, false},
+  };
+
+  // Original page starts loading.
+  EnableNavigationCorrections();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+
+  // It fails, and corrections are requested.
+  std::string html;
+  core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
+                      NetError(net::ERR_NAME_NOT_RESOLVED),
+                      false, &html);
+  EXPECT_TRUE(html.empty());
+
+  // The blank page loads.
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+  EXPECT_TRUE(is_url_being_fetched());
+  EXPECT_FALSE(last_error_page_params());
+
+  // Corrections are retrieved.
+  NavigationCorrectionsLoadSuccess(kCorrections, arraysize(kCorrections));
+  EXPECT_EQ(1, error_html_update_count());
+  EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
+  EXPECT_FALSE(is_url_being_fetched());
+
+  // Check params.
+  ASSERT_TRUE(last_error_page_params());
+  EXPECT_FALSE(last_error_page_params()->suggest_reload);
+  EXPECT_EQ(1u, last_error_page_params()->override_suggestions->GetSize());
+  EXPECT_FALSE(last_error_page_params()->search_url.is_valid());
+  EXPECT_EQ("", last_error_page_params()->search_terms);
+
+  // Corrections load.
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+  EXPECT_EQ(1, error_html_update_count());
+  EXPECT_EQ(0, update_count());
+}
+
+// Checks corrections are used when there are only search suggestions.
+TEST_F(NetErrorHelperCoreTest, CorrectionsOnlySearchSuggestion) {
+  const NavigationCorrection kCorrections[] = {
+    {"webSearchQuery", kSuggestedSearchTerms, false, false},
+  };
+
+  // Original page starts loading.
+  EnableNavigationCorrections();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+
+  // It fails, and corrections are requested.
+  std::string html;
+  core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
+                      NetError(net::ERR_NAME_NOT_RESOLVED),
+                      false, &html);
+  EXPECT_TRUE(html.empty());
+
+  // The blank page loads.
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+  EXPECT_TRUE(is_url_being_fetched());
+  EXPECT_FALSE(last_error_page_params());
+
+  // Corrections are retrieved.
+  NavigationCorrectionsLoadSuccess(kCorrections, arraysize(kCorrections));
+  EXPECT_EQ(1, error_html_update_count());
+  EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
+  EXPECT_FALSE(is_url_being_fetched());
+
+  // Check params.
+  ASSERT_TRUE(last_error_page_params());
+  EXPECT_FALSE(last_error_page_params()->suggest_reload);
+  EXPECT_EQ(0u, last_error_page_params()->override_suggestions->GetSize());
+  EXPECT_EQ(GURL(kSearchUrl), last_error_page_params()->search_url);
+  EXPECT_EQ(kSuggestedSearchTerms, last_error_page_params()->search_terms);
+
+  // Corrections load.
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+  EXPECT_EQ(1, error_html_update_count());
+  EXPECT_EQ(0, update_count());
+}
+
+// The correction service returns a non-JSON result.
+TEST_F(NetErrorHelperCoreTest, CorrectionServiceReturnsNonJsonResult) {
+  // Original page starts loading.
+  EnableNavigationCorrections();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+
+  // It fails, and corrections are requested.
+  std::string html;
+  core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
+                      NetError(net::ERR_CONNECTION_FAILED),
+                      false, &html);
+  EXPECT_TRUE(html.empty());
+
+  // The blank page loads.
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+
+  // Corrections request fails, final error page is shown.
+  EXPECT_TRUE(is_url_being_fetched());
+  NavigationCorrectionsLoadFinished("Weird Response");
+  EXPECT_EQ(1, error_html_update_count());
+  EXPECT_EQ(last_error_html(), NetErrorString(net::ERR_CONNECTION_FAILED));
+  EXPECT_FALSE(is_url_being_fetched());
+  EXPECT_EQ(0, update_count());
+  EXPECT_FALSE(last_error_page_params());
+
+  // Error page loads.
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+}
+
+// The correction service returns a JSON result that isn't a valid list of
+// corrections.
+TEST_F(NetErrorHelperCoreTest, CorrectionServiceReturnsInvalidJsonResult) {
+  // Original page starts loading.
+  EnableNavigationCorrections();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+
+  // It fails, and corrections are requested.
+  std::string html;
+  core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
+                      NetError(net::ERR_CONNECTION_FAILED),
+                      false, &html);
+  EXPECT_TRUE(html.empty());
+
+  // The blank page loads.
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+
+  // Corrections request fails, final error page is shown.
+  EXPECT_TRUE(is_url_being_fetched());
+  NavigationCorrectionsLoadFinished("{\"result\": 42}");
+  EXPECT_EQ(1, error_html_update_count());
+  EXPECT_EQ(last_error_html(), NetErrorString(net::ERR_CONNECTION_FAILED));
+  EXPECT_FALSE(is_url_being_fetched());
+  EXPECT_EQ(0, update_count());
+  EXPECT_FALSE(last_error_page_params());
+
+  // Error page loads.
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::ERROR_PAGE);
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+}
+
 TEST_F(NetErrorHelperCoreTest, AutoReloadDisabled) {
   DoErrorLoad(net::ERR_CONNECTION_RESET);