src/chrome/renderer/net/net_error_helper_core_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/renderer/net/net_error_helper_core.h"
   6
   7 #include "base/logging.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "base/timer/mock_timer.h"
  10 #include "base/timer/timer.h"
  11 #include "chrome/common/net/net_error_info.h"
  12 #include "net/base/net_errors.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "third_party/WebKit/public/platform/WebURLError.h"
  15
  16 using blink::WebURLError;
  17 using chrome_common_net::DnsProbeStatus;
  18 using chrome_common_net::DnsProbeStatusToString;
  19
  20 const char kFailedUrl[] = "http://failed/";
  21 const char kFailedHttpsUrl[] = "https://failed/";
  22 const char kLinkDoctorUrl[] = "http://link.doctor/";
  23 const char kLinkDoctorBody[] = "Link Doctor Body";
  24
  25 // Creates a string from an error that is used as a mock locally generated
  26 // error page for that error.
  27 std::string ErrorToString(const WebURLError& error, bool is_failed_post) {
  28   return base::StringPrintf("(%s, %s, %i, %s)",
  29                             error.unreachableURL.string().utf8().c_str(),
  30                             error.domain.utf8().c_str(), error.reason,
  31                             is_failed_post ? "POST" : "NOT POST");
  32 }
  33
  34 WebURLError ProbeError(DnsProbeStatus status) {
  35   WebURLError error;
  36   error.unreachableURL = GURL(kFailedUrl);
  37   error.domain = blink::WebString::fromUTF8(
  38       chrome_common_net::kDnsProbeErrorDomain);
  39   error.reason = status;
  40   return error;
  41 }
  42
  43 WebURLError NetError(net::Error net_error) {
  44   WebURLError error;
  45   error.unreachableURL = GURL(kFailedUrl);
  46   error.domain = blink::WebString::fromUTF8(net::kErrorDomain);
  47   error.reason = net_error;
  48   return error;
  49 }
  50
  51 WebURLError HttpError(int status_code) {
  52   WebURLError error;
  53   error.unreachableURL = GURL(kFailedUrl);
  54   error.domain = blink::WebString::fromUTF8("http");
  55   error.reason = status_code;
  56   return error;
  57 }
  58
  59 // Convenience functions that create an error string for a non-POST request.
  60
  61 std::string ProbeErrorString(DnsProbeStatus status) {
  62   return ErrorToString(ProbeError(status), false);
  63 }
  64
  65 std::string NetErrorString(net::Error net_error) {
  66   return ErrorToString(NetError(net_error), false);
  67 }
  68
  69 class NetErrorHelperCoreTest : public testing::Test,
  70                                public NetErrorHelperCore::Delegate {
  71  public:
  72   NetErrorHelperCoreTest() : timer_(new base::MockTimer(false, false)),
  73                              core_(this),
  74                              update_count_(0),
  75                              error_html_update_count_(0),
  76                              reload_count_(0),
  77                              enable_stale_load_bindings_count_(0) {
  78     core_.set_auto_reload_enabled(false);
  79     core_.set_timer_for_testing(scoped_ptr<base::Timer>(timer_));
  80   }
  81
  82   virtual ~NetErrorHelperCoreTest() {
  83     // No test finishes while an error page is being fetched.
  84     EXPECT_FALSE(is_url_being_fetched());
  85   }
  86
  87   NetErrorHelperCore& core() { return core_; }
  88
  89   const GURL& url_being_fetched() const { return url_being_fetched_; }
  90   bool is_url_being_fetched() const { return !url_being_fetched_.is_empty(); }
  91
  92   int reload_count() const {
  93     return reload_count_;
  94   }
  95
  96   int enable_stale_load_bindings_count() const {
  97     return enable_stale_load_bindings_count_;
  98   }
  99
 100   const std::string& last_update_string() const { return last_update_string_; }
 101   int update_count() const { return update_count_;  }
 102
 103   const std::string& last_error_html() const { return last_error_html_; }
 104   int error_html_update_count() const { return error_html_update_count_; }
 105
 106   void LinkDoctorLoadSuccess() {
 107     LinkDoctorLoadFinished(kLinkDoctorBody);
 108   }
 109
 110   void LinkDoctorLoadFailure() {
 111     LinkDoctorLoadFinished("");
 112   }
 113
 114   base::MockTimer* timer() { return timer_; }
 115
 116   void DoErrorLoad(net::Error error) {
 117     core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 118                        NetErrorHelperCore::NON_ERROR_PAGE);
 119     std::string html;
 120     core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 121                         NetError(error), false, &html);
 122     EXPECT_FALSE(html.empty());
 123     EXPECT_EQ(NetErrorString(error), html);
 124
 125     core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 126                        NetErrorHelperCore::ERROR_PAGE);
 127     core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 128     core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 129   }
 130
 131   void DoSuccessLoad() {
 132     core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 133                        NetErrorHelperCore::NON_ERROR_PAGE);
 134     core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 135     core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 136   }
 137
 138   void DoDnsProbe(chrome_common_net::DnsProbeStatus final_status) {
 139     core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 140     core().OnNetErrorInfo(final_status);
 141   }
 142
 143  private:
 144   void LinkDoctorLoadFinished(const std::string& result) {
 145     url_being_fetched_ = GURL();
 146     core().OnAlternateErrorPageFetched(result);
 147   }
 148
 149   // NetErrorHelperCore::Delegate implementation:
 150   virtual void GenerateLocalizedErrorPage(const WebURLError& error,
 151                                           bool is_failed_post,
 152                                           std::string* html) const OVERRIDE {
 153     *html = ErrorToString(error, is_failed_post);
 154   }
 155
 156   virtual void LoadErrorPageInMainFrame(const std::string& html,
 157                                         const GURL& failed_url) OVERRIDE {
 158     error_html_update_count_++;
 159     last_error_html_ = html;
 160   }
 161
 162   virtual void EnableStaleLoadBindings(const GURL& page_url) OVERRIDE {
 163     enable_stale_load_bindings_count_++;
 164   }
 165
 166   virtual void UpdateErrorPage(const WebURLError& error,
 167                                bool is_failed_post) OVERRIDE {
 168     update_count_++;
 169     last_error_html_ = ErrorToString(error, is_failed_post);
 170   }
 171
 172   virtual void FetchErrorPage(const GURL& url) OVERRIDE {
 173     EXPECT_TRUE(url_being_fetched_.is_empty());
 174     EXPECT_TRUE(url.is_valid());
 175     EXPECT_NE(std::string::npos, url.spec().find(kLinkDoctorUrl));
 176
 177     url_being_fetched_ = url;
 178   }
 179
 180   virtual void CancelFetchErrorPage() OVERRIDE {
 181     url_being_fetched_ = GURL();
 182   }
 183
 184   virtual void ReloadPage() OVERRIDE {
 185     reload_count_++;
 186   }
 187
 188   base::MockTimer* timer_;
 189
 190   NetErrorHelperCore core_;
 191
 192   GURL url_being_fetched_;
 193
 194   // Contains the information passed to the last call to UpdateErrorPage, as a
 195   // string.
 196   std::string last_update_string_;
 197   // Number of times |last_update_string_| has been changed.
 198   int update_count_;
 199
 200   // Contains the HTML set by the last call to LoadErrorPageInMainFrame.
 201   std::string last_error_html_;
 202   // Number of times |last_error_html_| has been changed.
 203   int error_html_update_count_;
 204
 205   int reload_count_;
 206
 207   int enable_stale_load_bindings_count_;
 208 };
 209
 210 //------------------------------------------------------------------------------
 211 // Basic tests that don't update the error page for probes or load the Link
 212 // Doctor.
 213 //------------------------------------------------------------------------------
 214
 215 TEST_F(NetErrorHelperCoreTest, Null) {
 216 }
 217
 218 TEST_F(NetErrorHelperCoreTest, SuccessfulPageLoad) {
 219   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 220                      NetErrorHelperCore::NON_ERROR_PAGE);
 221   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 222   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 223   EXPECT_EQ(0, update_count());
 224   EXPECT_EQ(0, error_html_update_count());
 225 }
 226
 227 TEST_F(NetErrorHelperCoreTest, SuccessfulPageLoadWithLinkDoctor) {
 228   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
 229   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 230                      NetErrorHelperCore::NON_ERROR_PAGE);
 231   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 232   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 233   EXPECT_EQ(0, update_count());
 234   EXPECT_EQ(0, error_html_update_count());
 235 }
 236
 237 TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsError) {
 238   // Original page starts loading.
 239   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 240                      NetErrorHelperCore::NON_ERROR_PAGE);
 241
 242   // It fails, and an error page is requested.
 243   std::string html;
 244   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 245                       NetError(net::ERR_CONNECTION_RESET), false, &html);
 246   // Should have returned a local error page.
 247   EXPECT_FALSE(html.empty());
 248   EXPECT_EQ(NetErrorString(net::ERR_CONNECTION_RESET), html);
 249
 250   // Error page loads.
 251   EXPECT_EQ(0, enable_stale_load_bindings_count());
 252   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 253                      NetErrorHelperCore::ERROR_PAGE);
 254   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 255   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 256   EXPECT_EQ(0, update_count());
 257   EXPECT_EQ(0, error_html_update_count());
 258   EXPECT_EQ(1, enable_stale_load_bindings_count());
 259 }
 260
 261 TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsErrorWithLinkDoctor) {
 262   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
 263
 264   // Original page starts loading.
 265   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 266                      NetErrorHelperCore::NON_ERROR_PAGE);
 267
 268   // It fails, and an error page is requested.
 269   std::string html;
 270   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 271                       NetError(net::ERR_CONNECTION_RESET), false, &html);
 272   // Should have returned a local error page.
 273   EXPECT_FALSE(html.empty());
 274   EXPECT_EQ(NetErrorString(net::ERR_CONNECTION_RESET), html);
 275
 276   // Error page loads.
 277   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 278                      NetErrorHelperCore::ERROR_PAGE);
 279   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 280   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 281   EXPECT_EQ(0, update_count());
 282   EXPECT_EQ(0, error_html_update_count());
 283 }
 284
 285 // Much like above tests, but with a bunch of spurious DNS status messages that
 286 // should have no effect.
 287 TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsErrorSpuriousStatus) {
 288   // Original page starts loading.
 289   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 290                      NetErrorHelperCore::NON_ERROR_PAGE);
 291   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 292
 293   // It fails, and an error page is requested.
 294   std::string html;
 295   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 296                       NetError(net::ERR_CONNECTION_RESET),
 297                       false, &html);
 298   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 299
 300   // Should have returned a local error page.
 301   EXPECT_FALSE(html.empty());
 302   EXPECT_EQ(NetErrorString(net::ERR_CONNECTION_RESET),  html);
 303
 304   // Error page loads.
 305
 306   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 307                      NetErrorHelperCore::ERROR_PAGE);
 308   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 309
 310   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 311   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 312
 313   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 314   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 315
 316   EXPECT_EQ(0, update_count());
 317   EXPECT_EQ(0, error_html_update_count());
 318 }
 319
 320 TEST_F(NetErrorHelperCoreTest, SubFrameDnsError) {
 321   // Original page starts loading.
 322   core().OnStartLoad(NetErrorHelperCore::SUB_FRAME,
 323                      NetErrorHelperCore::NON_ERROR_PAGE);
 324
 325   // It fails, and an error page is requested.
 326   std::string html;
 327   core().GetErrorHTML(NetErrorHelperCore::SUB_FRAME,
 328                       NetError(net::ERR_NAME_NOT_RESOLVED),
 329                       false, &html);
 330   // Should have returned a local error page.
 331   EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), html);
 332
 333   // Error page loads.
 334   core().OnStartLoad(NetErrorHelperCore::SUB_FRAME,
 335                      NetErrorHelperCore::ERROR_PAGE);
 336   core().OnCommitLoad(NetErrorHelperCore::SUB_FRAME);
 337   core().OnFinishLoad(NetErrorHelperCore::SUB_FRAME);
 338   EXPECT_EQ(0, update_count());
 339   EXPECT_EQ(0, error_html_update_count());
 340 }
 341
 342 TEST_F(NetErrorHelperCoreTest, SubFrameDnsErrorWithLinkDoctor) {
 343   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
 344
 345   // Original page starts loading.
 346   core().OnStartLoad(NetErrorHelperCore::SUB_FRAME,
 347                      NetErrorHelperCore::NON_ERROR_PAGE);
 348
 349   // It fails, and an error page is requested.
 350   std::string html;
 351   core().GetErrorHTML(NetErrorHelperCore::SUB_FRAME,
 352                       NetError(net::ERR_NAME_NOT_RESOLVED),
 353                       false, &html);
 354   // Should have returned a local error page.
 355   EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), html);
 356
 357   // Error page loads.
 358   core().OnStartLoad(NetErrorHelperCore::SUB_FRAME,
 359                      NetErrorHelperCore::ERROR_PAGE);
 360   core().OnCommitLoad(NetErrorHelperCore::SUB_FRAME);
 361   core().OnFinishLoad(NetErrorHelperCore::SUB_FRAME);
 362   EXPECT_EQ(0, update_count());
 363   EXPECT_EQ(0, error_html_update_count());
 364 }
 365
 366 // Much like above tests, but with a bunch of spurious DNS status messages that
 367 // should have no effect.
 368 TEST_F(NetErrorHelperCoreTest, SubFrameDnsErrorSpuriousStatus) {
 369   // Original page starts loading.
 370   core().OnStartLoad(NetErrorHelperCore::SUB_FRAME,
 371                      NetErrorHelperCore::NON_ERROR_PAGE);
 372   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 373
 374   // It fails, and an error page is requested.
 375   std::string html;
 376   core().GetErrorHTML(NetErrorHelperCore::SUB_FRAME,
 377                       NetError(net::ERR_NAME_NOT_RESOLVED),
 378                       false, &html);
 379   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 380
 381   // Should have returned a local error page.
 382   EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), html);
 383
 384   // Error page loads.
 385
 386   core().OnStartLoad(NetErrorHelperCore::SUB_FRAME,
 387                      NetErrorHelperCore::ERROR_PAGE);
 388   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 389
 390   core().OnCommitLoad(NetErrorHelperCore::SUB_FRAME);
 391   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 392
 393   core().OnFinishLoad(NetErrorHelperCore::SUB_FRAME);
 394   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 395
 396   EXPECT_EQ(0, update_count());
 397   EXPECT_EQ(0, error_html_update_count());
 398 }
 399
 400 //------------------------------------------------------------------------------
 401 // Tests for updating the error page in response to DNS probe results.  None
 402 // of these have the Link Doctor enabled.
 403 //------------------------------------------------------------------------------
 404
 405 // Test case where the error page finishes loading before receiving any DNS
 406 // probe messages.
 407 TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbe) {
 408   // Original page starts loading.
 409   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 410                      NetErrorHelperCore::NON_ERROR_PAGE);
 411
 412   // It fails, and an error page is requested.
 413   std::string html;
 414   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 415                       NetError(net::ERR_NAME_NOT_RESOLVED),
 416                       false, &html);
 417   // Should have returned a local error page indicating a probe may run.
 418   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 419
 420   // Error page loads.
 421   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 422                      NetErrorHelperCore::ERROR_PAGE);
 423   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 424   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 425   EXPECT_EQ(0, update_count());
 426
 427   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 428   EXPECT_EQ(1, update_count());
 429   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED),
 430             last_error_html());
 431
 432   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 433   EXPECT_EQ(2, update_count());
 434   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN),
 435             last_error_html());
 436
 437   // Any other probe updates should be ignored.
 438   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 439   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 440   EXPECT_EQ(2, update_count());
 441   EXPECT_EQ(0, error_html_update_count());
 442 }
 443
 444 // Same as above, but the probe is not run.
 445 TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbeNotRun) {
 446   // Original page starts loading.
 447   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 448                      NetErrorHelperCore::NON_ERROR_PAGE);
 449
 450   // It fails, and an error page is requested.
 451   std::string html;
 452   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 453                       NetError(net::ERR_NAME_NOT_RESOLVED),
 454                       false, &html);
 455   // Should have returned a local error page indicating a probe may run.
 456   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 457
 458   // Error page loads.
 459   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 460                      NetErrorHelperCore::ERROR_PAGE);
 461   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 462   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 463   EXPECT_EQ(0, update_count());
 464
 465   // When the not run status arrives, the page should revert to the normal dns
 466   // error page.
 467   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_NOT_RUN);
 468   EXPECT_EQ(1, update_count());
 469   EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
 470
 471   // Any other probe updates should be ignored.
 472   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 473   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 474   EXPECT_EQ(1, update_count());
 475   EXPECT_EQ(0, error_html_update_count());
 476 }
 477
 478 // Same as above, but the probe result is inconclusive.
 479 TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbeInconclusive) {
 480   // Original page starts loading.
 481   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 482                      NetErrorHelperCore::NON_ERROR_PAGE);
 483
 484   // It fails, and an error page is requested.
 485   std::string html;
 486   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 487                       NetError(net::ERR_NAME_NOT_RESOLVED),
 488                       false, &html);
 489   // Should have returned a local error page indicating a probe may run.
 490   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 491
 492   // Error page loads.
 493   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 494                      NetErrorHelperCore::ERROR_PAGE);
 495   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 496   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 497   EXPECT_EQ(0, update_count());
 498
 499   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 500   EXPECT_EQ(1, update_count());
 501   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED),
 502             last_error_html());
 503
 504   // When the inconclusive status arrives, the page should revert to the normal
 505   // dns error page.
 506   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE);
 507   EXPECT_EQ(2, update_count());
 508   EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html());
 509
 510   // Any other probe updates should be ignored.
 511   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE);
 512   EXPECT_EQ(2, update_count());
 513   EXPECT_EQ(0, error_html_update_count());
 514 }
 515
 516 // Same as above, but the probe result is no internet.
 517 TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbeNoInternet) {
 518   // Original page starts loading.
 519   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 520                      NetErrorHelperCore::NON_ERROR_PAGE);
 521
 522   // It fails, and an error page is requested.
 523   std::string html;
 524   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 525                       NetError(net::ERR_NAME_NOT_RESOLVED),
 526                       false, &html);
 527   // Should have returned a local error page indicating a probe may run.
 528   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 529
 530   // Error page loads.
 531   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 532                      NetErrorHelperCore::ERROR_PAGE);
 533   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 534   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 535   EXPECT_EQ(0, update_count());
 536
 537   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 538   EXPECT_EQ(1, update_count());
 539   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED),
 540             last_error_html());
 541
 542   // When the inconclusive status arrives, the page should revert to the normal
 543   // dns error page.
 544   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET);
 545   EXPECT_EQ(2, update_count());
 546   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET),
 547             last_error_html());
 548
 549   // Any other probe updates should be ignored.
 550   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET);
 551   EXPECT_EQ(2, update_count());
 552   EXPECT_EQ(0, error_html_update_count());
 553 }
 554
 555 // Same as above, but the probe result is bad config.
 556 TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbeBadConfig) {
 557   // Original page starts loading.
 558   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 559                      NetErrorHelperCore::NON_ERROR_PAGE);
 560
 561   // It fails, and an error page is requested.
 562   std::string html;
 563   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 564                       NetError(net::ERR_NAME_NOT_RESOLVED),
 565                       false, &html);
 566   // Should have returned a local error page indicating a probe may run.
 567   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 568
 569   // Error page loads.
 570   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 571                      NetErrorHelperCore::ERROR_PAGE);
 572   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 573   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 574   EXPECT_EQ(0, update_count());
 575
 576   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 577   EXPECT_EQ(1, update_count());
 578   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED),
 579             last_error_html());
 580
 581   // When the inconclusive status arrives, the page should revert to the normal
 582   // dns error page.
 583   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_BAD_CONFIG);
 584   EXPECT_EQ(2, update_count());
 585   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_BAD_CONFIG),
 586             last_error_html());
 587
 588   // Any other probe updates should be ignored.
 589   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_BAD_CONFIG);
 590   EXPECT_EQ(2, update_count());
 591   EXPECT_EQ(0, error_html_update_count());
 592 }
 593
 594 // Test case where the error page finishes loading after receiving the start
 595 // DNS probe message.
 596 TEST_F(NetErrorHelperCoreTest, FinishedAfterStartProbe) {
 597   // Original page starts loading.
 598   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 599                      NetErrorHelperCore::NON_ERROR_PAGE);
 600
 601   // It fails, and an error page is requested.
 602   std::string html;
 603   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 604                       NetError(net::ERR_NAME_NOT_RESOLVED),
 605                       false, &html);
 606   // Should have returned a local error page indicating a probe may run.
 607   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 608
 609   // Error page loads.
 610   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 611                      NetErrorHelperCore::ERROR_PAGE);
 612   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 613
 614   // Nothing should be done when a probe status comes in before loading
 615   // finishes.
 616   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 617   EXPECT_EQ(0, update_count());
 618
 619   // When loading finishes, however, the buffered probe status should be sent
 620   // to the page.
 621   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 622   EXPECT_EQ(1, update_count());
 623   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED),
 624             last_error_html());
 625
 626   // Should update the page again when the probe result comes in.
 627   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 628   EXPECT_EQ(2, update_count());
 629   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN),
 630             last_error_html());
 631
 632   // Any other probe updates should be ignored.
 633   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_NOT_RUN);
 634   EXPECT_EQ(2, update_count());
 635 }
 636
 637 // Test case where the error page finishes loading before receiving any DNS
 638 // probe messages and the request is a POST.
 639 TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbePost) {
 640   // Original page starts loading.
 641   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 642                      NetErrorHelperCore::NON_ERROR_PAGE);
 643
 644   // It fails, and an error page is requested.
 645   std::string html;
 646   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 647                       NetError(net::ERR_NAME_NOT_RESOLVED),
 648                       true, &html);
 649   // Should have returned a local error page indicating a probe may run.
 650   EXPECT_EQ(ErrorToString(
 651                 ProbeError(chrome_common_net::DNS_PROBE_POSSIBLE),
 652                            true),
 653             html);
 654
 655   // Error page loads.
 656   EXPECT_EQ(0, enable_stale_load_bindings_count());
 657   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 658                      NetErrorHelperCore::ERROR_PAGE);
 659   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 660   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 661   EXPECT_EQ(0, update_count());
 662   EXPECT_EQ(0, enable_stale_load_bindings_count());
 663
 664   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 665   EXPECT_EQ(1, update_count());
 666   EXPECT_EQ(ErrorToString(
 667                 ProbeError(chrome_common_net::DNS_PROBE_STARTED), true),
 668             last_error_html());
 669
 670   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 671   EXPECT_EQ(2, update_count());
 672   EXPECT_EQ(ErrorToString(
 673                 ProbeError(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN),
 674                            true),
 675             last_error_html());
 676   EXPECT_EQ(0, error_html_update_count());
 677 }
 678
 679 // Test case where the probe finishes before the page is committed.
 680 TEST_F(NetErrorHelperCoreTest, ProbeFinishesEarly) {
 681   // Original page starts loading.
 682   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 683                      NetErrorHelperCore::NON_ERROR_PAGE);
 684
 685   // It fails, and an error page is requested.
 686   std::string html;
 687   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 688                       NetError(net::ERR_NAME_NOT_RESOLVED),
 689                       false, &html);
 690   // Should have returned a local error page indicating a probe may run.
 691   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 692
 693   // Error page starts loading.
 694   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 695                      NetErrorHelperCore::ERROR_PAGE);
 696
 697   // Nothing should be done when the probe statuses come in before loading
 698   // finishes.
 699   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 700   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 701   EXPECT_EQ(0, update_count());
 702
 703   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 704   EXPECT_EQ(0, update_count());
 705
 706   // When loading finishes, however, the buffered probe status should be sent
 707   // to the page.
 708   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 709   EXPECT_EQ(1, update_count());
 710   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN),
 711             last_error_html());
 712
 713   // Any other probe updates should be ignored.
 714   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 715   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 716   EXPECT_EQ(1, update_count());
 717 }
 718
 719 // Test case where one error page loads completely before a new navigation
 720 // results in another error page.  Probes are run for both pages.
 721 TEST_F(NetErrorHelperCoreTest, TwoErrorsWithProbes) {
 722   // Original page starts loading.
 723   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 724                      NetErrorHelperCore::NON_ERROR_PAGE);
 725
 726   // It fails, and an error page is requested.
 727   std::string html;
 728   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 729                       NetError(net::ERR_NAME_NOT_RESOLVED),
 730                       false, &html);
 731   // Should have returned a local error page indicating a probe may run.
 732   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 733
 734   // Error page loads.
 735   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 736                      NetErrorHelperCore::ERROR_PAGE);
 737   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 738   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 739
 740   // Probe results come in.
 741   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 742   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 743   EXPECT_EQ(2, update_count());
 744   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN),
 745             last_error_html());
 746
 747   // The process starts again.
 748
 749   // Normal page starts loading.
 750   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 751                      NetErrorHelperCore::NON_ERROR_PAGE);
 752
 753   // It fails, and an error page is requested.
 754   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 755                       NetError(net::ERR_NAME_NOT_RESOLVED),
 756                       false, &html);
 757   // Should have returned a local error page indicating a probe may run.
 758   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 759
 760   // Error page loads.
 761   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 762                      NetErrorHelperCore::ERROR_PAGE);
 763   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 764   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 765   EXPECT_EQ(2, update_count());
 766
 767   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 768   EXPECT_EQ(3, update_count());
 769   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED),
 770             last_error_html());
 771
 772   // The probe returns a different result this time.
 773   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET);
 774   EXPECT_EQ(4, update_count());
 775   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET),
 776             last_error_html());
 777   EXPECT_EQ(0, error_html_update_count());
 778 }
 779
 780 // Test case where one error page loads completely before a new navigation
 781 // results in another error page.  Probe results for the first probe are only
 782 // received after the second load starts, but before it commits.
 783 TEST_F(NetErrorHelperCoreTest, TwoErrorsWithProbesAfterSecondStarts) {
 784   // Original page starts loading.
 785   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 786                      NetErrorHelperCore::NON_ERROR_PAGE);
 787
 788   // It fails, and an error page is requested.
 789   std::string html;
 790   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 791                       NetError(net::ERR_NAME_NOT_RESOLVED),
 792                       false, &html);
 793   // Should have returned a local error page indicating a probe may run.
 794   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 795
 796   // Error page loads.
 797   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 798                      NetErrorHelperCore::ERROR_PAGE);
 799   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 800   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 801
 802   // The process starts again.
 803
 804   // Normal page starts loading.
 805   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 806                      NetErrorHelperCore::NON_ERROR_PAGE);
 807
 808   // It fails, and an error page is requested.
 809   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 810                       NetError(net::ERR_NAME_NOT_RESOLVED),
 811                       false, &html);
 812   // Should have returned a local error page indicating a probe may run.
 813   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 814
 815   // Error page starts to load.
 816   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 817                      NetErrorHelperCore::ERROR_PAGE);
 818
 819   // Probe results come in, and the first page is updated.
 820   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 821   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 822   EXPECT_EQ(2, update_count());
 823   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN),
 824             last_error_html());
 825
 826   // Second page finishes loading, and is updated using the same probe result.
 827   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 828   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 829   EXPECT_EQ(3, update_count());
 830   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN),
 831             last_error_html());
 832
 833   // Other probe results should be ignored.
 834   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET);
 835   EXPECT_EQ(3, update_count());
 836   EXPECT_EQ(0, error_html_update_count());
 837 }
 838
 839 // Same as above, but a new page is loaded before the error page commits.
 840 TEST_F(NetErrorHelperCoreTest, ErrorPageLoadInterrupted) {
 841   // Original page starts loading.
 842   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 843                      NetErrorHelperCore::NON_ERROR_PAGE);
 844
 845   // It fails, and an error page is requested.
 846   std::string html;
 847   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 848                       NetError(net::ERR_NAME_NOT_RESOLVED),
 849                       false, &html);
 850   // Should have returned a local error page indicating a probe may run.
 851   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 852
 853   // Error page starts loading.
 854   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 855                      NetErrorHelperCore::ERROR_PAGE);
 856   // Probe statuses come in, but should be ignored.
 857   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 858   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 859   EXPECT_EQ(0, update_count());
 860
 861   // A new navigation begins while the error page is loading.
 862   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 863                      NetErrorHelperCore::NON_ERROR_PAGE);
 864
 865   // And fails.
 866   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 867                       NetError(net::ERR_NAME_NOT_RESOLVED),
 868                       false, &html);
 869   // Should have returned a local error page indicating a probe may run.
 870   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html);
 871
 872   // Error page finishes loading.
 873   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 874   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 875
 876   // Probe results come in.
 877   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 878   EXPECT_EQ(1, update_count());
 879   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED),
 880             last_error_html());
 881
 882   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET);
 883   EXPECT_EQ(2, update_count());
 884   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET),
 885             last_error_html());
 886   EXPECT_EQ(0, error_html_update_count());
 887 }
 888
 889 //------------------------------------------------------------------------------
 890 // Link Doctor tests.
 891 //------------------------------------------------------------------------------
 892
 893 // Check that the Link Doctor is not used for HTTPS URLs.
 894 TEST_F(NetErrorHelperCoreTest, NoLinkDoctorForHttps) {
 895   // Original page starts loading.
 896   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
 897   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 898                      NetErrorHelperCore::NON_ERROR_PAGE);
 899
 900   // The HTTPS page fails to load.
 901   std::string html;
 902   blink::WebURLError error = NetError(net::ERR_NAME_NOT_RESOLVED);
 903   error.unreachableURL = GURL(kFailedHttpsUrl);
 904   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, error, false, &html);
 905
 906   blink::WebURLError probe_error =
 907       ProbeError(chrome_common_net::DNS_PROBE_POSSIBLE);
 908   probe_error.unreachableURL = GURL(kFailedHttpsUrl);
 909   EXPECT_EQ(ErrorToString(probe_error, false), html);
 910   EXPECT_FALSE(is_url_being_fetched());
 911
 912   // The blank page loads, no error page is loaded.
 913   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 914                      NetErrorHelperCore::ERROR_PAGE);
 915   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 916   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 917   EXPECT_FALSE(is_url_being_fetched());
 918
 919   // Page is updated in response to DNS probes as normal.
 920   EXPECT_EQ(0, update_count());
 921   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 922   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 923   EXPECT_EQ(2, update_count());
 924   blink::WebURLError final_probe_error =
 925       ProbeError(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 926   final_probe_error.unreachableURL = GURL(kFailedHttpsUrl);
 927   EXPECT_EQ(ErrorToString(final_probe_error, false), last_error_html());
 928 }
 929
 930 // The blank page loads, then the Link Doctor request succeeds and is loaded.
 931 // Then the probe results come in.
 932 TEST_F(NetErrorHelperCoreTest, LinkDoctorSucceedsBeforeProbe) {
 933   // Original page starts loading.
 934   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
 935   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 936                      NetErrorHelperCore::NON_ERROR_PAGE);
 937
 938   // It fails.
 939   std::string html;
 940   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 941                       NetError(net::ERR_NAME_NOT_RESOLVED),
 942                       false, &html);
 943   EXPECT_TRUE(html.empty());
 944   EXPECT_FALSE(is_url_being_fetched());
 945
 946   // The blank page loads.
 947   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 948                      NetErrorHelperCore::ERROR_PAGE);
 949   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 950
 951   // Link doctor retrieval starts when the error page finishes loading.
 952   EXPECT_FALSE(is_url_being_fetched());
 953   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 954   EXPECT_TRUE(is_url_being_fetched());
 955
 956   // Link Doctor is retrieved.
 957   LinkDoctorLoadSuccess();
 958   EXPECT_EQ(1, error_html_update_count());
 959   EXPECT_EQ(kLinkDoctorBody, last_error_html());
 960   EXPECT_FALSE(is_url_being_fetched());
 961
 962   // Link Doctor page loads.
 963   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 964                      NetErrorHelperCore::ERROR_PAGE);
 965   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 966   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 967
 968   // Any probe statuses should be ignored.
 969   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
 970   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
 971
 972   EXPECT_EQ(0, update_count());
 973   EXPECT_EQ(1, error_html_update_count());
 974 }
 975
 976 // The blank page finishes loading, then probe results come in, and then
 977 // the Link Doctor request succeeds.
 978 TEST_F(NetErrorHelperCoreTest, LinkDoctorSucceedsAfterProbes) {
 979   // Original page starts loading.
 980   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
 981   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 982                      NetErrorHelperCore::NON_ERROR_PAGE);
 983
 984   // It fails, and a Link Doctor page is requested.
 985   std::string html;
 986   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
 987                       NetError(net::ERR_NAME_NOT_RESOLVED),
 988                       false, &html);
 989   EXPECT_TRUE(html.empty());
 990
 991   // The blank page loads.
 992   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
 993                      NetErrorHelperCore::ERROR_PAGE);
 994   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
 995   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
 996   EXPECT_TRUE(is_url_being_fetched());
 997
 998
 999   // Probe statuses should be ignored.
1000   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
1001   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
1002   EXPECT_EQ(0, update_count());
1003   EXPECT_EQ(0, error_html_update_count());
1004
1005   // Link Doctor is retrieved.
1006   EXPECT_TRUE(is_url_being_fetched());
1007   LinkDoctorLoadSuccess();
1008   EXPECT_EQ(1, error_html_update_count());
1009   EXPECT_EQ(kLinkDoctorBody, last_error_html());
1010   EXPECT_FALSE(is_url_being_fetched());
1011
1012   // Link Doctor page loads.
1013   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1014                      NetErrorHelperCore::ERROR_PAGE);
1015   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1016   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1017   EXPECT_EQ(1, error_html_update_count());
1018   EXPECT_EQ(0, update_count());
1019 }
1020
1021 // The Link Doctor request fails and then the error page loads for an error that
1022 // does not trigger DNS probes.
1023 TEST_F(NetErrorHelperCoreTest, LinkDoctorFailsLoadNoProbes) {
1024   // Original page starts loading.
1025   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
1026   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1027                      NetErrorHelperCore::NON_ERROR_PAGE);
1028
1029   // It fails, and a Link Doctor page is requested.
1030   std::string html;
1031   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1032                       NetError(net::ERR_CONNECTION_FAILED),
1033                       false, &html);
1034   EXPECT_TRUE(html.empty());
1035
1036   // The blank page loads.
1037   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1038                      NetErrorHelperCore::ERROR_PAGE);
1039   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1040   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1041
1042   // Link Doctor load fails, final error page is shown.
1043   EXPECT_TRUE(is_url_being_fetched());
1044   LinkDoctorLoadFailure();
1045   EXPECT_EQ(1, error_html_update_count());
1046   EXPECT_EQ(last_error_html(), NetErrorString(net::ERR_CONNECTION_FAILED));
1047   EXPECT_FALSE(is_url_being_fetched());
1048   EXPECT_EQ(0, update_count());
1049
1050   // Error page loads.
1051   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1052                      NetErrorHelperCore::ERROR_PAGE);
1053   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1054   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1055
1056   // If probe statuses come in last from another page load, they should be
1057   // ignored.
1058   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
1059   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
1060   EXPECT_EQ(0, update_count());
1061   EXPECT_EQ(1, error_html_update_count());
1062 }
1063
1064 // The Link Doctor request fails and then the error page loads before probe
1065 // results are received.
1066 TEST_F(NetErrorHelperCoreTest, LinkDoctorFailsLoadBeforeProbe) {
1067   // Original page starts loading.
1068   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
1069   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1070                      NetErrorHelperCore::NON_ERROR_PAGE);
1071
1072   // It fails, and a Link Doctor page is requested.
1073   std::string html;
1074   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1075                       NetError(net::ERR_NAME_NOT_RESOLVED),
1076                       false, &html);
1077   EXPECT_TRUE(html.empty());
1078
1079   // The blank page loads.
1080   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1081                      NetErrorHelperCore::ERROR_PAGE);
1082   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1083   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1084
1085   // Link Doctor load fails, probe pending page shown.
1086   EXPECT_TRUE(is_url_being_fetched());
1087   LinkDoctorLoadFailure();
1088   EXPECT_EQ(1, error_html_update_count());
1089   EXPECT_EQ(last_error_html(),
1090             ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE));
1091   EXPECT_FALSE(is_url_being_fetched());
1092   EXPECT_EQ(0, update_count());
1093
1094   // Probe page loads.
1095   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1096                      NetErrorHelperCore::ERROR_PAGE);
1097   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1098   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1099
1100   // Probe statuses comes in, and page is updated.
1101   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
1102   EXPECT_EQ(1, update_count());
1103   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED),
1104             last_error_html());
1105
1106   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
1107   EXPECT_EQ(2, update_count());
1108   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN),
1109             last_error_html());
1110
1111   // The commit results in sending a second probe status, which is ignored.
1112   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
1113   EXPECT_EQ(2, update_count());
1114   EXPECT_EQ(1, error_html_update_count());
1115 }
1116
1117 // The Link Doctor request fails after receiving probe results.
1118 TEST_F(NetErrorHelperCoreTest, LinkDoctorFailsAfterProbe) {
1119   // Original page starts loading.
1120   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
1121   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1122                      NetErrorHelperCore::NON_ERROR_PAGE);
1123
1124   // It fails, and a Link Doctor page is requested.
1125   std::string html;
1126   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1127                       NetError(net::ERR_NAME_NOT_RESOLVED),
1128                       false, &html);
1129   EXPECT_TRUE(html.empty());
1130
1131   // The blank page loads.
1132   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1133                      NetErrorHelperCore::ERROR_PAGE);
1134   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1135   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1136
1137   // Results come in, but end up being ignored.
1138   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
1139   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
1140   EXPECT_EQ(0, update_count());
1141
1142   // Link Doctor load fails, probe pending page shown.
1143   EXPECT_TRUE(is_url_being_fetched());
1144   LinkDoctorLoadFailure();
1145   EXPECT_EQ(1, error_html_update_count());
1146   EXPECT_EQ(last_error_html(),
1147             ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE));
1148   EXPECT_FALSE(is_url_being_fetched());
1149   EXPECT_EQ(0, update_count());
1150
1151   // Probe page loads.
1152   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1153                      NetErrorHelperCore::ERROR_PAGE);
1154   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1155   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1156
1157   // Probe statuses comes in, and page is updated.
1158   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
1159   EXPECT_EQ(1, update_count());
1160   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN),
1161             last_error_html());
1162   EXPECT_EQ(1, error_html_update_count());
1163 }
1164
1165 // An error page load that would normally load the Link Doctor is interrupted
1166 // by a new navigation before the blank page commits.
1167 TEST_F(NetErrorHelperCoreTest, LinkDoctorInterruptedBeforeCommit) {
1168   // Original page starts loading.
1169   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
1170   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1171                      NetErrorHelperCore::NON_ERROR_PAGE);
1172
1173   // It fails, and a Link Doctor page is requested.
1174   std::string html;
1175   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1176                       NetError(net::ERR_NAME_NOT_RESOLVED),
1177                       false, &html);
1178   EXPECT_TRUE(html.empty());
1179
1180   // The blank page starts loading.
1181   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1182                      NetErrorHelperCore::ERROR_PAGE);
1183
1184   // A new page load starts.
1185   EXPECT_FALSE(is_url_being_fetched());
1186   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1187                      NetErrorHelperCore::NON_ERROR_PAGE);
1188
1189   // A new page load interrupts the original load.
1190   EXPECT_FALSE(is_url_being_fetched());
1191   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1192                      NetErrorHelperCore::NON_ERROR_PAGE);
1193   EXPECT_FALSE(is_url_being_fetched());
1194   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1195   EXPECT_FALSE(is_url_being_fetched());
1196   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1197
1198   EXPECT_FALSE(is_url_being_fetched());
1199   EXPECT_EQ(0, update_count());
1200   EXPECT_EQ(0, error_html_update_count());
1201 }
1202
1203 // An error page load that would normally load the Link Doctor is interrupted
1204 // by a new navigation before the blank page finishes loading.
1205 TEST_F(NetErrorHelperCoreTest, LinkDoctorInterruptedBeforeLoad) {
1206   // Original page starts loading.
1207   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
1208   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1209                      NetErrorHelperCore::NON_ERROR_PAGE);
1210
1211   // It fails, and a Link Doctor page is requested.
1212   std::string html;
1213   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1214                       NetError(net::ERR_NAME_NOT_RESOLVED),
1215                       false, &html);
1216   EXPECT_TRUE(html.empty());
1217
1218   // The blank page starts loading and is committed.
1219   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1220                      NetErrorHelperCore::ERROR_PAGE);
1221   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1222
1223   // A new page load interrupts the original load.
1224   EXPECT_FALSE(is_url_being_fetched());
1225   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1226                      NetErrorHelperCore::NON_ERROR_PAGE);
1227   EXPECT_FALSE(is_url_being_fetched());
1228   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1229   EXPECT_FALSE(is_url_being_fetched());
1230   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1231
1232   EXPECT_FALSE(is_url_being_fetched());
1233   EXPECT_EQ(0, update_count());
1234   EXPECT_EQ(0, error_html_update_count());
1235 }
1236
1237 // The Link Doctor request is cancelled due to a new navigation.  The new
1238 // navigation fails and then loads the link doctor page again (Successfully).
1239 TEST_F(NetErrorHelperCoreTest, LinkDoctorInterrupted) {
1240   // Original page starts loading.
1241   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
1242   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1243                      NetErrorHelperCore::NON_ERROR_PAGE);
1244
1245   // It fails, and a Link Doctor page is requested.
1246   std::string html;
1247   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1248                       NetError(net::ERR_NAME_NOT_RESOLVED),
1249                       false, &html);
1250   EXPECT_TRUE(html.empty());
1251
1252   // The blank page loads.
1253   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1254                      NetErrorHelperCore::ERROR_PAGE);
1255   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1256   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1257   EXPECT_TRUE(is_url_being_fetched());
1258
1259   // Results come in, but end up being ignored.
1260   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
1261   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
1262   EXPECT_EQ(0, update_count());
1263
1264   // A new load appears!
1265   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1266                      NetErrorHelperCore::NON_ERROR_PAGE);
1267   EXPECT_FALSE(is_url_being_fetched());
1268
1269   // It fails, and a Link Doctor page is requested again once a blank page is
1270   // loaded.
1271   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1272                       NetError(net::ERR_NAME_NOT_RESOLVED),
1273                       false, &html);
1274   EXPECT_TRUE(html.empty());
1275   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1276                      NetErrorHelperCore::ERROR_PAGE);
1277   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1278   EXPECT_FALSE(is_url_being_fetched());
1279   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1280   EXPECT_TRUE(is_url_being_fetched());
1281
1282   // Link Doctor load succeeds.
1283   LinkDoctorLoadSuccess();
1284   EXPECT_EQ(1, error_html_update_count());
1285   EXPECT_EQ(kLinkDoctorBody, last_error_html());
1286   EXPECT_FALSE(is_url_being_fetched());
1287
1288   // Probe statuses come in, and are ignored.
1289   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
1290   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
1291   EXPECT_EQ(0, update_count());
1292 }
1293
1294 // The Link Doctor request is cancelled due to call to Stop().  The cross
1295 // process navigation is cancelled, and then a new load fails and tries to load
1296 // the link doctor page again (Which fails).
1297 TEST_F(NetErrorHelperCoreTest, LinkDoctorStopped) {
1298   // Original page starts loading.
1299   core().set_alt_error_page_url(GURL(kLinkDoctorUrl));
1300   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1301                      NetErrorHelperCore::NON_ERROR_PAGE);
1302
1303   // It fails, and a Link Doctor page is requested.
1304   std::string html;
1305   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1306                       NetError(net::ERR_NAME_NOT_RESOLVED),
1307                       false, &html);
1308   EXPECT_TRUE(html.empty());
1309
1310   // The blank page loads.
1311   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1312                      NetErrorHelperCore::ERROR_PAGE);
1313   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1314   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1315
1316   EXPECT_TRUE(is_url_being_fetched());
1317   core().OnStop();
1318   EXPECT_FALSE(is_url_being_fetched());
1319
1320   // Results come in, but end up being ignored.
1321   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
1322   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
1323   EXPECT_EQ(0, update_count());
1324
1325   // Cross process navigation must have been cancelled, and a new load appears!
1326   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1327                      NetErrorHelperCore::NON_ERROR_PAGE);
1328
1329   // It fails, and a Link Doctor page is requested again.
1330   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1331                       NetError(net::ERR_NAME_NOT_RESOLVED),
1332                       false, &html);
1333   EXPECT_TRUE(html.empty());
1334
1335   // The blank page loads again.
1336   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1337                      NetErrorHelperCore::ERROR_PAGE);
1338   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1339   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1340   EXPECT_TRUE(is_url_being_fetched());
1341
1342   // Link Doctor load fails, probe pending page shown.
1343   LinkDoctorLoadFailure();
1344   EXPECT_EQ(1, error_html_update_count());
1345   EXPECT_EQ(last_error_html(),
1346             ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE));
1347   EXPECT_FALSE(is_url_being_fetched());
1348
1349   // Probe page loads.
1350   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1351                      NetErrorHelperCore::ERROR_PAGE);
1352   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1353   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1354
1355   // Probe statuses comes in, and page is updated.
1356   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED);
1357   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED),
1358             last_error_html());
1359   EXPECT_EQ(1, update_count());
1360
1361   core().OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
1362   EXPECT_EQ(2, update_count());
1363   EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN),
1364             last_error_html());
1365   EXPECT_EQ(1, error_html_update_count());
1366 }
1367
1368 TEST_F(NetErrorHelperCoreTest, AutoReloadDisabled) {
1369   DoErrorLoad(net::ERR_CONNECTION_RESET);
1370
1371   EXPECT_FALSE(timer()->IsRunning());
1372   EXPECT_EQ(0, reload_count());
1373 }
1374
1375 TEST_F(NetErrorHelperCoreTest, AutoReloadSucceeds) {
1376   core().set_auto_reload_enabled(true);
1377   DoErrorLoad(net::ERR_CONNECTION_RESET);
1378
1379   EXPECT_TRUE(timer()->IsRunning());
1380   EXPECT_EQ(0, reload_count());
1381
1382   timer()->Fire();
1383   EXPECT_FALSE(timer()->IsRunning());
1384   EXPECT_EQ(1, reload_count());
1385
1386   DoSuccessLoad();
1387
1388   EXPECT_FALSE(timer()->IsRunning());
1389 }
1390
1391 TEST_F(NetErrorHelperCoreTest, AutoReloadRetries) {
1392   core().set_auto_reload_enabled(true);
1393   DoErrorLoad(net::ERR_CONNECTION_RESET);
1394
1395   EXPECT_TRUE(timer()->IsRunning());
1396   base::TimeDelta first_delay = timer()->GetCurrentDelay();
1397   EXPECT_EQ(0, reload_count());
1398
1399   timer()->Fire();
1400   EXPECT_FALSE(timer()->IsRunning());
1401   EXPECT_EQ(1, reload_count());
1402
1403   DoErrorLoad(net::ERR_CONNECTION_RESET);
1404
1405   EXPECT_TRUE(timer()->IsRunning());
1406   EXPECT_GT(timer()->GetCurrentDelay(), first_delay);
1407 }
1408
1409 TEST_F(NetErrorHelperCoreTest, AutoReloadStopsTimerOnStop) {
1410   core().set_auto_reload_enabled(true);
1411   DoErrorLoad(net::ERR_CONNECTION_RESET);
1412   EXPECT_TRUE(timer()->IsRunning());
1413   core().OnStop();
1414   EXPECT_FALSE(timer()->IsRunning());
1415 }
1416
1417 TEST_F(NetErrorHelperCoreTest, AutoReloadStopsLoadingOnStop) {
1418   core().set_auto_reload_enabled(true);
1419   DoErrorLoad(net::ERR_CONNECTION_RESET);
1420   EXPECT_EQ(1, core().auto_reload_count());
1421   timer()->Fire();
1422   EXPECT_EQ(1, reload_count());
1423   core().OnStop();
1424   EXPECT_FALSE(timer()->IsRunning());
1425   EXPECT_EQ(0, core().auto_reload_count());
1426 }
1427
1428 TEST_F(NetErrorHelperCoreTest, AutoReloadStopsOnOtherLoadStart) {
1429   core().set_auto_reload_enabled(true);
1430   DoErrorLoad(net::ERR_CONNECTION_RESET);
1431   EXPECT_TRUE(timer()->IsRunning());
1432   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1433                      NetErrorHelperCore::NON_ERROR_PAGE);
1434   EXPECT_FALSE(timer()->IsRunning());
1435   EXPECT_EQ(1, core().auto_reload_count());
1436 }
1437
1438 TEST_F(NetErrorHelperCoreTest, AutoReloadResetsCountOnSuccess) {
1439   core().set_auto_reload_enabled(true);
1440   DoErrorLoad(net::ERR_CONNECTION_RESET);
1441   base::TimeDelta delay = timer()->GetCurrentDelay();
1442   EXPECT_EQ(1, core().auto_reload_count());
1443   timer()->Fire();
1444   EXPECT_EQ(1, reload_count());
1445   DoSuccessLoad();
1446   DoErrorLoad(net::ERR_CONNECTION_RESET);
1447   EXPECT_EQ(1, core().auto_reload_count());
1448   EXPECT_EQ(timer()->GetCurrentDelay(), delay);
1449   timer()->Fire();
1450   EXPECT_EQ(2, reload_count());
1451   DoSuccessLoad();
1452   EXPECT_EQ(0, core().auto_reload_count());
1453 }
1454
1455 TEST_F(NetErrorHelperCoreTest, AutoReloadRestartsOnOnline) {
1456   core().set_auto_reload_enabled(true);
1457   DoErrorLoad(net::ERR_CONNECTION_RESET);
1458   base::TimeDelta delay = timer()->GetCurrentDelay();
1459   timer()->Fire();
1460   DoErrorLoad(net::ERR_CONNECTION_RESET);
1461   EXPECT_TRUE(timer()->IsRunning());
1462   EXPECT_NE(delay, timer()->GetCurrentDelay());
1463   core().NetworkStateChanged(true);
1464   EXPECT_TRUE(timer()->IsRunning());
1465   EXPECT_EQ(delay, timer()->GetCurrentDelay());
1466 }
1467
1468 TEST_F(NetErrorHelperCoreTest, AutoReloadDoesNotStartOnOnline) {
1469   core().set_auto_reload_enabled(true);
1470   DoErrorLoad(net::ERR_CONNECTION_RESET);
1471   timer()->Fire();
1472   DoSuccessLoad();
1473   EXPECT_FALSE(timer()->IsRunning());
1474   core().NetworkStateChanged(true);
1475   EXPECT_FALSE(timer()->IsRunning());
1476 }
1477
1478 TEST_F(NetErrorHelperCoreTest, AutoReloadStopsOnOffline) {
1479   core().set_auto_reload_enabled(true);
1480   DoErrorLoad(net::ERR_CONNECTION_RESET);
1481   EXPECT_TRUE(timer()->IsRunning());
1482   core().NetworkStateChanged(false);
1483   EXPECT_FALSE(timer()->IsRunning());
1484   EXPECT_EQ(0, core().auto_reload_count());
1485 }
1486
1487 TEST_F(NetErrorHelperCoreTest, AutoReloadStopsOnOfflineThenRestartsOnOnline) {
1488   core().set_auto_reload_enabled(true);
1489   DoErrorLoad(net::ERR_CONNECTION_RESET);
1490   EXPECT_TRUE(timer()->IsRunning());
1491   core().NetworkStateChanged(false);
1492   EXPECT_FALSE(timer()->IsRunning());
1493   core().NetworkStateChanged(true);
1494   EXPECT_TRUE(timer()->IsRunning());
1495   EXPECT_EQ(1, core().auto_reload_count());
1496 }
1497
1498 TEST_F(NetErrorHelperCoreTest, AutoReloadDoesNotRestartOnOnlineAfterStop) {
1499   core().set_auto_reload_enabled(true);
1500   DoErrorLoad(net::ERR_CONNECTION_RESET);
1501   timer()->Fire();
1502   core().OnStop();
1503   core().NetworkStateChanged(true);
1504   EXPECT_FALSE(timer()->IsRunning());
1505 }
1506
1507 TEST_F(NetErrorHelperCoreTest, AutoReloadWithDnsProbes) {
1508   core().set_auto_reload_enabled(true);
1509   DoErrorLoad(net::ERR_CONNECTION_RESET);
1510   DoDnsProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN);
1511   timer()->Fire();
1512   EXPECT_EQ(1, reload_count());
1513 }
1514
1515 TEST_F(NetErrorHelperCoreTest, AutoReloadExponentialBackoffLevelsOff) {
1516   core().set_auto_reload_enabled(true);
1517   base::TimeDelta previous = base::TimeDelta::FromMilliseconds(0);
1518   const int kMaxTries = 50;
1519   int tries = 0;
1520   for (tries = 0; tries < kMaxTries; tries++) {
1521     DoErrorLoad(net::ERR_CONNECTION_RESET);
1522     EXPECT_TRUE(timer()->IsRunning());
1523     if (previous == timer()->GetCurrentDelay())
1524       break;
1525     previous = timer()->GetCurrentDelay();
1526     timer()->Fire();
1527   }
1528
1529   EXPECT_LT(tries, kMaxTries);
1530 }
1531
1532 TEST_F(NetErrorHelperCoreTest, AutoReloadSlowError) {
1533   core().set_auto_reload_enabled(true);
1534   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1535                      NetErrorHelperCore::NON_ERROR_PAGE);
1536   std::string html;
1537   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1538                       NetError(net::ERR_CONNECTION_RESET), false, &html);
1539   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1540                      NetErrorHelperCore::ERROR_PAGE);
1541   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1542   EXPECT_FALSE(timer()->IsRunning());
1543   // Start a new non-error page load.
1544   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1545                      NetErrorHelperCore::NON_ERROR_PAGE);
1546   EXPECT_FALSE(timer()->IsRunning());
1547   // Finish the error page load.
1548   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1549   EXPECT_FALSE(timer()->IsRunning());
1550   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1551   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1552   EXPECT_FALSE(timer()->IsRunning());
1553 }
1554
1555 TEST_F(NetErrorHelperCoreTest, AutoReloadOnlineSlowError) {
1556   core().set_auto_reload_enabled(true);
1557   core().NetworkStateChanged(false);
1558   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1559                      NetErrorHelperCore::NON_ERROR_PAGE);
1560   std::string html;
1561   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1562                       NetError(net::ERR_CONNECTION_RESET), false, &html);
1563   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1564                      NetErrorHelperCore::ERROR_PAGE);
1565   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1566   EXPECT_FALSE(timer()->IsRunning());
1567   core().NetworkStateChanged(true);
1568   EXPECT_FALSE(timer()->IsRunning());
1569   core().NetworkStateChanged(false);
1570   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1571   EXPECT_FALSE(timer()->IsRunning());
1572   core().NetworkStateChanged(true);
1573   EXPECT_TRUE(timer()->IsRunning());
1574 }
1575
1576 TEST_F(NetErrorHelperCoreTest, AutoReloadOnlinePendingError) {
1577   core().set_auto_reload_enabled(true);
1578   core().NetworkStateChanged(false);
1579   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1580                      NetErrorHelperCore::NON_ERROR_PAGE);
1581   std::string html;
1582   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1583                       NetError(net::ERR_CONNECTION_RESET), false, &html);
1584   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1585                      NetErrorHelperCore::ERROR_PAGE);
1586   EXPECT_FALSE(timer()->IsRunning());
1587   core().NetworkStateChanged(true);
1588   EXPECT_FALSE(timer()->IsRunning());
1589   core().NetworkStateChanged(false);
1590   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1591   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1592   EXPECT_FALSE(timer()->IsRunning());
1593   core().NetworkStateChanged(true);
1594   EXPECT_TRUE(timer()->IsRunning());
1595 }
1596
1597 TEST_F(NetErrorHelperCoreTest, AutoReloadOnlinePartialErrorReplacement) {
1598   core().set_auto_reload_enabled(true);
1599   core().NetworkStateChanged(false);
1600   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1601                      NetErrorHelperCore::NON_ERROR_PAGE);
1602   std::string html;
1603   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1604                       NetError(net::ERR_CONNECTION_RESET), false, &html);
1605   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1606                      NetErrorHelperCore::ERROR_PAGE);
1607   core().OnCommitLoad(NetErrorHelperCore::MAIN_FRAME);
1608   core().OnFinishLoad(NetErrorHelperCore::MAIN_FRAME);
1609   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1610                      NetErrorHelperCore::NON_ERROR_PAGE);
1611   core().GetErrorHTML(NetErrorHelperCore::MAIN_FRAME,
1612                       NetError(net::ERR_CONNECTION_RESET), false, &html);
1613   core().OnStartLoad(NetErrorHelperCore::MAIN_FRAME,
1614                      NetErrorHelperCore::ERROR_PAGE);
1615   EXPECT_FALSE(timer()->IsRunning());
1616   core().NetworkStateChanged(true);
1617   EXPECT_FALSE(timer()->IsRunning());
1618 }
1619
1620 TEST_F(NetErrorHelperCoreTest, ShouldSuppressErrorPage) {
1621   // Set up the environment to test ShouldSuppressErrorPage: auto-reload is
1622   // enabled, an error page is loaded, and the auto-reload callback is running.
1623   core().set_auto_reload_enabled(true);
1624   DoErrorLoad(net::ERR_CONNECTION_RESET);
1625   timer()->Fire();
1626
1627   EXPECT_FALSE(core().ShouldSuppressErrorPage(NetErrorHelperCore::SUB_FRAME,
1628                                               GURL(kFailedUrl)));
1629   EXPECT_FALSE(core().ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME,
1630                                               GURL("http://some.other.url")));
1631   EXPECT_TRUE(core().ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME,
1632                                              GURL(kFailedUrl)));
1633 }