Switch to using the new Link Doctor API.

chrome/renderer/net/net_error_helper_core_unittest.cc

Index: chrome/renderer/net/net_error_helper_core_unittest.cc
===================================================================
--- chrome/renderer/net/net_error_helper_core_unittest.cc	(revision 248295)
+++ chrome/renderer/net/net_error_helper_core_unittest.cc	(working copy)
@@ -4,8 +4,10 @@
 
 #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/values.h"
 #include "chrome/common/net/net_error_info.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -18,8 +20,51 @@
 const char kFailedUrl[] = "http://failed/";
 const char kFailedHttpsUrl[] = "https://failed/";
 const char kLinkDoctorUrl[] = "http://link.doctor/";
-const char kLinkDoctorBody[] = "Link Doctor Body";
+const char kSearchUrl[] = "http://www.google.com/search";
+const char kSuggestedSearchTerms[] = "Happy Goats";
 
+struct LinkDoctorSuggestion {
+  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 LinkDoctorSuggestion kDefaultSuggestions[] = {
+  {"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 LinkDoctorSuggestion* suggestions,
+                                  int num_suggestions) {
+  base::ListValue* url_corrections = new base::ListValue();
+  for (int i = 0; i < num_suggestions; ++i)
+    url_corrections->Append(suggestions[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) {
@@ -88,24 +133,54 @@
   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 LinkDoctorLoadSuccess(const LinkDoctorSuggestion* suggestions,
+                             int num_suggestions) {
+    LinkDoctorLoadFinished(SuggestionsToResponse(suggestions, num_suggestions));
+  }
+
   void LinkDoctorLoadFailure() {
     LinkDoctorLoadFinished("");
   }
 
- private:
   void LinkDoctorLoadFinished(const std::string& result) {
     url_being_fetched_ = GURL();
-    core().OnAlternateErrorPageFetched(result);
+    core().OnLinkDoctorSuggestionsFetched(result, "en", false);
   }
 
+  void EnableLinkDoctor() {
+    SetLinkDoctorURL(GURL(kLinkDoctorUrl));
+  }
+
+  void DisableLinkDoctor() {
+    SetLinkDoctorURL(GURL());
+  }
+
+  void ExpectDefaultLinkDoctorSuggestions() 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 SetLinkDoctorURL(const GURL& link_doctor_url) {
+    core().OnSetLinkDoctorInfo(link_doctor_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);
   }
 
@@ -118,24 +193,30 @@
   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 FetchLinkDoctorSuggestions(
+      const GURL& link_doctor_url,
+      const std::string& link_doctor_url_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(kLinkDoctorUrl), link_doctor_url);
 
-    url_being_fetched_ = url;
+    url_being_fetched_ = link_doctor_url;
+    request_body_ = link_doctor_url_request_body;
   }
 
-  virtual void CancelFetchErrorPage() OVERRIDE {
+  virtual void CancelFetchLinkDoctorSuggestions() OVERRIDE {
     url_being_fetched_ = GURL();
+    request_body_.clear();
   }
 
   NetErrorHelperCore core_;
 
   GURL url_being_fetched_;
+  std::string request_body_;
 
   // Contains the information passed to the last call to UpdateErrorPage, as a
   // string.
@@ -147,6 +228,9 @@
   std::string last_error_html_;
   // 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_;
 };
 
 //------------------------------------------------------------------------------
@@ -167,7 +251,7 @@
 }
 
 TEST_F(NetErrorHelperCoreTest, SuccessfulPageLoadWithLinkDoctor) {
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
@@ -199,7 +283,7 @@
 }
 
 TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsErrorWithLinkDoctor) {
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
 
   // Original page starts loading.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
@@ -280,7 +364,7 @@
 }
 
 TEST_F(NetErrorHelperCoreTest, SubFrameDnsErrorWithLinkDoctor) {
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
 
   // Original page starts loading.
   core().OnStartLoad(NetErrorHelperCore::SUB_FRAME,
@@ -831,7 +915,7 @@
 // Check that the Link Doctor is not used for HTTPS URLs.
 TEST_F(NetErrorHelperCoreTest, NoLinkDoctorForHttps) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
@@ -846,6 +930,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,
@@ -853,12 +938,14 @@
   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);
@@ -869,7 +956,7 @@
 // Then the probe results come in.
 TEST_F(NetErrorHelperCoreTest, LinkDoctorSucceedsBeforeProbe) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
@@ -880,26 +967,30 @@
                       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.
   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();
+  LinkDoctorLoadSuccess(kDefaultSuggestions, arraysize(kDefaultSuggestions));
   EXPECT_EQ(1, error_html_update_count());
-  EXPECT_EQ(kLinkDoctorBody, last_error_html());
+  EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
+  ExpectDefaultLinkDoctorSuggestions();
   EXPECT_FALSE(is_url_being_fetched());
 
   // Link Doctor page loads.
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
-                     NetErrorHelperCore::ERROR_PAGE);
+                      NetErrorHelperCore::ERROR_PAGE);
   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 
@@ -915,7 +1006,7 @@
 // the Link Doctor request succeeds.
 TEST_F(NetErrorHelperCoreTest, LinkDoctorSucceedsAfterProbes) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
@@ -932,19 +1023,21 @@
   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.
   EXPECT_TRUE(is_url_being_fetched());
-  LinkDoctorLoadSuccess();
+  LinkDoctorLoadSuccess(kDefaultSuggestions, arraysize(kDefaultSuggestions));
   EXPECT_EQ(1, error_html_update_count());
-  EXPECT_EQ(kLinkDoctorBody, last_error_html());
+  EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
+  ExpectDefaultLinkDoctorSuggestions();
   EXPECT_FALSE(is_url_being_fetched());
 
   // Link Doctor page loads.
@@ -960,7 +1053,7 @@
 // does not trigger DNS probes.
 TEST_F(NetErrorHelperCoreTest, LinkDoctorFailsLoadNoProbes) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
@@ -984,6 +1077,7 @@
   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,
@@ -1003,7 +1097,7 @@
 // results are received.
 TEST_F(NetErrorHelperCoreTest, LinkDoctorFailsLoadBeforeProbe) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
@@ -1055,7 +1149,7 @@
 // The Link Doctor request fails after receiving probe results.
 TEST_F(NetErrorHelperCoreTest, LinkDoctorFailsAfterProbe) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
@@ -1104,7 +1198,7 @@
 // by a new navigation before the blank page commits.
 TEST_F(NetErrorHelperCoreTest, LinkDoctorInterruptedBeforeCommit) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
@@ -1142,7 +1236,7 @@
 // by a new navigation before the blank page finishes loading.
 TEST_F(NetErrorHelperCoreTest, LinkDoctorInterruptedBeforeLoad) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
@@ -1176,7 +1270,7 @@
 // navigation fails and then loads the link doctor page again (Successfully).
 TEST_F(NetErrorHelperCoreTest, LinkDoctorInterrupted) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
@@ -1218,9 +1312,10 @@
   EXPECT_TRUE(is_url_being_fetched());
 
   // Link Doctor load succeeds.
-  LinkDoctorLoadSuccess();
+  LinkDoctorLoadSuccess(kDefaultSuggestions, arraysize(kDefaultSuggestions));
   EXPECT_EQ(1, error_html_update_count());
-  EXPECT_EQ(kLinkDoctorBody, last_error_html());
+  EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
+  ExpectDefaultLinkDoctorSuggestions();
   EXPECT_FALSE(is_url_being_fetched());
 
   // Probe statuses come in, and are ignored.
@@ -1234,7 +1329,7 @@
 // the link doctor page again (Which fails).
 TEST_F(NetErrorHelperCoreTest, LinkDoctorStopped) {
   // Original page starts loading.
-  core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
+  EnableLinkDoctor();
   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
                      NetErrorHelperCore::NON_ERROR_PAGE);
 
@@ -1302,3 +1397,253 @@
             last_error_html());
   EXPECT_EQ(1, error_html_update_count());
 }
+
+// Check the case the Link Doctor is disabled while the blank page (Loaded
+// before the Link Doctor) is being loaded.
+TEST_F(NetErrorHelperCoreTest, LinkDoctorDisabledBeforeFetch) {
+  // Original page starts loading.
+  EnableLinkDoctor();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+
+  // It fails, and a Link Doctor page is 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);
+  // Link Doctor is disabled.
+  DisableLinkDoctor();
+  core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
+  core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
+  EXPECT_TRUE(is_url_being_fetched());
+  EXPECT_FALSE(last_error_page_params());
+
+  // Link Doctor is retrieved.
+  LinkDoctorLoadSuccess(kDefaultSuggestions, arraysize(kDefaultSuggestions));
+  EXPECT_EQ(1, error_html_update_count());
+  EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
+  EXPECT_FALSE(is_url_being_fetched());
+  ExpectDefaultLinkDoctorSuggestions();
+
+  // Link Doctor page loads.
+  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 the Link Doctor is disabled while fetching the Link Doctor.
+TEST_F(NetErrorHelperCoreTest, LinkDoctorDisabledDuringFetch) {
+  // Original page starts loading.
+  EnableLinkDoctor();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+
+  // It fails, and a Link Doctor page is 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());
+
+  // Link Doctor is disabled.
+  DisableLinkDoctor();
+
+  // Link Doctor is retrieved.
+  LinkDoctorLoadSuccess(kDefaultSuggestions, arraysize(kDefaultSuggestions));
+  EXPECT_EQ(1, error_html_update_count());
+  EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
+  EXPECT_FALSE(is_url_being_fetched());
+  ExpectDefaultLinkDoctorSuggestions();
+
+  // Link Doctor page loads.
+  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 the Link Doctor is used when there are no search suggestions.
+TEST_F(NetErrorHelperCoreTest, LinkDoctorWithoutSearchSuggestion) {
+  const LinkDoctorSuggestion kSuggestions[] = {
+    {"urlCorrection", "http://somewhere_else/", false, false},
+  };
+
+  // Original page starts loading.
+  EnableLinkDoctor();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+
+  // It fails, and a Link Doctor page is 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());
+
+  // Link Doctor is retrieved.
+  LinkDoctorLoadSuccess(kSuggestions, arraysize(kSuggestions));
+  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);
+
+  // Link Doctor page loads.
+  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 the Link Doctor is used when there are only search suggestions.
+TEST_F(NetErrorHelperCoreTest, LinkDoctorOnlySearchSuggestion) {
+  const LinkDoctorSuggestion kSuggestions[] = {
+    {"webSearchQuery", kSuggestedSearchTerms, false, false},
+  };
+
+  // Original page starts loading.
+  EnableLinkDoctor();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+
+  // It fails, and a Link Doctor page is 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());
+
+  // Link Doctor is retrieved.
+  LinkDoctorLoadSuccess(kSuggestions, arraysize(kSuggestions));
+  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);
+
+  // Link Doctor page loads.
+  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 Link Doctor returns a non-JSON result.
+TEST_F(NetErrorHelperCoreTest, LinkDoctorReturnsNonJsonResult) {
+  // Original page starts loading.
+  EnableLinkDoctor();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+
+  // It fails, and a Link Doctor page is 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);
+
+  // Link Doctor load fails, final error page is shown.
+  EXPECT_TRUE(is_url_being_fetched());
+  LinkDoctorLoadFinished("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 Link Doctor returns a JSON result that isn't a valid response.
+TEST_F(NetErrorHelperCoreTest, LinkDoctorReturnsInvalidJsonResult) {
+  // Original page starts loading.
+  EnableLinkDoctor();
+  core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
+                     NetErrorHelperCore::NON_ERROR_PAGE);
+
+  // It fails, and a Link Doctor page is 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);
+
+  // Link Doctor load fails, final error page is shown.
+  EXPECT_TRUE(is_url_being_fetched());
+  LinkDoctorLoadFinished("{\"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);
+}