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 <map> 8#include <string> 9#include <vector> 10 11#include "base/json/json_reader.h" 12#include "base/json/json_writer.h" 13#include "base/logging.h" 14#include "base/metrics/statistics_recorder.h" 15#include "base/strings/stringprintf.h" 16#include "base/test/histogram_tester.h" 17#include "base/timer/mock_timer.h" 18#include "base/timer/timer.h" 19#include "base/values.h" 20#include "chrome/common/net/net_error_info.h" 21#include "content/public/common/url_constants.h" 22#include "net/base/net_errors.h" 23#include "testing/gtest/include/gtest/gtest.h" 24#include "third_party/WebKit/public/platform/WebURLError.h" 25#include "url/gurl.h" 26 27namespace { 28 29using blink::WebURLError; 30using chrome_common_net::DnsProbeStatus; 31using chrome_common_net::DnsProbeStatusToString; 32 33const char kFailedUrl[] = "http://failed/"; 34const char kFailedHttpsUrl[] = "https://failed/"; 35 36const char kNavigationCorrectionUrl[] = "http://navigation.corrections/"; 37const char kLanguage[] = "en"; 38const char kCountry[] = "us"; 39const char kApiKey[] = "api_key"; 40const char kSearchUrl[] = "http://www.google.com/search"; 41 42const char kSuggestedSearchTerms[] = "Happy Goats"; 43const char kNavigationCorrectionEventId[] = "#007"; 44const char kNavigationCorrectionFingerprint[] = "RandumStuff"; 45 46struct NavigationCorrection { 47 const char* correction_type; 48 const char* url_correction; 49 const char* click_type; 50 const char* click_data; 51 bool is_porn; 52 bool is_soft_porn; 53 54 base::Value* ToValue() const { 55 base::DictionaryValue* dict = new base::DictionaryValue(); 56 dict->SetString("correctionType", correction_type); 57 dict->SetString("urlCorrection", url_correction); 58 dict->SetString("clickType", click_type); 59 dict->SetString("clickData", click_data); 60 dict->SetBoolean("isPorn", is_porn); 61 dict->SetBoolean("isSoftPorn", is_soft_porn); 62 return dict; 63 } 64}; 65 66const NavigationCorrection kDefaultCorrections[] = { 67 {"reloadPage", kFailedUrl, "rld", "data1", false, false}, 68 {"urlCorrection", "http://somewhere_else/", "btn", "data2", false, false}, 69 {"contentOverlap", "http://pony_island/", "btn", "data3", false, false}, 70 71 // Porn should be ignored. 72 {"emphasizedUrlCorrection", "http://porn/", "btn", "data4", true, false}, 73 {"sitemap", "http://more_porn/", "btn", "data5", false, true}, 74 75 {"webSearchQuery", kSuggestedSearchTerms, "frm", "data6", false, false}, 76}; 77 78std::string SuggestionsToResponse(const NavigationCorrection* corrections, 79 int num_corrections) { 80 base::ListValue* url_corrections = new base::ListValue(); 81 for (int i = 0; i < num_corrections; ++i) 82 url_corrections->Append(corrections[i].ToValue()); 83 84 scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue()); 85 response->Set("result.UrlCorrections", url_corrections); 86 response->SetString("result.eventId", kNavigationCorrectionEventId); 87 response->SetString("result.fingerprint", kNavigationCorrectionFingerprint); 88 89 std::string json; 90 base::JSONWriter::Write(response.get(), &json); 91 return json; 92} 93 94testing::AssertionResult StringValueEquals( 95 const base::DictionaryValue& dict, 96 const std::string& key, 97 const std::string& expected_value) { 98 std::string actual_value; 99 if (!dict.GetString(key, &actual_value)) 100 return testing::AssertionFailure() << key << " not found."; 101 if (actual_value != expected_value) { 102 return testing::AssertionFailure() 103 << "actual: " << actual_value << "\n expected: " << expected_value; 104 } 105 return testing::AssertionSuccess(); 106} 107 108// Creates a string from an error that is used as a mock locally generated 109// error page for that error. 110std::string ErrorToString(const WebURLError& error, bool is_failed_post) { 111 return base::StringPrintf("(%s, %s, %i, %s)", 112 error.unreachableURL.string().utf8().c_str(), 113 error.domain.utf8().c_str(), error.reason, 114 is_failed_post ? "POST" : "NOT POST"); 115} 116 117WebURLError ProbeError(DnsProbeStatus status) { 118 WebURLError error; 119 error.unreachableURL = GURL(kFailedUrl); 120 error.domain = blink::WebString::fromUTF8( 121 chrome_common_net::kDnsProbeErrorDomain); 122 error.reason = status; 123 return error; 124} 125 126WebURLError NetError(net::Error net_error) { 127 WebURLError error; 128 error.unreachableURL = GURL(kFailedUrl); 129 error.domain = blink::WebString::fromUTF8(net::kErrorDomain); 130 error.reason = net_error; 131 return error; 132} 133 134// Convenience functions that create an error string for a non-POST request. 135 136std::string ProbeErrorString(DnsProbeStatus status) { 137 return ErrorToString(ProbeError(status), false); 138} 139 140std::string NetErrorString(net::Error net_error) { 141 return ErrorToString(NetError(net_error), false); 142} 143 144class NetErrorHelperCoreTest : public testing::Test, 145 public NetErrorHelperCore::Delegate { 146 public: 147 NetErrorHelperCoreTest() : timer_(NULL), 148 update_count_(0), 149 error_html_update_count_(0), 150 reload_count_(0), 151 load_stale_count_(0), 152 enable_page_helper_functions_count_(0), 153 default_url_(GURL(kFailedUrl)), 154 error_url_(GURL(content::kUnreachableWebDataURL)), 155 tracking_request_count_(0) { 156 SetUpCore(false, false, true); 157 } 158 159 virtual ~NetErrorHelperCoreTest() { 160 // No test finishes while an error page is being fetched. 161 EXPECT_FALSE(is_url_being_fetched()); 162 } 163 164 virtual void SetUp() OVERRIDE { 165 base::StatisticsRecorder::Initialize(); 166 } 167 168 void SetUpCore(bool auto_reload_enabled, 169 bool auto_reload_visible_only, 170 bool visible) { 171 // The old value of timer_, if any, will be freed by the old core_ being 172 // destructed, since core_ takes ownership of the timer. 173 timer_ = new base::MockTimer(false, false); 174 core_.reset(new NetErrorHelperCore(this, 175 auto_reload_enabled, 176 auto_reload_visible_only, 177 visible)); 178 core_->set_timer_for_testing(scoped_ptr<base::Timer>(timer_)); 179 } 180 181 NetErrorHelperCore* core() { return core_.get(); } 182 183 const GURL& url_being_fetched() const { return url_being_fetched_; } 184 bool is_url_being_fetched() const { return !url_being_fetched_.is_empty(); } 185 186 int reload_count() const { 187 return reload_count_; 188 } 189 190 int load_stale_count() const { 191 return load_stale_count_; 192 } 193 194 const GURL& load_stale_url() const { 195 return load_stale_url_; 196 } 197 198 const GURL& default_url() const { 199 return default_url_; 200 } 201 202 const GURL& error_url() const { 203 return error_url_; 204 } 205 206 int enable_page_helper_functions_count() const { 207 return enable_page_helper_functions_count_; 208 } 209 210 const std::string& last_update_string() const { return last_update_string_; } 211 int update_count() const { return update_count_; } 212 213 const std::string& last_error_html() const { return last_error_html_; } 214 int error_html_update_count() const { return error_html_update_count_; } 215 216 const LocalizedError::ErrorPageParams* last_error_page_params() const { 217 return last_error_page_params_.get(); 218 } 219 220 const GURL& last_tracking_url() const { return last_tracking_url_; } 221 const std::string& last_tracking_request_body() const { 222 return last_tracking_request_body_; 223 } 224 int tracking_request_count() const { return tracking_request_count_; } 225 226 base::MockTimer* timer() { return timer_; } 227 228 void NavigationCorrectionsLoadSuccess( 229 const NavigationCorrection* corrections, int num_corrections) { 230 NavigationCorrectionsLoadFinished( 231 SuggestionsToResponse(corrections, num_corrections)); 232 } 233 234 void NavigationCorrectionsLoadFailure() { 235 NavigationCorrectionsLoadFinished(""); 236 } 237 238 void NavigationCorrectionsLoadFinished(const std::string& result) { 239 url_being_fetched_ = GURL(); 240 core()->OnNavigationCorrectionsFetched(result, "en", false); 241 } 242 243 void DoErrorLoad(net::Error error) { 244 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 245 NetErrorHelperCore::NON_ERROR_PAGE); 246 std::string html; 247 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 248 NetError(error), false, &html); 249 EXPECT_FALSE(html.empty()); 250 EXPECT_EQ(NetErrorString(error), html); 251 252 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 253 NetErrorHelperCore::ERROR_PAGE); 254 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, 255 error_url()); 256 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 257 } 258 259 void DoSuccessLoad() { 260 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 261 NetErrorHelperCore::NON_ERROR_PAGE); 262 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, default_url()); 263 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 264 } 265 266 void DoDnsProbe(chrome_common_net::DnsProbeStatus final_status) { 267 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 268 core()->OnNetErrorInfo(final_status); 269 } 270 271 void EnableNavigationCorrections() { 272 SetNavigationCorrectionURL(GURL(kNavigationCorrectionUrl)); 273 } 274 275 void DisableNavigationCorrections() { 276 SetNavigationCorrectionURL(GURL()); 277 } 278 279 void ExpectDefaultNavigationCorrections() const { 280 // Checks that the last error page params correspond to kDefaultSuggestions. 281 ASSERT_TRUE(last_error_page_params()); 282 EXPECT_TRUE(last_error_page_params()->suggest_reload); 283 EXPECT_EQ(2u, last_error_page_params()->override_suggestions->GetSize()); 284 EXPECT_EQ(GURL(kSearchUrl), last_error_page_params()->search_url); 285 EXPECT_EQ(kSuggestedSearchTerms, last_error_page_params()->search_terms); 286 } 287 288 private: 289 void SetNavigationCorrectionURL(const GURL& navigation_correction_url) { 290 core()->OnSetNavigationCorrectionInfo(navigation_correction_url, 291 kLanguage, kCountry, kApiKey, 292 GURL(kSearchUrl)); 293 } 294 295 // NetErrorHelperCore::Delegate implementation: 296 virtual void GenerateLocalizedErrorPage( 297 const WebURLError& error, 298 bool is_failed_post, 299 scoped_ptr<LocalizedError::ErrorPageParams> params, 300 bool* reload_button_shown, 301 bool* load_stale_button_shown, 302 std::string* html) const OVERRIDE { 303 last_error_page_params_.reset(params.release()); 304 *reload_button_shown = false; 305 *load_stale_button_shown = false; 306 *html = ErrorToString(error, is_failed_post); 307 } 308 309 virtual void LoadErrorPageInMainFrame(const std::string& html, 310 const GURL& failed_url) OVERRIDE { 311 error_html_update_count_++; 312 last_error_html_ = html; 313 } 314 315 virtual void EnablePageHelperFunctions() OVERRIDE { 316 enable_page_helper_functions_count_++; 317 } 318 319 virtual void UpdateErrorPage(const WebURLError& error, 320 bool is_failed_post) OVERRIDE { 321 update_count_++; 322 last_error_page_params_.reset(NULL); 323 last_error_html_ = ErrorToString(error, is_failed_post); 324 } 325 326 virtual void FetchNavigationCorrections( 327 const GURL& navigation_correction_url, 328 const std::string& navigation_correction_request_body) OVERRIDE { 329 EXPECT_TRUE(url_being_fetched_.is_empty()); 330 EXPECT_TRUE(request_body_.empty()); 331 EXPECT_EQ(GURL(kNavigationCorrectionUrl), navigation_correction_url); 332 333 url_being_fetched_ = navigation_correction_url; 334 request_body_ = navigation_correction_request_body; 335 336 // Check the body of the request. 337 338 base::JSONReader reader; 339 scoped_ptr<base::Value> parsed_body(reader.Read( 340 navigation_correction_request_body)); 341 ASSERT_TRUE(parsed_body); 342 base::DictionaryValue* dict = NULL; 343 ASSERT_TRUE(parsed_body->GetAsDictionary(&dict)); 344 345 EXPECT_TRUE(StringValueEquals(*dict, "params.urlQuery", kFailedUrl)); 346 EXPECT_TRUE(StringValueEquals(*dict, "params.language", kLanguage)); 347 EXPECT_TRUE(StringValueEquals(*dict, "params.originCountry", kCountry)); 348 EXPECT_TRUE(StringValueEquals(*dict, "params.key", kApiKey)); 349 } 350 351 virtual void CancelFetchNavigationCorrections() OVERRIDE { 352 url_being_fetched_ = GURL(); 353 request_body_.clear(); 354 } 355 356 virtual void ReloadPage() OVERRIDE { 357 reload_count_++; 358 } 359 360 virtual void LoadPageFromCache(const GURL& error_url) OVERRIDE { 361 load_stale_count_++; 362 load_stale_url_ = error_url; 363 } 364 365 virtual void SendTrackingRequest( 366 const GURL& tracking_url, 367 const std::string& tracking_request_body) OVERRIDE { 368 last_tracking_url_ = tracking_url; 369 last_tracking_request_body_ = tracking_request_body; 370 tracking_request_count_++; 371 372 // Check the body of the request. 373 374 base::JSONReader reader; 375 scoped_ptr<base::Value> parsed_body(reader.Read(tracking_request_body)); 376 ASSERT_TRUE(parsed_body); 377 base::DictionaryValue* dict = NULL; 378 ASSERT_TRUE(parsed_body->GetAsDictionary(&dict)); 379 380 EXPECT_TRUE(StringValueEquals(*dict, "params.originalUrlQuery", 381 kFailedUrl)); 382 EXPECT_TRUE(StringValueEquals(*dict, "params.language", kLanguage)); 383 EXPECT_TRUE(StringValueEquals(*dict, "params.originCountry", kCountry)); 384 EXPECT_TRUE(StringValueEquals(*dict, "params.key", kApiKey)); 385 } 386 387 base::MockTimer* timer_; 388 389 scoped_ptr<NetErrorHelperCore> core_; 390 391 GURL url_being_fetched_; 392 std::string request_body_; 393 394 // Contains the information passed to the last call to UpdateErrorPage, as a 395 // string. 396 std::string last_update_string_; 397 // Number of times |last_update_string_| has been changed. 398 int update_count_; 399 400 // Contains the HTML set by the last call to LoadErrorPageInMainFrame. 401 std::string last_error_html_; 402 // Number of times |last_error_html_| has been changed. 403 int error_html_update_count_; 404 405 // Mutable because GenerateLocalizedErrorPage is const. 406 mutable scoped_ptr<LocalizedError::ErrorPageParams> last_error_page_params_; 407 408 int reload_count_; 409 int load_stale_count_; 410 GURL load_stale_url_; 411 412 int enable_page_helper_functions_count_; 413 414 const GURL default_url_; 415 const GURL error_url_; 416 417 GURL last_tracking_url_; 418 std::string last_tracking_request_body_; 419 int tracking_request_count_; 420}; 421 422//------------------------------------------------------------------------------ 423// Basic tests that don't update the error page for probes or load navigation 424// corrections. 425//------------------------------------------------------------------------------ 426 427TEST_F(NetErrorHelperCoreTest, Null) { 428} 429 430TEST_F(NetErrorHelperCoreTest, SuccessfulPageLoad) { 431 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 432 NetErrorHelperCore::NON_ERROR_PAGE); 433 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, default_url()); 434 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 435 EXPECT_EQ(0, update_count()); 436 EXPECT_EQ(0, error_html_update_count()); 437} 438 439TEST_F(NetErrorHelperCoreTest, SuccessfulPageLoadWithNavigationCorrections) { 440 EnableNavigationCorrections(); 441 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 442 NetErrorHelperCore::NON_ERROR_PAGE); 443 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, default_url()); 444 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 445 EXPECT_EQ(0, update_count()); 446 EXPECT_EQ(0, error_html_update_count()); 447} 448 449TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsError) { 450 // Original page starts loading. 451 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 452 NetErrorHelperCore::NON_ERROR_PAGE); 453 454 // It fails, and an error page is requested. 455 std::string html; 456 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 457 NetError(net::ERR_CONNECTION_RESET), false, &html); 458 // Should have returned a local error page. 459 EXPECT_FALSE(html.empty()); 460 EXPECT_EQ(NetErrorString(net::ERR_CONNECTION_RESET), html); 461 462 // Error page loads. 463 EXPECT_EQ(0, enable_page_helper_functions_count()); 464 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 465 NetErrorHelperCore::ERROR_PAGE); 466 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 467 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 468 EXPECT_EQ(0, update_count()); 469 EXPECT_EQ(0, error_html_update_count()); 470 EXPECT_EQ(1, enable_page_helper_functions_count()); 471} 472 473TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsErrorWithCorrections) { 474 EnableNavigationCorrections(); 475 476 // Original page starts loading. 477 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 478 NetErrorHelperCore::NON_ERROR_PAGE); 479 480 // It fails, and an error page is requested. 481 std::string html; 482 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 483 NetError(net::ERR_CONNECTION_RESET), false, &html); 484 // Should have returned a local error page. 485 EXPECT_FALSE(html.empty()); 486 EXPECT_EQ(NetErrorString(net::ERR_CONNECTION_RESET), html); 487 488 // Error page loads. 489 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 490 NetErrorHelperCore::ERROR_PAGE); 491 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 492 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 493 EXPECT_EQ(0, update_count()); 494 EXPECT_EQ(0, error_html_update_count()); 495} 496 497// Much like above tests, but with a bunch of spurious DNS status messages that 498// should have no effect. 499TEST_F(NetErrorHelperCoreTest, MainFrameNonDnsErrorSpuriousStatus) { 500 // Original page starts loading. 501 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 502 NetErrorHelperCore::NON_ERROR_PAGE); 503 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 504 505 // It fails, and an error page is requested. 506 std::string html; 507 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 508 NetError(net::ERR_CONNECTION_RESET), 509 false, &html); 510 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 511 512 // Should have returned a local error page. 513 EXPECT_FALSE(html.empty()); 514 EXPECT_EQ(NetErrorString(net::ERR_CONNECTION_RESET), html); 515 516 // Error page loads. 517 518 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 519 NetErrorHelperCore::ERROR_PAGE); 520 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 521 522 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 523 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 524 525 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 526 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 527 528 EXPECT_EQ(0, update_count()); 529 EXPECT_EQ(0, error_html_update_count()); 530} 531 532TEST_F(NetErrorHelperCoreTest, SubFrameDnsError) { 533 // Original page starts loading. 534 core()->OnStartLoad(NetErrorHelperCore::SUB_FRAME, 535 NetErrorHelperCore::NON_ERROR_PAGE); 536 537 // It fails, and an error page is requested. 538 std::string html; 539 core()->GetErrorHTML(NetErrorHelperCore::SUB_FRAME, 540 NetError(net::ERR_NAME_NOT_RESOLVED), 541 false, &html); 542 // Should have returned a local error page. 543 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), html); 544 545 // Error page loads. 546 core()->OnStartLoad(NetErrorHelperCore::SUB_FRAME, 547 NetErrorHelperCore::ERROR_PAGE); 548 core()->OnCommitLoad(NetErrorHelperCore::SUB_FRAME, error_url()); 549 core()->OnFinishLoad(NetErrorHelperCore::SUB_FRAME); 550 EXPECT_EQ(0, update_count()); 551 EXPECT_EQ(0, error_html_update_count()); 552} 553 554TEST_F(NetErrorHelperCoreTest, SubFrameDnsErrorWithCorrections) { 555 EnableNavigationCorrections(); 556 557 // Original page starts loading. 558 core()->OnStartLoad(NetErrorHelperCore::SUB_FRAME, 559 NetErrorHelperCore::NON_ERROR_PAGE); 560 561 // It fails, and an error page is requested. 562 std::string html; 563 core()->GetErrorHTML(NetErrorHelperCore::SUB_FRAME, 564 NetError(net::ERR_NAME_NOT_RESOLVED), 565 false, &html); 566 // Should have returned a local error page. 567 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), html); 568 569 // Error page loads. 570 core()->OnStartLoad(NetErrorHelperCore::SUB_FRAME, 571 NetErrorHelperCore::ERROR_PAGE); 572 core()->OnCommitLoad(NetErrorHelperCore::SUB_FRAME, error_url()); 573 core()->OnFinishLoad(NetErrorHelperCore::SUB_FRAME); 574 EXPECT_EQ(0, update_count()); 575 EXPECT_EQ(0, error_html_update_count()); 576} 577 578// Much like above tests, but with a bunch of spurious DNS status messages that 579// should have no effect. 580TEST_F(NetErrorHelperCoreTest, SubFrameDnsErrorSpuriousStatus) { 581 // Original page starts loading. 582 core()->OnStartLoad(NetErrorHelperCore::SUB_FRAME, 583 NetErrorHelperCore::NON_ERROR_PAGE); 584 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 585 586 // It fails, and an error page is requested. 587 std::string html; 588 core()->GetErrorHTML(NetErrorHelperCore::SUB_FRAME, 589 NetError(net::ERR_NAME_NOT_RESOLVED), 590 false, &html); 591 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 592 593 // Should have returned a local error page. 594 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), html); 595 596 // Error page loads. 597 598 core()->OnStartLoad(NetErrorHelperCore::SUB_FRAME, 599 NetErrorHelperCore::ERROR_PAGE); 600 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 601 602 core()->OnCommitLoad(NetErrorHelperCore::SUB_FRAME, error_url()); 603 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 604 605 core()->OnFinishLoad(NetErrorHelperCore::SUB_FRAME); 606 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 607 608 EXPECT_EQ(0, update_count()); 609 EXPECT_EQ(0, error_html_update_count()); 610} 611 612//------------------------------------------------------------------------------ 613// Tests for updating the error page in response to DNS probe results. None 614// of these have navigation corrections enabled. 615//------------------------------------------------------------------------------ 616 617// Test case where the error page finishes loading before receiving any DNS 618// probe messages. 619TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbe) { 620 // Original page starts loading. 621 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 622 NetErrorHelperCore::NON_ERROR_PAGE); 623 624 // It fails, and an error page is requested. 625 std::string html; 626 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 627 NetError(net::ERR_NAME_NOT_RESOLVED), 628 false, &html); 629 // Should have returned a local error page indicating a probe may run. 630 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 631 632 // Error page loads. 633 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 634 NetErrorHelperCore::ERROR_PAGE); 635 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 636 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 637 EXPECT_EQ(0, update_count()); 638 639 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 640 EXPECT_EQ(1, update_count()); 641 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED), 642 last_error_html()); 643 644 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 645 EXPECT_EQ(2, update_count()); 646 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN), 647 last_error_html()); 648 649 // Any other probe updates should be ignored. 650 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 651 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 652 EXPECT_EQ(2, update_count()); 653 EXPECT_EQ(0, error_html_update_count()); 654} 655 656// Same as above, but the probe is not run. 657TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbeNotRun) { 658 // Original page starts loading. 659 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 660 NetErrorHelperCore::NON_ERROR_PAGE); 661 662 // It fails, and an error page is requested. 663 std::string html; 664 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 665 NetError(net::ERR_NAME_NOT_RESOLVED), 666 false, &html); 667 // Should have returned a local error page indicating a probe may run. 668 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 669 670 // Error page loads. 671 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 672 NetErrorHelperCore::ERROR_PAGE); 673 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 674 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 675 EXPECT_EQ(0, update_count()); 676 677 // When the not run status arrives, the page should revert to the normal dns 678 // error page. 679 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_NOT_RUN); 680 EXPECT_EQ(1, update_count()); 681 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html()); 682 683 // Any other probe updates should be ignored. 684 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 685 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 686 EXPECT_EQ(1, update_count()); 687 EXPECT_EQ(0, error_html_update_count()); 688} 689 690// Same as above, but the probe result is inconclusive. 691TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbeInconclusive) { 692 // Original page starts loading. 693 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 694 NetErrorHelperCore::NON_ERROR_PAGE); 695 696 // It fails, and an error page is requested. 697 std::string html; 698 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 699 NetError(net::ERR_NAME_NOT_RESOLVED), 700 false, &html); 701 // Should have returned a local error page indicating a probe may run. 702 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 703 704 // Error page loads. 705 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 706 NetErrorHelperCore::ERROR_PAGE); 707 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 708 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 709 EXPECT_EQ(0, update_count()); 710 711 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 712 EXPECT_EQ(1, update_count()); 713 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED), 714 last_error_html()); 715 716 // When the inconclusive status arrives, the page should revert to the normal 717 // dns error page. 718 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE); 719 EXPECT_EQ(2, update_count()); 720 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html()); 721 722 // Any other probe updates should be ignored. 723 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE); 724 EXPECT_EQ(2, update_count()); 725 EXPECT_EQ(0, error_html_update_count()); 726} 727 728// Same as above, but the probe result is no internet. 729TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbeNoInternet) { 730 // Original page starts loading. 731 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 732 NetErrorHelperCore::NON_ERROR_PAGE); 733 734 // It fails, and an error page is requested. 735 std::string html; 736 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 737 NetError(net::ERR_NAME_NOT_RESOLVED), 738 false, &html); 739 // Should have returned a local error page indicating a probe may run. 740 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 741 742 // Error page loads. 743 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 744 NetErrorHelperCore::ERROR_PAGE); 745 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 746 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 747 EXPECT_EQ(0, update_count()); 748 749 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 750 EXPECT_EQ(1, update_count()); 751 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED), 752 last_error_html()); 753 754 // When the inconclusive status arrives, the page should revert to the normal 755 // dns error page. 756 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET); 757 EXPECT_EQ(2, update_count()); 758 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET), 759 last_error_html()); 760 761 // Any other probe updates should be ignored. 762 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET); 763 EXPECT_EQ(2, update_count()); 764 EXPECT_EQ(0, error_html_update_count()); 765} 766 767// Same as above, but the probe result is bad config. 768TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbeBadConfig) { 769 // Original page starts loading. 770 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 771 NetErrorHelperCore::NON_ERROR_PAGE); 772 773 // It fails, and an error page is requested. 774 std::string html; 775 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 776 NetError(net::ERR_NAME_NOT_RESOLVED), 777 false, &html); 778 // Should have returned a local error page indicating a probe may run. 779 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 780 781 // Error page loads. 782 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 783 NetErrorHelperCore::ERROR_PAGE); 784 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 785 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 786 EXPECT_EQ(0, update_count()); 787 788 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 789 EXPECT_EQ(1, update_count()); 790 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED), 791 last_error_html()); 792 793 // When the inconclusive status arrives, the page should revert to the normal 794 // dns error page. 795 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_BAD_CONFIG); 796 EXPECT_EQ(2, update_count()); 797 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_BAD_CONFIG), 798 last_error_html()); 799 800 // Any other probe updates should be ignored. 801 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_BAD_CONFIG); 802 EXPECT_EQ(2, update_count()); 803 EXPECT_EQ(0, error_html_update_count()); 804} 805 806// Test case where the error page finishes loading after receiving the start 807// DNS probe message. 808TEST_F(NetErrorHelperCoreTest, FinishedAfterStartProbe) { 809 // Original page starts loading. 810 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 811 NetErrorHelperCore::NON_ERROR_PAGE); 812 813 // It fails, and an error page is requested. 814 std::string html; 815 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 816 NetError(net::ERR_NAME_NOT_RESOLVED), 817 false, &html); 818 // Should have returned a local error page indicating a probe may run. 819 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 820 821 // Error page loads. 822 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 823 NetErrorHelperCore::ERROR_PAGE); 824 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 825 826 // Nothing should be done when a probe status comes in before loading 827 // finishes. 828 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 829 EXPECT_EQ(0, update_count()); 830 831 // When loading finishes, however, the buffered probe status should be sent 832 // to the page. 833 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 834 EXPECT_EQ(1, update_count()); 835 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED), 836 last_error_html()); 837 838 // Should update the page again when the probe result comes in. 839 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 840 EXPECT_EQ(2, update_count()); 841 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN), 842 last_error_html()); 843 844 // Any other probe updates should be ignored. 845 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_NOT_RUN); 846 EXPECT_EQ(2, update_count()); 847} 848 849// Test case where the error page finishes loading before receiving any DNS 850// probe messages and the request is a POST. 851TEST_F(NetErrorHelperCoreTest, FinishedBeforeProbePost) { 852 // Original page starts loading. 853 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 854 NetErrorHelperCore::NON_ERROR_PAGE); 855 856 // It fails, and an error page is requested. 857 std::string html; 858 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 859 NetError(net::ERR_NAME_NOT_RESOLVED), 860 true, &html); 861 // Should have returned a local error page indicating a probe may run. 862 EXPECT_EQ(ErrorToString( 863 ProbeError(chrome_common_net::DNS_PROBE_POSSIBLE), 864 true), 865 html); 866 867 // Error page loads. 868 EXPECT_EQ(0, enable_page_helper_functions_count()); 869 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 870 NetErrorHelperCore::ERROR_PAGE); 871 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 872 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 873 EXPECT_EQ(0, update_count()); 874 EXPECT_EQ(1, enable_page_helper_functions_count()); 875 876 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 877 EXPECT_EQ(1, update_count()); 878 EXPECT_EQ(ErrorToString( 879 ProbeError(chrome_common_net::DNS_PROBE_STARTED), true), 880 last_error_html()); 881 882 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 883 EXPECT_EQ(2, update_count()); 884 EXPECT_EQ(ErrorToString( 885 ProbeError(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN), 886 true), 887 last_error_html()); 888 EXPECT_EQ(0, error_html_update_count()); 889} 890 891// Test case where the probe finishes before the page is committed. 892TEST_F(NetErrorHelperCoreTest, ProbeFinishesEarly) { 893 // Original page starts loading. 894 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 895 NetErrorHelperCore::NON_ERROR_PAGE); 896 897 // It fails, and an error page is requested. 898 std::string html; 899 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 900 NetError(net::ERR_NAME_NOT_RESOLVED), 901 false, &html); 902 // Should have returned a local error page indicating a probe may run. 903 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 904 905 // Error page starts loading. 906 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 907 NetErrorHelperCore::ERROR_PAGE); 908 909 // Nothing should be done when the probe statuses come in before loading 910 // finishes. 911 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 912 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 913 EXPECT_EQ(0, update_count()); 914 915 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 916 EXPECT_EQ(0, update_count()); 917 918 // When loading finishes, however, the buffered probe status should be sent 919 // to the page. 920 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 921 EXPECT_EQ(1, update_count()); 922 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN), 923 last_error_html()); 924 925 // Any other probe updates should be ignored. 926 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 927 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 928 EXPECT_EQ(1, update_count()); 929} 930 931// Test case where one error page loads completely before a new navigation 932// results in another error page. Probes are run for both pages. 933TEST_F(NetErrorHelperCoreTest, TwoErrorsWithProbes) { 934 // Original page starts loading. 935 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 936 NetErrorHelperCore::NON_ERROR_PAGE); 937 938 // It fails, and an error page is requested. 939 std::string html; 940 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 941 NetError(net::ERR_NAME_NOT_RESOLVED), 942 false, &html); 943 // Should have returned a local error page indicating a probe may run. 944 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 945 946 // Error page loads. 947 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 948 NetErrorHelperCore::ERROR_PAGE); 949 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 950 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 951 952 // Probe results come in. 953 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 954 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 955 EXPECT_EQ(2, update_count()); 956 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN), 957 last_error_html()); 958 959 // The process starts again. 960 961 // Normal page starts loading. 962 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 963 NetErrorHelperCore::NON_ERROR_PAGE); 964 965 // It fails, and an error page is requested. 966 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 967 NetError(net::ERR_NAME_NOT_RESOLVED), 968 false, &html); 969 // Should have returned a local error page indicating a probe may run. 970 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 971 972 // Error page loads. 973 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 974 NetErrorHelperCore::ERROR_PAGE); 975 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 976 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 977 EXPECT_EQ(2, update_count()); 978 979 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 980 EXPECT_EQ(3, update_count()); 981 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED), 982 last_error_html()); 983 984 // The probe returns a different result this time. 985 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET); 986 EXPECT_EQ(4, update_count()); 987 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET), 988 last_error_html()); 989 EXPECT_EQ(0, error_html_update_count()); 990} 991 992// Test case where one error page loads completely before a new navigation 993// results in another error page. Probe results for the first probe are only 994// received after the second load starts, but before it commits. 995TEST_F(NetErrorHelperCoreTest, TwoErrorsWithProbesAfterSecondStarts) { 996 // Original page starts loading. 997 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 998 NetErrorHelperCore::NON_ERROR_PAGE); 999 1000 // It fails, and an error page is requested. 1001 std::string html; 1002 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1003 NetError(net::ERR_NAME_NOT_RESOLVED), 1004 false, &html); 1005 // Should have returned a local error page indicating a probe may run. 1006 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 1007 1008 // Error page loads. 1009 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1010 NetErrorHelperCore::ERROR_PAGE); 1011 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1012 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1013 1014 // The process starts again. 1015 1016 // Normal page starts loading. 1017 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1018 NetErrorHelperCore::NON_ERROR_PAGE); 1019 1020 // It fails, and an error page is requested. 1021 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1022 NetError(net::ERR_NAME_NOT_RESOLVED), 1023 false, &html); 1024 // Should have returned a local error page indicating a probe may run. 1025 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 1026 1027 // Error page starts to load. 1028 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1029 NetErrorHelperCore::ERROR_PAGE); 1030 1031 // Probe results come in, and the first page is updated. 1032 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1033 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1034 EXPECT_EQ(2, update_count()); 1035 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN), 1036 last_error_html()); 1037 1038 // Second page finishes loading, and is updated using the same probe result. 1039 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1040 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1041 EXPECT_EQ(3, update_count()); 1042 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN), 1043 last_error_html()); 1044 1045 // Other probe results should be ignored. 1046 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET); 1047 EXPECT_EQ(3, update_count()); 1048 EXPECT_EQ(0, error_html_update_count()); 1049} 1050 1051// Same as above, but a new page is loaded before the error page commits. 1052TEST_F(NetErrorHelperCoreTest, ErrorPageLoadInterrupted) { 1053 // Original page starts loading. 1054 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1055 NetErrorHelperCore::NON_ERROR_PAGE); 1056 1057 // It fails, and an error page is requested. 1058 std::string html; 1059 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1060 NetError(net::ERR_NAME_NOT_RESOLVED), 1061 false, &html); 1062 // Should have returned a local error page indicating a probe may run. 1063 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 1064 1065 // Error page starts loading. 1066 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1067 NetErrorHelperCore::ERROR_PAGE); 1068 // Probe statuses come in, but should be ignored. 1069 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1070 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1071 EXPECT_EQ(0, update_count()); 1072 1073 // A new navigation begins while the error page is loading. 1074 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1075 NetErrorHelperCore::NON_ERROR_PAGE); 1076 1077 // And fails. 1078 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1079 NetError(net::ERR_NAME_NOT_RESOLVED), 1080 false, &html); 1081 // Should have returned a local error page indicating a probe may run. 1082 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE), html); 1083 1084 // Error page finishes loading. 1085 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1086 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1087 1088 // Probe results come in. 1089 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1090 EXPECT_EQ(1, update_count()); 1091 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED), 1092 last_error_html()); 1093 1094 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET); 1095 EXPECT_EQ(2, update_count()); 1096 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET), 1097 last_error_html()); 1098 EXPECT_EQ(0, error_html_update_count()); 1099} 1100 1101//------------------------------------------------------------------------------ 1102// Navigation correction tests. 1103//------------------------------------------------------------------------------ 1104 1105// Check that corrections are not used for HTTPS URLs. 1106TEST_F(NetErrorHelperCoreTest, NoCorrectionsForHttps) { 1107 // Original page starts loading. 1108 EnableNavigationCorrections(); 1109 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1110 NetErrorHelperCore::NON_ERROR_PAGE); 1111 1112 // The HTTPS page fails to load. 1113 std::string html; 1114 blink::WebURLError error = NetError(net::ERR_NAME_NOT_RESOLVED); 1115 error.unreachableURL = GURL(kFailedHttpsUrl); 1116 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, error, false, &html); 1117 1118 blink::WebURLError probe_error = 1119 ProbeError(chrome_common_net::DNS_PROBE_POSSIBLE); 1120 probe_error.unreachableURL = GURL(kFailedHttpsUrl); 1121 EXPECT_EQ(ErrorToString(probe_error, false), html); 1122 EXPECT_FALSE(is_url_being_fetched()); 1123 EXPECT_FALSE(last_error_page_params()); 1124 1125 // The blank page loads, no error page is loaded. 1126 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1127 NetErrorHelperCore::ERROR_PAGE); 1128 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1129 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1130 EXPECT_FALSE(is_url_being_fetched()); 1131 EXPECT_FALSE(last_error_page_params()); 1132 1133 // Page is updated in response to DNS probes as normal. 1134 EXPECT_EQ(0, update_count()); 1135 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1136 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1137 EXPECT_EQ(2, update_count()); 1138 EXPECT_FALSE(last_error_page_params()); 1139 blink::WebURLError final_probe_error = 1140 ProbeError(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1141 final_probe_error.unreachableURL = GURL(kFailedHttpsUrl); 1142 EXPECT_EQ(ErrorToString(final_probe_error, false), last_error_html()); 1143} 1144 1145// The blank page loads, then the navigation corrections request succeeds and is 1146// loaded. Then the probe results come in. 1147TEST_F(NetErrorHelperCoreTest, CorrectionsReceivedBeforeProbe) { 1148 // Original page starts loading. 1149 EnableNavigationCorrections(); 1150 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1151 NetErrorHelperCore::NON_ERROR_PAGE); 1152 1153 // It fails. 1154 std::string html; 1155 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1156 NetError(net::ERR_NAME_NOT_RESOLVED), 1157 false, &html); 1158 EXPECT_TRUE(html.empty()); 1159 EXPECT_FALSE(is_url_being_fetched()); 1160 EXPECT_FALSE(last_error_page_params()); 1161 1162 // The blank page loads. 1163 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1164 NetErrorHelperCore::ERROR_PAGE); 1165 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1166 1167 // Corrections retrieval starts when the error page finishes loading. 1168 EXPECT_FALSE(is_url_being_fetched()); 1169 EXPECT_FALSE(last_error_page_params()); 1170 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1171 EXPECT_TRUE(is_url_being_fetched()); 1172 EXPECT_FALSE(last_error_page_params()); 1173 1174 // Corrections are retrieved. 1175 NavigationCorrectionsLoadSuccess(kDefaultCorrections, 1176 arraysize(kDefaultCorrections)); 1177 EXPECT_EQ(1, error_html_update_count()); 1178 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html()); 1179 ExpectDefaultNavigationCorrections(); 1180 EXPECT_FALSE(is_url_being_fetched()); 1181 1182 // Corrections load. 1183 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1184 NetErrorHelperCore::ERROR_PAGE); 1185 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1186 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1187 1188 // Any probe statuses should be ignored. 1189 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1190 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1191 1192 EXPECT_EQ(0, update_count()); 1193 EXPECT_EQ(1, error_html_update_count()); 1194} 1195 1196// The blank page finishes loading, then probe results come in, and then 1197// the navigation corrections request succeeds. 1198TEST_F(NetErrorHelperCoreTest, CorrectionsRetrievedAfterProbes) { 1199 // Original page starts loading. 1200 EnableNavigationCorrections(); 1201 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1202 NetErrorHelperCore::NON_ERROR_PAGE); 1203 1204 // It fails, and corrections are requested. 1205 std::string html; 1206 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1207 NetError(net::ERR_NAME_NOT_RESOLVED), 1208 false, &html); 1209 EXPECT_TRUE(html.empty()); 1210 1211 // The blank page loads. 1212 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1213 NetErrorHelperCore::ERROR_PAGE); 1214 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1215 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1216 EXPECT_TRUE(is_url_being_fetched()); 1217 EXPECT_FALSE(last_error_page_params()); 1218 1219 // Probe statuses should be ignored. 1220 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1221 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1222 EXPECT_EQ(0, update_count()); 1223 EXPECT_EQ(0, error_html_update_count()); 1224 EXPECT_FALSE(last_error_page_params()); 1225 1226 // Corrections are retrieved. 1227 EXPECT_TRUE(is_url_being_fetched()); 1228 NavigationCorrectionsLoadSuccess(kDefaultCorrections, 1229 arraysize(kDefaultCorrections)); 1230 EXPECT_EQ(1, error_html_update_count()); 1231 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html()); 1232 ExpectDefaultNavigationCorrections(); 1233 EXPECT_FALSE(is_url_being_fetched()); 1234 1235 // Corrections load. 1236 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1237 NetErrorHelperCore::ERROR_PAGE); 1238 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1239 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1240 EXPECT_EQ(1, error_html_update_count()); 1241 EXPECT_EQ(0, update_count()); 1242} 1243 1244// The corrections request fails and then the error page loads for an error that 1245// does not trigger DNS probes. 1246TEST_F(NetErrorHelperCoreTest, CorrectionsFailLoadNoProbes) { 1247 // Original page starts loading. 1248 EnableNavigationCorrections(); 1249 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1250 NetErrorHelperCore::NON_ERROR_PAGE); 1251 1252 // It fails, and corrections are requested. 1253 std::string html; 1254 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1255 NetError(net::ERR_CONNECTION_FAILED), 1256 false, &html); 1257 EXPECT_TRUE(html.empty()); 1258 1259 // The blank page loads. 1260 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1261 NetErrorHelperCore::ERROR_PAGE); 1262 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1263 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1264 1265 // Corrections request fails, final error page is shown. 1266 EXPECT_TRUE(is_url_being_fetched()); 1267 NavigationCorrectionsLoadFailure(); 1268 EXPECT_EQ(1, error_html_update_count()); 1269 EXPECT_EQ(last_error_html(), NetErrorString(net::ERR_CONNECTION_FAILED)); 1270 EXPECT_FALSE(is_url_being_fetched()); 1271 EXPECT_EQ(0, update_count()); 1272 EXPECT_FALSE(last_error_page_params()); 1273 1274 // Error page loads. 1275 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1276 NetErrorHelperCore::ERROR_PAGE); 1277 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1278 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1279 1280 // If probe statuses come in last from another page load, they should be 1281 // ignored. 1282 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1283 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1284 EXPECT_EQ(0, update_count()); 1285 EXPECT_EQ(1, error_html_update_count()); 1286} 1287 1288// The corrections request fails and then the error page loads before probe 1289// results are received. 1290TEST_F(NetErrorHelperCoreTest, CorrectionsFailLoadBeforeProbe) { 1291 // Original page starts loading. 1292 EnableNavigationCorrections(); 1293 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1294 NetErrorHelperCore::NON_ERROR_PAGE); 1295 1296 // It fails, and corrections are requested. 1297 std::string html; 1298 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1299 NetError(net::ERR_NAME_NOT_RESOLVED), 1300 false, &html); 1301 EXPECT_TRUE(html.empty()); 1302 1303 // The blank page loads. 1304 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1305 NetErrorHelperCore::ERROR_PAGE); 1306 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1307 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1308 1309 // Corrections request fails, probe pending page shown. 1310 EXPECT_TRUE(is_url_being_fetched()); 1311 NavigationCorrectionsLoadFailure(); 1312 EXPECT_EQ(1, error_html_update_count()); 1313 EXPECT_EQ(last_error_html(), 1314 ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE)); 1315 EXPECT_FALSE(is_url_being_fetched()); 1316 EXPECT_EQ(0, update_count()); 1317 1318 // Probe page loads. 1319 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1320 NetErrorHelperCore::ERROR_PAGE); 1321 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1322 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1323 1324 // Probe statuses comes in, and page is updated. 1325 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1326 EXPECT_EQ(1, update_count()); 1327 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED), 1328 last_error_html()); 1329 1330 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1331 EXPECT_EQ(2, update_count()); 1332 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN), 1333 last_error_html()); 1334 1335 // The commit results in sending a second probe status, which is ignored. 1336 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1337 EXPECT_EQ(2, update_count()); 1338 EXPECT_EQ(1, error_html_update_count()); 1339} 1340 1341// The corrections request fails after receiving probe results. 1342TEST_F(NetErrorHelperCoreTest, CorrectionsFailAfterProbe) { 1343 // Original page starts loading. 1344 EnableNavigationCorrections(); 1345 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1346 NetErrorHelperCore::NON_ERROR_PAGE); 1347 1348 // It fails, and corrections are requested. 1349 std::string html; 1350 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1351 NetError(net::ERR_NAME_NOT_RESOLVED), 1352 false, &html); 1353 EXPECT_TRUE(html.empty()); 1354 1355 // The blank page loads. 1356 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1357 NetErrorHelperCore::ERROR_PAGE); 1358 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1359 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1360 1361 // Results come in, but end up being ignored. 1362 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1363 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1364 EXPECT_EQ(0, update_count()); 1365 1366 // Corrections request fails, probe pending page shown. 1367 EXPECT_TRUE(is_url_being_fetched()); 1368 NavigationCorrectionsLoadFailure(); 1369 EXPECT_EQ(1, error_html_update_count()); 1370 EXPECT_EQ(last_error_html(), 1371 ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE)); 1372 EXPECT_FALSE(is_url_being_fetched()); 1373 EXPECT_EQ(0, update_count()); 1374 1375 // Probe page loads. 1376 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1377 NetErrorHelperCore::ERROR_PAGE); 1378 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1379 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1380 1381 // Probe statuses comes in, and page is updated. 1382 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1383 EXPECT_EQ(1, update_count()); 1384 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN), 1385 last_error_html()); 1386 EXPECT_EQ(1, error_html_update_count()); 1387} 1388 1389// An error page load that would normally load correction is interrupted 1390// by a new navigation before the blank page commits. 1391TEST_F(NetErrorHelperCoreTest, CorrectionsInterruptedBeforeCommit) { 1392 // Original page starts loading. 1393 EnableNavigationCorrections(); 1394 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1395 NetErrorHelperCore::NON_ERROR_PAGE); 1396 1397 // It fails, and corrections are requested. 1398 std::string html; 1399 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1400 NetError(net::ERR_NAME_NOT_RESOLVED), 1401 false, &html); 1402 EXPECT_TRUE(html.empty()); 1403 1404 // The blank page starts loading. 1405 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1406 NetErrorHelperCore::ERROR_PAGE); 1407 1408 // A new page load starts. 1409 EXPECT_FALSE(is_url_being_fetched()); 1410 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1411 NetErrorHelperCore::NON_ERROR_PAGE); 1412 1413 // A new page load interrupts the original load. 1414 EXPECT_FALSE(is_url_being_fetched()); 1415 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1416 NetErrorHelperCore::NON_ERROR_PAGE); 1417 EXPECT_FALSE(is_url_being_fetched()); 1418 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, default_url()); 1419 EXPECT_FALSE(is_url_being_fetched()); 1420 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1421 1422 EXPECT_FALSE(is_url_being_fetched()); 1423 EXPECT_EQ(0, update_count()); 1424 EXPECT_EQ(0, error_html_update_count()); 1425} 1426 1427// An error page load that would normally load corrections is interrupted 1428// by a new navigation before the blank page finishes loading. 1429TEST_F(NetErrorHelperCoreTest, CorrectionsInterruptedBeforeLoad) { 1430 // Original page starts loading. 1431 EnableNavigationCorrections(); 1432 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1433 NetErrorHelperCore::NON_ERROR_PAGE); 1434 1435 // It fails, and corrections are requested. 1436 std::string html; 1437 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1438 NetError(net::ERR_NAME_NOT_RESOLVED), 1439 false, &html); 1440 EXPECT_TRUE(html.empty()); 1441 1442 // The blank page starts loading and is committed. 1443 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1444 NetErrorHelperCore::ERROR_PAGE); 1445 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1446 1447 // A new page load interrupts the original load. 1448 EXPECT_FALSE(is_url_being_fetched()); 1449 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1450 NetErrorHelperCore::NON_ERROR_PAGE); 1451 EXPECT_FALSE(is_url_being_fetched()); 1452 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, default_url()); 1453 EXPECT_FALSE(is_url_being_fetched()); 1454 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1455 1456 EXPECT_FALSE(is_url_being_fetched()); 1457 EXPECT_EQ(0, update_count()); 1458 EXPECT_EQ(0, error_html_update_count()); 1459} 1460 1461// The corrections request is cancelled due to a new navigation. The new 1462// navigation fails and then loads corrections successfully. 1463TEST_F(NetErrorHelperCoreTest, CorrectionsInterrupted) { 1464 // Original page starts loading. 1465 EnableNavigationCorrections(); 1466 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1467 NetErrorHelperCore::NON_ERROR_PAGE); 1468 1469 // It fails, and corrections are requested. 1470 std::string html; 1471 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1472 NetError(net::ERR_NAME_NOT_RESOLVED), 1473 false, &html); 1474 EXPECT_TRUE(html.empty()); 1475 1476 // The blank page loads. 1477 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1478 NetErrorHelperCore::ERROR_PAGE); 1479 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1480 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1481 EXPECT_TRUE(is_url_being_fetched()); 1482 1483 // Results come in, but end up being ignored. 1484 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1485 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1486 EXPECT_EQ(0, update_count()); 1487 1488 // A new load appears! 1489 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1490 NetErrorHelperCore::NON_ERROR_PAGE); 1491 EXPECT_FALSE(is_url_being_fetched()); 1492 1493 // It fails, and corrections are requested again once a blank page is loaded. 1494 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1495 NetError(net::ERR_NAME_NOT_RESOLVED), 1496 false, &html); 1497 EXPECT_TRUE(html.empty()); 1498 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1499 NetErrorHelperCore::ERROR_PAGE); 1500 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1501 EXPECT_FALSE(is_url_being_fetched()); 1502 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1503 EXPECT_TRUE(is_url_being_fetched()); 1504 1505 // Corrections request succeeds. 1506 NavigationCorrectionsLoadSuccess(kDefaultCorrections, 1507 arraysize(kDefaultCorrections)); 1508 EXPECT_EQ(1, error_html_update_count()); 1509 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html()); 1510 ExpectDefaultNavigationCorrections(); 1511 EXPECT_FALSE(is_url_being_fetched()); 1512 1513 // Probe statuses come in, and are ignored. 1514 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1515 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1516 EXPECT_EQ(0, update_count()); 1517} 1518 1519// The corrections request is cancelled due to call to Stop(). The cross 1520// process navigation is cancelled, and then a new load fails and tries to load 1521// corrections again, unsuccessfully. 1522TEST_F(NetErrorHelperCoreTest, CorrectionsStopped) { 1523 // Original page starts loading. 1524 EnableNavigationCorrections(); 1525 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1526 NetErrorHelperCore::NON_ERROR_PAGE); 1527 1528 // It fails, and corrections are requested. 1529 std::string html; 1530 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1531 NetError(net::ERR_NAME_NOT_RESOLVED), 1532 false, &html); 1533 EXPECT_TRUE(html.empty()); 1534 1535 // The blank page loads. 1536 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1537 NetErrorHelperCore::ERROR_PAGE); 1538 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1539 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1540 1541 EXPECT_TRUE(is_url_being_fetched()); 1542 core()->OnStop(); 1543 EXPECT_FALSE(is_url_being_fetched()); 1544 1545 // Results come in, but end up being ignored. 1546 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1547 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1548 EXPECT_EQ(0, update_count()); 1549 1550 // Cross process navigation must have been cancelled, and a new load appears! 1551 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1552 NetErrorHelperCore::NON_ERROR_PAGE); 1553 1554 // It fails, and corrections are requested again. 1555 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1556 NetError(net::ERR_NAME_NOT_RESOLVED), 1557 false, &html); 1558 EXPECT_TRUE(html.empty()); 1559 1560 // The blank page loads again. 1561 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1562 NetErrorHelperCore::ERROR_PAGE); 1563 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1564 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1565 EXPECT_TRUE(is_url_being_fetched()); 1566 1567 // Corrections request fails, probe pending page shown. 1568 NavigationCorrectionsLoadFailure(); 1569 EXPECT_EQ(1, error_html_update_count()); 1570 EXPECT_EQ(last_error_html(), 1571 ProbeErrorString(chrome_common_net::DNS_PROBE_POSSIBLE)); 1572 EXPECT_FALSE(is_url_being_fetched()); 1573 1574 // Probe page loads. 1575 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1576 NetErrorHelperCore::ERROR_PAGE); 1577 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1578 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1579 1580 // Probe statuses comes in, and page is updated. 1581 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_STARTED); 1582 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_STARTED), 1583 last_error_html()); 1584 EXPECT_EQ(1, update_count()); 1585 1586 core()->OnNetErrorInfo(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 1587 EXPECT_EQ(2, update_count()); 1588 EXPECT_EQ(ProbeErrorString(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN), 1589 last_error_html()); 1590 EXPECT_EQ(1, error_html_update_count()); 1591} 1592 1593// Check the case corrections are disabled while the blank page (Loaded 1594// before the corrections page) is being loaded. 1595TEST_F(NetErrorHelperCoreTest, CorrectionsDisabledBeforeFetch) { 1596 // Original page starts loading. 1597 EnableNavigationCorrections(); 1598 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1599 NetErrorHelperCore::NON_ERROR_PAGE); 1600 1601 // It fails, and corrections are requested. 1602 std::string html; 1603 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1604 NetError(net::ERR_NAME_NOT_RESOLVED), 1605 false, &html); 1606 EXPECT_TRUE(html.empty()); 1607 1608 // The blank page loads. 1609 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1610 NetErrorHelperCore::ERROR_PAGE); 1611 // Corrections is disabled. 1612 DisableNavigationCorrections(); 1613 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1614 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1615 EXPECT_TRUE(is_url_being_fetched()); 1616 EXPECT_FALSE(last_error_page_params()); 1617 1618 // Corrections are retrieved. 1619 NavigationCorrectionsLoadSuccess(kDefaultCorrections, 1620 arraysize(kDefaultCorrections)); 1621 EXPECT_EQ(1, error_html_update_count()); 1622 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html()); 1623 EXPECT_FALSE(is_url_being_fetched()); 1624 ExpectDefaultNavigationCorrections(); 1625 1626 // Corrections load. 1627 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1628 NetErrorHelperCore::ERROR_PAGE); 1629 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1630 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1631 EXPECT_EQ(1, error_html_update_count()); 1632 EXPECT_EQ(0, update_count()); 1633} 1634 1635// Check the case corrections is disabled while fetching the corrections for 1636// a failed page load. 1637TEST_F(NetErrorHelperCoreTest, CorrectionsDisabledDuringFetch) { 1638 // Original page starts loading. 1639 EnableNavigationCorrections(); 1640 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1641 NetErrorHelperCore::NON_ERROR_PAGE); 1642 1643 // It fails, and corrections are requested. 1644 std::string html; 1645 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1646 NetError(net::ERR_NAME_NOT_RESOLVED), 1647 false, &html); 1648 EXPECT_TRUE(html.empty()); 1649 1650 // The blank page loads. 1651 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1652 NetErrorHelperCore::ERROR_PAGE); 1653 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1654 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1655 EXPECT_TRUE(is_url_being_fetched()); 1656 EXPECT_FALSE(last_error_page_params()); 1657 1658 // Corrections are disabled. 1659 DisableNavigationCorrections(); 1660 1661 // Corrections are retrieved. 1662 NavigationCorrectionsLoadSuccess(kDefaultCorrections, 1663 arraysize(kDefaultCorrections)); 1664 EXPECT_EQ(1, error_html_update_count()); 1665 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html()); 1666 EXPECT_FALSE(is_url_being_fetched()); 1667 ExpectDefaultNavigationCorrections(); 1668 1669 // Corrections load. 1670 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1671 NetErrorHelperCore::ERROR_PAGE); 1672 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1673 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1674 EXPECT_EQ(1, error_html_update_count()); 1675 EXPECT_EQ(0, update_count()); 1676} 1677 1678// Checks corrections are is used when there are no search suggestions. 1679TEST_F(NetErrorHelperCoreTest, CorrectionsWithoutSearch) { 1680 const NavigationCorrection kCorrections[] = { 1681 {"urlCorrection", "http://somewhere_else/", "btn", "data", false, false}, 1682 }; 1683 1684 // Original page starts loading. 1685 EnableNavigationCorrections(); 1686 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1687 NetErrorHelperCore::NON_ERROR_PAGE); 1688 1689 // It fails, and corrections are requested. 1690 std::string html; 1691 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1692 NetError(net::ERR_NAME_NOT_RESOLVED), 1693 false, &html); 1694 EXPECT_TRUE(html.empty()); 1695 1696 // The blank page loads. 1697 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1698 NetErrorHelperCore::ERROR_PAGE); 1699 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1700 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1701 EXPECT_TRUE(is_url_being_fetched()); 1702 EXPECT_FALSE(last_error_page_params()); 1703 1704 // Corrections are retrieved. 1705 NavigationCorrectionsLoadSuccess(kCorrections, arraysize(kCorrections)); 1706 EXPECT_EQ(1, error_html_update_count()); 1707 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html()); 1708 EXPECT_FALSE(is_url_being_fetched()); 1709 1710 // Check params. 1711 ASSERT_TRUE(last_error_page_params()); 1712 EXPECT_FALSE(last_error_page_params()->suggest_reload); 1713 EXPECT_EQ(1u, last_error_page_params()->override_suggestions->GetSize()); 1714 EXPECT_FALSE(last_error_page_params()->search_url.is_valid()); 1715 EXPECT_EQ("", last_error_page_params()->search_terms); 1716 1717 // Corrections load. 1718 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1719 NetErrorHelperCore::ERROR_PAGE); 1720 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1721 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1722 EXPECT_EQ(1, error_html_update_count()); 1723 EXPECT_EQ(0, update_count()); 1724} 1725 1726// Checks corrections are used when there are only search suggestions. 1727TEST_F(NetErrorHelperCoreTest, CorrectionsOnlySearchSuggestion) { 1728 const NavigationCorrection kCorrections[] = { 1729 {"webSearchQuery", kSuggestedSearchTerms, "frm", "data", false, false}, 1730 }; 1731 1732 // Original page starts loading. 1733 EnableNavigationCorrections(); 1734 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1735 NetErrorHelperCore::NON_ERROR_PAGE); 1736 1737 // It fails, and corrections are requested. 1738 std::string html; 1739 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1740 NetError(net::ERR_NAME_NOT_RESOLVED), 1741 false, &html); 1742 EXPECT_TRUE(html.empty()); 1743 1744 // The blank page loads. 1745 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1746 NetErrorHelperCore::ERROR_PAGE); 1747 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1748 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1749 EXPECT_TRUE(is_url_being_fetched()); 1750 EXPECT_FALSE(last_error_page_params()); 1751 1752 // Corrections are retrieved. 1753 NavigationCorrectionsLoadSuccess(kCorrections, arraysize(kCorrections)); 1754 EXPECT_EQ(1, error_html_update_count()); 1755 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html()); 1756 EXPECT_FALSE(is_url_being_fetched()); 1757 1758 // Check params. 1759 ASSERT_TRUE(last_error_page_params()); 1760 EXPECT_FALSE(last_error_page_params()->suggest_reload); 1761 EXPECT_EQ(0u, last_error_page_params()->override_suggestions->GetSize()); 1762 EXPECT_EQ(GURL(kSearchUrl), last_error_page_params()->search_url); 1763 EXPECT_EQ(kSuggestedSearchTerms, last_error_page_params()->search_terms); 1764 1765 // Corrections load. 1766 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1767 NetErrorHelperCore::ERROR_PAGE); 1768 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1769 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1770 EXPECT_EQ(1, error_html_update_count()); 1771 EXPECT_EQ(0, update_count()); 1772} 1773 1774// The correction service returns a non-JSON result. 1775TEST_F(NetErrorHelperCoreTest, CorrectionServiceReturnsNonJsonResult) { 1776 // Original page starts loading. 1777 EnableNavigationCorrections(); 1778 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1779 NetErrorHelperCore::NON_ERROR_PAGE); 1780 1781 // It fails, and corrections are requested. 1782 std::string html; 1783 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1784 NetError(net::ERR_CONNECTION_FAILED), 1785 false, &html); 1786 EXPECT_TRUE(html.empty()); 1787 1788 // The blank page loads. 1789 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1790 NetErrorHelperCore::ERROR_PAGE); 1791 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1792 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1793 1794 // Corrections request fails, final error page is shown. 1795 EXPECT_TRUE(is_url_being_fetched()); 1796 NavigationCorrectionsLoadFinished("Weird Response"); 1797 EXPECT_EQ(1, error_html_update_count()); 1798 EXPECT_EQ(last_error_html(), NetErrorString(net::ERR_CONNECTION_FAILED)); 1799 EXPECT_FALSE(is_url_being_fetched()); 1800 EXPECT_EQ(0, update_count()); 1801 EXPECT_FALSE(last_error_page_params()); 1802 1803 // Error page loads. 1804 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1805 NetErrorHelperCore::ERROR_PAGE); 1806 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1807 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1808} 1809 1810// The correction service returns a JSON result that isn't a valid list of 1811// corrections. 1812TEST_F(NetErrorHelperCoreTest, CorrectionServiceReturnsInvalidJsonResult) { 1813 // Original page starts loading. 1814 EnableNavigationCorrections(); 1815 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1816 NetErrorHelperCore::NON_ERROR_PAGE); 1817 1818 // It fails, and corrections are requested. 1819 std::string html; 1820 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1821 NetError(net::ERR_CONNECTION_FAILED), 1822 false, &html); 1823 EXPECT_TRUE(html.empty()); 1824 1825 // The blank page loads. 1826 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1827 NetErrorHelperCore::ERROR_PAGE); 1828 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1829 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1830 1831 // Corrections request fails, final error page is shown. 1832 EXPECT_TRUE(is_url_being_fetched()); 1833 NavigationCorrectionsLoadFinished("{\"result\": 42}"); 1834 EXPECT_EQ(1, error_html_update_count()); 1835 EXPECT_EQ(last_error_html(), NetErrorString(net::ERR_CONNECTION_FAILED)); 1836 EXPECT_FALSE(is_url_being_fetched()); 1837 EXPECT_EQ(0, update_count()); 1838 EXPECT_FALSE(last_error_page_params()); 1839 1840 // Error page loads. 1841 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1842 NetErrorHelperCore::ERROR_PAGE); 1843 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1844 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1845} 1846 1847TEST_F(NetErrorHelperCoreTest, CorrectionClickTracking) { 1848 // Go through the standard navigation correction steps. 1849 1850 // Original page starts loading. 1851 EnableNavigationCorrections(); 1852 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1853 NetErrorHelperCore::NON_ERROR_PAGE); 1854 1855 // It fails. 1856 std::string html; 1857 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 1858 NetError(net::ERR_NAME_NOT_RESOLVED), 1859 false, &html); 1860 EXPECT_TRUE(html.empty()); 1861 EXPECT_FALSE(is_url_being_fetched()); 1862 EXPECT_FALSE(last_error_page_params()); 1863 1864 // The blank page loads. 1865 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1866 NetErrorHelperCore::ERROR_PAGE); 1867 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1868 1869 // Corrections retrieval starts when the error page finishes loading. 1870 EXPECT_FALSE(is_url_being_fetched()); 1871 EXPECT_FALSE(last_error_page_params()); 1872 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1873 EXPECT_TRUE(is_url_being_fetched()); 1874 EXPECT_FALSE(last_error_page_params()); 1875 1876 // Corrections are retrieved. 1877 NavigationCorrectionsLoadSuccess(kDefaultCorrections, 1878 arraysize(kDefaultCorrections)); 1879 EXPECT_EQ(1, error_html_update_count()); 1880 EXPECT_EQ(NetErrorString(net::ERR_NAME_NOT_RESOLVED), last_error_html()); 1881 ExpectDefaultNavigationCorrections(); 1882 EXPECT_FALSE(is_url_being_fetched()); 1883 1884 // Corrections load. 1885 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 1886 NetErrorHelperCore::ERROR_PAGE); 1887 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 1888 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 1889 1890 EXPECT_EQ(0, tracking_request_count()); 1891 1892 // Invalid clicks should be ignored. 1893 core()->TrackClick(-1); 1894 core()->TrackClick(arraysize(kDefaultCorrections)); 1895 EXPECT_EQ(0, tracking_request_count()); 1896 1897 for (size_t i = 0; i < arraysize(kDefaultCorrections); ++i) { 1898 // Skip links that do not appear in the page. 1899 if (kDefaultCorrections[i].is_porn || kDefaultCorrections[i].is_soft_porn) 1900 continue; 1901 1902 int old_tracking_request_count = tracking_request_count(); 1903 core()->TrackClick(i); 1904 EXPECT_EQ(old_tracking_request_count + 1, tracking_request_count()); 1905 EXPECT_EQ(GURL(kNavigationCorrectionUrl), last_tracking_url()); 1906 1907 // Make sure all expected strings appear in output. 1908 EXPECT_TRUE(last_tracking_request_body().find( 1909 kDefaultCorrections[i].url_correction)); 1910 EXPECT_TRUE(last_tracking_request_body().find( 1911 kDefaultCorrections[i].click_data)); 1912 EXPECT_TRUE(last_tracking_request_body().find( 1913 kDefaultCorrections[i].click_type)); 1914 EXPECT_TRUE(last_tracking_request_body().find( 1915 kNavigationCorrectionEventId)); 1916 EXPECT_TRUE(last_tracking_request_body().find( 1917 kNavigationCorrectionFingerprint)); 1918 } 1919 1920 // Make sure duplicate tracking requests are ignored. 1921 for (size_t i = 0; i < arraysize(kDefaultCorrections); ++i) { 1922 // Skip links that do not appear in the page. 1923 if (kDefaultCorrections[i].is_porn || kDefaultCorrections[i].is_soft_porn) 1924 continue; 1925 1926 int old_tracking_request_count = tracking_request_count(); 1927 core()->TrackClick(i); 1928 EXPECT_EQ(old_tracking_request_count, tracking_request_count()); 1929 } 1930 1931 EXPECT_EQ(0, update_count()); 1932 EXPECT_EQ(1, error_html_update_count()); 1933} 1934 1935TEST_F(NetErrorHelperCoreTest, AutoReloadDisabled) { 1936 DoErrorLoad(net::ERR_CONNECTION_RESET); 1937 1938 EXPECT_FALSE(timer()->IsRunning()); 1939 EXPECT_EQ(0, reload_count()); 1940} 1941 1942class NetErrorHelperCoreAutoReloadTest : public NetErrorHelperCoreTest { 1943 public: 1944 virtual void SetUp() { 1945 NetErrorHelperCoreTest::SetUp(); 1946 SetUpCore(true, false, true); 1947 } 1948}; 1949 1950TEST_F(NetErrorHelperCoreAutoReloadTest, Succeeds) { 1951 DoErrorLoad(net::ERR_CONNECTION_RESET); 1952 1953 EXPECT_TRUE(timer()->IsRunning()); 1954 EXPECT_EQ(0, reload_count()); 1955 1956 timer()->Fire(); 1957 EXPECT_FALSE(timer()->IsRunning()); 1958 EXPECT_EQ(1, reload_count()); 1959 1960 DoSuccessLoad(); 1961 1962 EXPECT_FALSE(timer()->IsRunning()); 1963} 1964 1965TEST_F(NetErrorHelperCoreAutoReloadTest, Retries) { 1966 DoErrorLoad(net::ERR_CONNECTION_RESET); 1967 1968 EXPECT_TRUE(timer()->IsRunning()); 1969 base::TimeDelta first_delay = timer()->GetCurrentDelay(); 1970 EXPECT_EQ(0, reload_count()); 1971 1972 timer()->Fire(); 1973 EXPECT_FALSE(timer()->IsRunning()); 1974 EXPECT_EQ(1, reload_count()); 1975 1976 DoErrorLoad(net::ERR_CONNECTION_RESET); 1977 1978 EXPECT_TRUE(timer()->IsRunning()); 1979 EXPECT_GT(timer()->GetCurrentDelay(), first_delay); 1980} 1981 1982TEST_F(NetErrorHelperCoreAutoReloadTest, StopsTimerOnStop) { 1983 DoErrorLoad(net::ERR_CONNECTION_RESET); 1984 EXPECT_TRUE(timer()->IsRunning()); 1985 core()->OnStop(); 1986 EXPECT_FALSE(timer()->IsRunning()); 1987} 1988 1989TEST_F(NetErrorHelperCoreAutoReloadTest, StopsLoadingOnStop) { 1990 DoErrorLoad(net::ERR_CONNECTION_RESET); 1991 EXPECT_EQ(0, core()->auto_reload_count()); 1992 timer()->Fire(); 1993 EXPECT_EQ(1, core()->auto_reload_count()); 1994 EXPECT_EQ(1, reload_count()); 1995 core()->OnStop(); 1996 EXPECT_FALSE(timer()->IsRunning()); 1997 EXPECT_EQ(0, core()->auto_reload_count()); 1998} 1999 2000TEST_F(NetErrorHelperCoreAutoReloadTest, StopsOnOtherLoadStart) { 2001 DoErrorLoad(net::ERR_CONNECTION_RESET); 2002 EXPECT_TRUE(timer()->IsRunning()); 2003 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2004 NetErrorHelperCore::NON_ERROR_PAGE); 2005 EXPECT_FALSE(timer()->IsRunning()); 2006 EXPECT_EQ(0, core()->auto_reload_count()); 2007} 2008 2009TEST_F(NetErrorHelperCoreAutoReloadTest, ResetsCountOnSuccess) { 2010 DoErrorLoad(net::ERR_CONNECTION_RESET); 2011 base::TimeDelta delay = timer()->GetCurrentDelay(); 2012 EXPECT_EQ(0, core()->auto_reload_count()); 2013 timer()->Fire(); 2014 EXPECT_EQ(1, core()->auto_reload_count()); 2015 EXPECT_EQ(1, reload_count()); 2016 DoSuccessLoad(); 2017 DoErrorLoad(net::ERR_CONNECTION_RESET); 2018 EXPECT_EQ(0, core()->auto_reload_count()); 2019 EXPECT_EQ(timer()->GetCurrentDelay(), delay); 2020 timer()->Fire(); 2021 EXPECT_EQ(1, core()->auto_reload_count()); 2022 EXPECT_EQ(2, reload_count()); 2023 DoSuccessLoad(); 2024 EXPECT_EQ(0, core()->auto_reload_count()); 2025} 2026 2027TEST_F(NetErrorHelperCoreAutoReloadTest, RestartsOnOnline) { 2028 DoErrorLoad(net::ERR_CONNECTION_RESET); 2029 base::TimeDelta delay = timer()->GetCurrentDelay(); 2030 timer()->Fire(); 2031 DoErrorLoad(net::ERR_CONNECTION_RESET); 2032 EXPECT_TRUE(timer()->IsRunning()); 2033 EXPECT_NE(delay, timer()->GetCurrentDelay()); 2034 core()->NetworkStateChanged(false); 2035 EXPECT_FALSE(timer()->IsRunning()); 2036 core()->NetworkStateChanged(true); 2037 EXPECT_TRUE(timer()->IsRunning()); 2038 EXPECT_EQ(delay, timer()->GetCurrentDelay()); 2039} 2040 2041TEST_F(NetErrorHelperCoreAutoReloadTest, DoesNotStartOnOnline) { 2042 DoErrorLoad(net::ERR_CONNECTION_RESET); 2043 timer()->Fire(); 2044 DoSuccessLoad(); 2045 EXPECT_FALSE(timer()->IsRunning()); 2046 core()->NetworkStateChanged(true); 2047 EXPECT_FALSE(timer()->IsRunning()); 2048} 2049 2050TEST_F(NetErrorHelperCoreAutoReloadTest, DoesNotStartOffline) { 2051 core()->NetworkStateChanged(false); 2052 DoErrorLoad(net::ERR_CONNECTION_RESET); 2053 EXPECT_FALSE(timer()->IsRunning()); 2054 core()->NetworkStateChanged(true); 2055 EXPECT_TRUE(timer()->IsRunning()); 2056} 2057 2058TEST_F(NetErrorHelperCoreAutoReloadTest, DoesNotRestartOnOnlineAfterStop) { 2059 DoErrorLoad(net::ERR_CONNECTION_RESET); 2060 timer()->Fire(); 2061 core()->OnStop(); 2062 core()->NetworkStateChanged(true); 2063 EXPECT_FALSE(timer()->IsRunning()); 2064} 2065 2066TEST_F(NetErrorHelperCoreAutoReloadTest, WithDnsProbes) { 2067 DoErrorLoad(net::ERR_CONNECTION_RESET); 2068 DoDnsProbe(chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN); 2069 timer()->Fire(); 2070 EXPECT_EQ(1, reload_count()); 2071} 2072 2073TEST_F(NetErrorHelperCoreAutoReloadTest, ExponentialBackoffLevelsOff) { 2074 base::TimeDelta previous = base::TimeDelta::FromMilliseconds(0); 2075 const int kMaxTries = 50; 2076 int tries = 0; 2077 for (tries = 0; tries < kMaxTries; tries++) { 2078 DoErrorLoad(net::ERR_CONNECTION_RESET); 2079 EXPECT_TRUE(timer()->IsRunning()); 2080 if (previous == timer()->GetCurrentDelay()) 2081 break; 2082 previous = timer()->GetCurrentDelay(); 2083 timer()->Fire(); 2084 } 2085 2086 EXPECT_LT(tries, kMaxTries); 2087} 2088 2089TEST_F(NetErrorHelperCoreAutoReloadTest, SlowError) { 2090 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2091 NetErrorHelperCore::NON_ERROR_PAGE); 2092 std::string html; 2093 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 2094 NetError(net::ERR_CONNECTION_RESET), false, &html); 2095 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2096 NetErrorHelperCore::ERROR_PAGE); 2097 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 2098 EXPECT_FALSE(timer()->IsRunning()); 2099 // Start a new non-error page load. 2100 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2101 NetErrorHelperCore::NON_ERROR_PAGE); 2102 EXPECT_FALSE(timer()->IsRunning()); 2103 // Finish the error page load. 2104 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 2105 EXPECT_FALSE(timer()->IsRunning()); 2106 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 2107 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 2108 EXPECT_FALSE(timer()->IsRunning()); 2109} 2110 2111TEST_F(NetErrorHelperCoreAutoReloadTest, OnlineSlowError) { 2112 core()->NetworkStateChanged(false); 2113 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2114 NetErrorHelperCore::NON_ERROR_PAGE); 2115 std::string html; 2116 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 2117 NetError(net::ERR_CONNECTION_RESET), false, &html); 2118 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2119 NetErrorHelperCore::ERROR_PAGE); 2120 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 2121 EXPECT_FALSE(timer()->IsRunning()); 2122 core()->NetworkStateChanged(true); 2123 EXPECT_FALSE(timer()->IsRunning()); 2124 core()->NetworkStateChanged(false); 2125 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 2126 EXPECT_FALSE(timer()->IsRunning()); 2127 core()->NetworkStateChanged(true); 2128 EXPECT_TRUE(timer()->IsRunning()); 2129} 2130 2131TEST_F(NetErrorHelperCoreAutoReloadTest, OnlinePendingError) { 2132 core()->NetworkStateChanged(false); 2133 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2134 NetErrorHelperCore::NON_ERROR_PAGE); 2135 std::string html; 2136 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 2137 NetError(net::ERR_CONNECTION_RESET), false, &html); 2138 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2139 NetErrorHelperCore::ERROR_PAGE); 2140 EXPECT_FALSE(timer()->IsRunning()); 2141 core()->NetworkStateChanged(true); 2142 EXPECT_FALSE(timer()->IsRunning()); 2143 core()->NetworkStateChanged(false); 2144 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 2145 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 2146 EXPECT_FALSE(timer()->IsRunning()); 2147 core()->NetworkStateChanged(true); 2148 EXPECT_TRUE(timer()->IsRunning()); 2149} 2150 2151TEST_F(NetErrorHelperCoreAutoReloadTest, OnlinePartialErrorReplacement) { 2152 core()->NetworkStateChanged(false); 2153 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2154 NetErrorHelperCore::NON_ERROR_PAGE); 2155 std::string html; 2156 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 2157 NetError(net::ERR_CONNECTION_RESET), false, &html); 2158 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2159 NetErrorHelperCore::ERROR_PAGE); 2160 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, error_url()); 2161 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 2162 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2163 NetErrorHelperCore::NON_ERROR_PAGE); 2164 core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, 2165 NetError(net::ERR_CONNECTION_RESET), false, &html); 2166 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2167 NetErrorHelperCore::ERROR_PAGE); 2168 EXPECT_FALSE(timer()->IsRunning()); 2169 core()->NetworkStateChanged(true); 2170 EXPECT_FALSE(timer()->IsRunning()); 2171} 2172 2173TEST_F(NetErrorHelperCoreAutoReloadTest, ShouldSuppressNonReloadableErrorPage) { 2174 DoErrorLoad(net::ERR_ABORTED); 2175 EXPECT_FALSE(core()->ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME, 2176 GURL(kFailedUrl))); 2177} 2178 2179TEST_F(NetErrorHelperCoreAutoReloadTest, ShouldSuppressErrorPage) { 2180 // Set up the environment to test ShouldSuppressErrorPage: auto-reload is 2181 // enabled, an error page is loaded, and the auto-reload callback is running. 2182 DoErrorLoad(net::ERR_CONNECTION_RESET); 2183 timer()->Fire(); 2184 2185 EXPECT_FALSE(core()->ShouldSuppressErrorPage(NetErrorHelperCore::SUB_FRAME, 2186 GURL(kFailedUrl))); 2187 EXPECT_FALSE(core()->ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME, 2188 GURL("http://some.other.url"))); 2189 EXPECT_TRUE(core()->ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME, 2190 GURL(kFailedUrl))); 2191} 2192 2193TEST_F(NetErrorHelperCoreAutoReloadTest, HiddenAndShown) { 2194 SetUpCore(true, true, true); 2195 DoErrorLoad(net::ERR_CONNECTION_RESET); 2196 EXPECT_TRUE(timer()->IsRunning()); 2197 core()->OnWasHidden(); 2198 EXPECT_FALSE(timer()->IsRunning()); 2199 core()->OnWasShown(); 2200 EXPECT_TRUE(timer()->IsRunning()); 2201} 2202 2203TEST_F(NetErrorHelperCoreAutoReloadTest, HiddenWhileOnline) { 2204 SetUpCore(true, true, true); 2205 core()->NetworkStateChanged(false); 2206 DoErrorLoad(net::ERR_CONNECTION_RESET); 2207 EXPECT_FALSE(timer()->IsRunning()); 2208 core()->OnWasHidden(); 2209 core()->NetworkStateChanged(true); 2210 EXPECT_FALSE(timer()->IsRunning()); 2211 core()->NetworkStateChanged(false); 2212 core()->OnWasShown(); 2213 EXPECT_FALSE(timer()->IsRunning()); 2214 core()->NetworkStateChanged(true); 2215 EXPECT_TRUE(timer()->IsRunning()); 2216 core()->NetworkStateChanged(false); 2217 core()->OnWasHidden(); 2218 EXPECT_FALSE(timer()->IsRunning()); 2219 core()->NetworkStateChanged(true); 2220 EXPECT_FALSE(timer()->IsRunning()); 2221 core()->OnWasShown(); 2222 EXPECT_TRUE(timer()->IsRunning()); 2223} 2224 2225TEST_F(NetErrorHelperCoreAutoReloadTest, ShownWhileNotReloading) { 2226 SetUpCore(true, true, false); 2227 DoErrorLoad(net::ERR_CONNECTION_RESET); 2228 EXPECT_FALSE(timer()->IsRunning()); 2229 core()->OnWasShown(); 2230 EXPECT_TRUE(timer()->IsRunning()); 2231} 2232 2233class NetErrorHelperCoreHistogramTest 2234 : public NetErrorHelperCoreAutoReloadTest { 2235 public: 2236 virtual void SetUp() OVERRIDE { 2237 NetErrorHelperCoreAutoReloadTest::SetUp(); 2238 } 2239 2240 static const char kCountAtStop[]; 2241 static const char kErrorAtStop[]; 2242 static const char kCountAtSuccess[]; 2243 static const char kErrorAtSuccess[]; 2244 static const char kErrorAtFirstSuccess[]; 2245 2246 protected: 2247 base::HistogramTester histogram_tester_; 2248}; 2249 2250const char NetErrorHelperCoreHistogramTest::kCountAtStop[] = 2251 "Net.AutoReload.CountAtStop"; 2252const char NetErrorHelperCoreHistogramTest::kErrorAtStop[] = 2253 "Net.AutoReload.ErrorAtStop"; 2254const char NetErrorHelperCoreHistogramTest::kCountAtSuccess[] = 2255 "Net.AutoReload.CountAtSuccess"; 2256const char NetErrorHelperCoreHistogramTest::kErrorAtSuccess[] = 2257 "Net.AutoReload.ErrorAtSuccess"; 2258const char NetErrorHelperCoreHistogramTest::kErrorAtFirstSuccess[] = 2259 "Net.AutoReload.ErrorAtFirstSuccess"; 2260 2261// Test that the success histograms are updated when auto-reload succeeds at the 2262// first attempt, and that the failure histograms are not updated. 2263TEST_F(NetErrorHelperCoreHistogramTest, SuccessAtFirstAttempt) { 2264 DoErrorLoad(net::ERR_CONNECTION_RESET); 2265 timer()->Fire(); 2266 DoSuccessLoad(); 2267 2268 // All of CountAtSuccess, ErrorAtSuccess, and ErrorAtFirstSuccess should 2269 // reflect this successful load. The failure histograms should be unchanged. 2270 histogram_tester_.ExpectTotalCount(kCountAtSuccess, 1); 2271 histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 1); 2272 histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 1); 2273 histogram_tester_.ExpectTotalCount(kCountAtStop, 0); 2274 histogram_tester_.ExpectTotalCount(kErrorAtStop, 0); 2275} 2276 2277// Test that the success histograms are updated when auto-reload succeeds but 2278// not on the first attempt, and that the first-success histogram is not 2279// updated. 2280TEST_F(NetErrorHelperCoreHistogramTest, SuccessAtSecondAttempt) { 2281 DoErrorLoad(net::ERR_CONNECTION_RESET); 2282 timer()->Fire(); 2283 EXPECT_TRUE(core()->ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME, 2284 default_url())); 2285// DoErrorLoad(net::ERR_CONNECTION_RESET); 2286 timer()->Fire(); 2287 DoSuccessLoad(); 2288 2289 // CountAtSuccess and ErrorAtSuccess should reflect this successful load, but 2290 // not ErrorAtFirstSuccess since it wasn't a first success. 2291 histogram_tester_.ExpectTotalCount(kCountAtSuccess, 1); 2292 histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 1); 2293 histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 0); 2294 histogram_tester_.ExpectTotalCount(kCountAtStop, 0); 2295 histogram_tester_.ExpectTotalCount(kErrorAtStop, 0); 2296} 2297 2298// Test that a user stop (caused by the user pressing the 'Stop' button) 2299// registers as an auto-reload failure if an auto-reload attempt is in flight. 2300// Note that "user stop" is also caused by a cross-process navigation, for which 2301// the browser process will send an OnStop to the old process. 2302TEST_F(NetErrorHelperCoreHistogramTest, UserStop) { 2303 DoErrorLoad(net::ERR_CONNECTION_RESET); 2304 timer()->Fire(); 2305 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2306 NetErrorHelperCore::NON_ERROR_PAGE); 2307 core()->OnStop(); 2308 2309 // CountAtStop and ErrorAtStop should reflect the failure. 2310 histogram_tester_.ExpectTotalCount(kCountAtSuccess, 0); 2311 histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 0); 2312 histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 0); 2313 histogram_tester_.ExpectTotalCount(kCountAtStop, 1); 2314 histogram_tester_.ExpectTotalCount(kErrorAtStop, 1); 2315} 2316 2317// Test that a user stop (caused by the user pressing the 'Stop' button) 2318// registers as an auto-reload failure even if an auto-reload attempt has not 2319// been launched yet (i.e., if the timer is running, but no reload is in 2320// flight), because this means auto-reload didn't successfully replace the error 2321// page. 2322TEST_F(NetErrorHelperCoreHistogramTest, OtherPageLoaded) { 2323 DoErrorLoad(net::ERR_CONNECTION_RESET); 2324 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2325 NetErrorHelperCore::NON_ERROR_PAGE); 2326 core()->OnStop(); 2327 2328 histogram_tester_.ExpectTotalCount(kCountAtSuccess, 0); 2329 histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 0); 2330 histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 0); 2331 histogram_tester_.ExpectTotalCount(kCountAtStop, 1); 2332 histogram_tester_.ExpectTotalCount(kErrorAtStop, 1); 2333} 2334 2335// Test that a commit of a different URL (caused by the user navigating to a 2336// different page) with an auto-reload attempt in flight registers as an 2337// auto-reload failure. 2338TEST_F(NetErrorHelperCoreHistogramTest, OtherPageLoadedAfterTimerFires) { 2339 const GURL kTestUrl("https://anotherurl"); 2340 DoErrorLoad(net::ERR_CONNECTION_RESET); 2341 timer()->Fire(); 2342 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2343 NetErrorHelperCore::NON_ERROR_PAGE); 2344 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, 2345 kTestUrl); 2346 core()->OnFinishLoad(NetErrorHelperCore::MAIN_FRAME); 2347 2348 histogram_tester_.ExpectTotalCount(kCountAtSuccess, 0); 2349 histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 0); 2350 histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 0); 2351 histogram_tester_.ExpectTotalCount(kCountAtStop, 1); 2352 histogram_tester_.ExpectTotalCount(kErrorAtStop, 1); 2353} 2354 2355// Test that a commit of the same URL with an auto-reload attempt in flight 2356// registers as an auto-reload success. 2357TEST_F(NetErrorHelperCoreHistogramTest, SamePageLoadedAfterTimerFires) { 2358 DoErrorLoad(net::ERR_CONNECTION_RESET); 2359 timer()->Fire(); 2360 DoSuccessLoad(); 2361 2362 histogram_tester_.ExpectTotalCount(kCountAtSuccess, 1); 2363 histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 1); 2364 histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 1); 2365 histogram_tester_.ExpectTotalCount(kCountAtStop, 0); 2366 histogram_tester_.ExpectTotalCount(kErrorAtStop, 0); 2367} 2368 2369TEST_F(NetErrorHelperCoreHistogramTest, SamePageLoadedAfterLoadStarts) { 2370 DoErrorLoad(net::ERR_CONNECTION_RESET); 2371 timer()->Fire(); 2372 // Autoreload attempt starts 2373 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2374 NetErrorHelperCore::NON_ERROR_PAGE); 2375 // User does a manual reload 2376 DoSuccessLoad(); 2377 2378 histogram_tester_.ExpectTotalCount(kCountAtSuccess, 1); 2379 histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 1); 2380 histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 1); 2381 histogram_tester_.ExpectTotalCount(kCountAtStop, 0); 2382 histogram_tester_.ExpectTotalCount(kErrorAtStop, 0); 2383} 2384 2385// In this test case, the user presses the reload button manually after an 2386// auto-reload fails and the error page is suppressed. 2387TEST_F(NetErrorHelperCoreHistogramTest, ErrorPageLoadedAfterTimerFires) { 2388 DoErrorLoad(net::ERR_CONNECTION_RESET); 2389 timer()->Fire(); 2390 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2391 NetErrorHelperCore::NON_ERROR_PAGE); 2392 EXPECT_TRUE(core()->ShouldSuppressErrorPage(NetErrorHelperCore::MAIN_FRAME, 2393 default_url())); 2394 DoErrorLoad(net::ERR_CONNECTION_RESET); 2395 2396 histogram_tester_.ExpectTotalCount(kCountAtSuccess, 0); 2397 histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 0); 2398 histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 0); 2399 histogram_tester_.ExpectTotalCount(kCountAtStop, 0); 2400 histogram_tester_.ExpectTotalCount(kErrorAtStop, 0); 2401} 2402 2403TEST_F(NetErrorHelperCoreHistogramTest, SuccessPageLoadedBeforeTimerFires) { 2404 DoErrorLoad(net::ERR_CONNECTION_RESET); 2405 core()->OnStartLoad(NetErrorHelperCore::MAIN_FRAME, 2406 NetErrorHelperCore::NON_ERROR_PAGE); 2407 core()->OnCommitLoad(NetErrorHelperCore::MAIN_FRAME, 2408 GURL(kFailedHttpsUrl)); 2409 2410 histogram_tester_.ExpectTotalCount(kCountAtSuccess, 0); 2411 histogram_tester_.ExpectTotalCount(kErrorAtSuccess, 0); 2412 histogram_tester_.ExpectTotalCount(kErrorAtFirstSuccess, 0); 2413 histogram_tester_.ExpectTotalCount(kCountAtStop, 1); 2414 histogram_tester_.ExpectTotalCount(kErrorAtStop, 1); 2415} 2416 2417 2418TEST_F(NetErrorHelperCoreTest, ExplicitReloadSucceeds) { 2419 DoErrorLoad(net::ERR_CONNECTION_RESET); 2420 EXPECT_EQ(0, reload_count()); 2421 core()->ExecuteButtonPress(NetErrorHelperCore::RELOAD_BUTTON); 2422 EXPECT_EQ(1, reload_count()); 2423} 2424 2425TEST_F(NetErrorHelperCoreTest, ExplicitLoadStaleSucceeds) { 2426 DoErrorLoad(net::ERR_CONNECTION_RESET); 2427 EXPECT_EQ(0, load_stale_count()); 2428 core()->ExecuteButtonPress(NetErrorHelperCore::LOAD_STALE_BUTTON); 2429 EXPECT_EQ(1, load_stale_count()); 2430 EXPECT_EQ(GURL(kFailedUrl), load_stale_url()); 2431} 2432 2433} // namespace 2434