OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/command_line.h" | 5 #include "base/command_line.h" |
| 6 #include "base/format_macros.h" |
6 #include "base/memory/scoped_vector.h" | 7 #include "base/memory/scoped_vector.h" |
7 #include "base/message_loop.h" | 8 #include "base/message_loop.h" |
8 #include "base/stringprintf.h" | 9 #include "base/stringprintf.h" |
9 #include "base/time.h" | 10 #include "base/time.h" |
10 #include "chrome/browser/prerender/prerender_contents.h" | 11 #include "chrome/browser/prerender/prerender_contents.h" |
11 #include "chrome/browser/prerender/prerender_handle.h" | 12 #include "chrome/browser/prerender/prerender_handle.h" |
12 #include "chrome/browser/prerender/prerender_link_manager.h" | 13 #include "chrome/browser/prerender/prerender_link_manager.h" |
13 #include "chrome/browser/prerender/prerender_manager.h" | 14 #include "chrome/browser/prerender/prerender_manager.h" |
14 #include "chrome/browser/prerender/prerender_origin.h" | 15 #include "chrome/browser/prerender/prerender_origin.h" |
15 #include "chrome/common/chrome_switches.h" | 16 #include "chrome/common/chrome_switches.h" |
(...skipping 280 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
296 } | 297 } |
297 | 298 |
298 UnitTestPrerenderManager* prerender_manager() { | 299 UnitTestPrerenderManager* prerender_manager() { |
299 return prerender_manager_.get(); | 300 return prerender_manager_.get(); |
300 } | 301 } |
301 | 302 |
302 PrerenderLinkManager* prerender_link_manager() { | 303 PrerenderLinkManager* prerender_link_manager() { |
303 return prerender_link_manager_.get(); | 304 return prerender_link_manager_.get(); |
304 } | 305 } |
305 | 306 |
| 307 void SetConcurrency(size_t concurrency) { |
| 308 prerender_manager()->mutable_config().max_concurrency_per_launcher = |
| 309 concurrency; |
| 310 prerender_manager()->mutable_config().max_concurrency = |
| 311 std::max(prerender_manager()->mutable_config().max_concurrency, |
| 312 concurrency); |
| 313 } |
| 314 |
306 bool IsEmptyPrerenderLinkManager() { | 315 bool IsEmptyPrerenderLinkManager() { |
307 return prerender_link_manager_->IsEmpty(); | 316 return prerender_link_manager_->IsEmpty(); |
308 } | 317 } |
309 | 318 |
310 int last_prerender_id() const { | 319 int last_prerender_id() const { |
311 return last_prerender_id_; | 320 return last_prerender_id_; |
312 } | 321 } |
313 | 322 |
314 int GetNextPrerenderID() { | 323 int GetNextPrerenderID() { |
315 return ++last_prerender_id_; | 324 return ++last_prerender_id_; |
316 } | 325 } |
317 | 326 |
| 327 bool PrerenderHasHandle(int child_id, int prerender_id) { |
| 328 PrerenderLinkManager::Prerender* prerender = |
| 329 prerender_link_manager()-> FindByLauncherChildIdAndPrerenderId( |
| 330 child_id, prerender_id); |
| 331 return prerender && prerender->handle; |
| 332 } |
| 333 |
318 // Shorthand to add a simple preload with a reasonable source. | 334 // Shorthand to add a simple preload with a reasonable source. |
319 bool AddSimplePrerender(const GURL& url) { | 335 bool AddSimplePrerender(const GURL& url) { |
320 return prerender_link_manager()->OnAddPrerender( | 336 prerender_link_manager()->OnAddPrerender(kDefaultChildId, |
321 kDefaultChildId, GetNextPrerenderID(), | 337 GetNextPrerenderID(), |
322 url, content::Referrer(), | 338 url, content::Referrer(), |
323 kSize, kDefaultRenderViewRouteId); | 339 kSize, kDefaultRenderViewRouteId); |
| 340 return PrerenderHasHandle(kDefaultChildId, last_prerender_id()); |
324 } | 341 } |
325 | 342 |
326 private: | 343 private: |
327 PrerenderTracker* prerender_tracker() { | 344 PrerenderTracker* prerender_tracker() { |
328 return g_browser_process->prerender_tracker(); | 345 return g_browser_process->prerender_tracker(); |
329 } | 346 } |
330 | 347 |
331 // Needed to pass PrerenderManager's DCHECKs. | 348 // Needed to pass PrerenderManager's DCHECKs. |
332 TestingProfile profile_; | 349 TestingProfile profile_; |
333 MessageLoop message_loop_; | 350 MessageLoop message_loop_; |
334 content::TestBrowserThread ui_thread_; | 351 content::TestBrowserThread ui_thread_; |
335 scoped_ptr<UnitTestPrerenderManager> prerender_manager_; | 352 scoped_ptr<UnitTestPrerenderManager> prerender_manager_; |
336 scoped_ptr<PrerenderLinkManager> prerender_link_manager_; | 353 scoped_ptr<PrerenderLinkManager> prerender_link_manager_; |
337 int last_prerender_id_; | 354 int last_prerender_id_; |
338 }; | 355 }; |
339 | 356 |
340 TEST_F(PrerenderTest, FoundTest) { | 357 TEST_F(PrerenderTest, FoundTest) { |
341 GURL url("http://www.google.com/"); | 358 GURL url("http://www.google.com/"); |
342 DummyPrerenderContents* prerender_contents = | 359 DummyPrerenderContents* prerender_contents = |
343 prerender_manager()->CreateNextPrerenderContents( | 360 prerender_manager()->CreateNextPrerenderContents( |
344 url, | 361 url, |
345 FINAL_STATUS_USED); | 362 FINAL_STATUS_USED); |
346 EXPECT_TRUE(AddSimplePrerender(url)); | 363 EXPECT_TRUE(AddSimplePrerender(url)); |
347 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 364 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
348 ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url)); | 365 ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url)); |
349 } | 366 } |
350 | 367 |
| 368 // Make sure that if queue a request, and a second prerender request for the |
| 369 // same URL comes in, that the second request attaches to the first prerender, |
| 370 // and we don't use the second prerender contents. |
351 TEST_F(PrerenderTest, DuplicateTest) { | 371 TEST_F(PrerenderTest, DuplicateTest) { |
| 372 SetConcurrency(2); |
352 GURL url("http://www.google.com/"); | 373 GURL url("http://www.google.com/"); |
353 DummyPrerenderContents* prerender_contents = | 374 DummyPrerenderContents* prerender_contents = |
354 prerender_manager()->CreateNextPrerenderContents( | 375 prerender_manager()->CreateNextPrerenderContents( |
355 url, | |
356 FINAL_STATUS_USED); | |
357 EXPECT_TRUE(AddSimplePrerender(url)); | |
358 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | |
359 | |
360 scoped_ptr<PrerenderHandle> duplicate_prerender_handle( | |
361 prerender_manager()->AddPrerenderFromLinkRelPrerender( | |
362 kDefaultChildId, kDefaultRenderViewRouteId, url, | |
363 Referrer(url, WebKit::WebReferrerPolicyDefault), kSize)); | |
364 | |
365 EXPECT_TRUE(duplicate_prerender_handle->IsPrerendering()); | |
366 | |
367 ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url)); | |
368 | |
369 EXPECT_FALSE(duplicate_prerender_handle->IsPrerendering()); | |
370 } | |
371 | |
372 // Make sure that if queue a request, and a second prerender request for the | |
373 // same URL comes in, that we drop the second request and keep the first one. | |
374 TEST_F(PrerenderTest, DropSecondRequestTest) { | |
375 GURL url("http://www.google.com/"); | |
376 DummyPrerenderContents* prerender_contents = | |
377 prerender_manager()->CreateNextPrerenderContents( | |
378 url, | 376 url, |
379 FINAL_STATUS_USED); | 377 FINAL_STATUS_USED); |
380 DummyPrerenderContents* null = NULL; | 378 DummyPrerenderContents* null = NULL; |
381 EXPECT_TRUE(AddSimplePrerender(url)); | 379 EXPECT_TRUE(AddSimplePrerender(url)); |
382 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 380 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
383 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 381 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
384 | 382 |
385 DummyPrerenderContents* prerender_contents1 = | 383 DummyPrerenderContents* prerender_contents1 = |
386 prerender_manager()->CreateNextPrerenderContents( | 384 prerender_manager()->CreateNextPrerenderContents( |
387 url, | 385 url, |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
477 last_prerender_id()); | 475 last_prerender_id()); |
478 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 476 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
479 | 477 |
480 DummyPrerenderContents* null = NULL; | 478 DummyPrerenderContents* null = NULL; |
481 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 479 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
482 | 480 |
483 prerender_manager()->AdvanceTimeTicks(second_advance); | 481 prerender_manager()->AdvanceTimeTicks(second_advance); |
484 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | 482 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
485 } | 483 } |
486 | 484 |
487 // LRU Test. Make sure that if we prerender more requests than we support, that | 485 // Make sure that if we prerender more requests than we support, that we launch |
488 // the oldest one will be dropped. | 486 // them in the order given up until we reach MaxConcurrency, at which point we |
489 TEST_F(PrerenderTest, DropOldestRequestTest) { | 487 // queue them and launch them in the order given. As well, insure that limits |
490 std::vector<int> concurrencies_to_test; | 488 // are enforced for the system as a whole and on a per launcher basis. |
491 concurrencies_to_test.push_back( | 489 TEST_F(PrerenderTest, MaxConcurrencyTest) { |
492 prerender_manager()->config().max_concurrency); | 490 struct TestConcurrency { |
493 concurrencies_to_test.push_back(1); | 491 size_t max_concurrency; |
494 concurrencies_to_test.push_back(2); | 492 size_t max_concurrency_per_launcher; |
| 493 }; |
| 494 |
| 495 TestConcurrency concurrencies_to_test[] = { |
| 496 { prerender_manager()->config().max_concurrency, |
| 497 prerender_manager()->config(). max_concurrency_per_launcher}, |
| 498 |
| 499 // With the system limit higher than the per launcher limit, the per |
| 500 // launcher limit should be in effect. |
| 501 { 2, 1 }, |
| 502 |
| 503 // With the per launcher limit higher than system limit, the system limit |
| 504 // should be in effect. |
| 505 { 2, 4 }, |
| 506 }; |
495 | 507 |
496 DummyPrerenderContents* null = NULL; | 508 DummyPrerenderContents* null = NULL; |
497 GURL url_to_evict("http://www.google.com/evictme"); | 509 GURL url_to_delay("http://www.google.com/delayme"); |
498 | 510 |
499 for (std::vector<int>::const_iterator i = concurrencies_to_test.begin(); | 511 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(concurrencies_to_test); ++i) { |
500 i != concurrencies_to_test.end(); | 512 prerender_manager()->mutable_config().max_concurrency = |
501 ++i) { | 513 concurrencies_to_test[i].max_concurrency; |
502 const int max_concurrency = *i; | 514 prerender_manager()->mutable_config().max_concurrency_per_launcher = |
503 prerender_manager()->mutable_config().max_concurrency = max_concurrency; | 515 concurrencies_to_test[i].max_concurrency_per_launcher; |
504 | 516 |
505 DummyPrerenderContents* prerender_contents_to_evict = | 517 const size_t effective_max_concurrency = |
506 prerender_manager()->CreateNextPrerenderContents( | 518 std::min(concurrencies_to_test[i].max_concurrency, |
507 url_to_evict, FINAL_STATUS_EVICTED); | 519 concurrencies_to_test[i].max_concurrency_per_launcher); |
508 EXPECT_TRUE(AddSimplePrerender(url_to_evict)); | |
509 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
510 EXPECT_TRUE(prerender_contents_to_evict->prerendering_has_started()); | |
511 | 520 |
512 std::vector<GURL> urls; | 521 std::vector<GURL> urls; |
513 std::vector<PrerenderContents*> prerender_contentses; | 522 std::vector<PrerenderContents*> prerender_contentses; |
514 | 523 |
515 for (int j = 0; j < max_concurrency; ++j) { | 524 for (size_t j = 0; j < effective_max_concurrency; ++j) { |
516 urls.push_back(GURL(base::StringPrintf("http://google.com/use#%d", j))); | 525 urls.push_back( |
| 526 GURL(base::StringPrintf("http://google.com/use#%" PRIuS, j))); |
517 prerender_contentses.push_back( | 527 prerender_contentses.push_back( |
518 prerender_manager()->CreateNextPrerenderContents(urls.back(), | 528 prerender_manager()->CreateNextPrerenderContents(urls.back(), |
519 FINAL_STATUS_USED)); | 529 FINAL_STATUS_USED)); |
520 EXPECT_TRUE(AddSimplePrerender(urls.back())); | 530 EXPECT_TRUE(AddSimplePrerender(urls.back())); |
521 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 531 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
522 EXPECT_TRUE(prerender_contentses.back()->prerendering_has_started()); | 532 EXPECT_TRUE(prerender_contentses.back()->prerendering_has_started()); |
523 } | 533 } |
524 | 534 |
525 ASSERT_EQ(null, prerender_manager()->FindEntry(url_to_evict)); | 535 DummyPrerenderContents* prerender_contents_to_delay = |
526 for (int j = 0; j < max_concurrency; ++j) { | 536 prerender_manager()->CreateNextPrerenderContents(url_to_delay, |
527 ASSERT_EQ(prerender_contentses[j], | 537 FINAL_STATUS_USED); |
| 538 EXPECT_FALSE(AddSimplePrerender(url_to_delay)); |
| 539 EXPECT_FALSE(prerender_contents_to_delay->prerendering_has_started()); |
| 540 EXPECT_NE(null, prerender_manager()->next_prerender_contents()); |
| 541 EXPECT_EQ(null, prerender_manager()->FindEntry(url_to_delay)); |
| 542 for (size_t j = 0; j < effective_max_concurrency; ++j) { |
| 543 EXPECT_EQ(prerender_contentses[j], |
528 prerender_manager()->FindAndUseEntry(urls[j])); | 544 prerender_manager()->FindAndUseEntry(urls[j])); |
529 } | 545 } |
| 546 |
| 547 EXPECT_TRUE(prerender_contents_to_delay->prerendering_has_started()); |
| 548 EXPECT_EQ(prerender_contents_to_delay, |
| 549 prerender_manager()->FindAndUseEntry(url_to_delay)); |
| 550 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
530 } | 551 } |
531 } | 552 } |
532 | 553 |
533 TEST_F(PrerenderTest, AliasURLTest) { | 554 TEST_F(PrerenderTest, AliasURLTest) { |
| 555 SetConcurrency(7); |
| 556 |
534 GURL url("http://www.google.com/"); | 557 GURL url("http://www.google.com/"); |
535 GURL alias_url1("http://www.google.com/index.html"); | 558 GURL alias_url1("http://www.google.com/index.html"); |
536 GURL alias_url2("http://google.com/"); | 559 GURL alias_url2("http://google.com/"); |
537 GURL not_an_alias_url("http://google.com/index.html"); | 560 GURL not_an_alias_url("http://google.com/index.html"); |
538 std::vector<GURL> alias_urls; | 561 std::vector<GURL> alias_urls; |
539 alias_urls.push_back(alias_url1); | 562 alias_urls.push_back(alias_url1); |
540 alias_urls.push_back(alias_url2); | 563 alias_urls.push_back(alias_url2); |
541 | 564 |
542 // Test that all of the aliases work, but not_an_alias_url does not. | 565 // Test that all of the aliases work, but not_an_alias_url does not. |
543 DummyPrerenderContents* prerender_contents = | 566 DummyPrerenderContents* prerender_contents = |
(...skipping 18 matching lines...) Expand all Loading... |
562 url, alias_urls, FINAL_STATUS_USED); | 585 url, alias_urls, FINAL_STATUS_USED); |
563 EXPECT_TRUE(AddSimplePrerender(url)); | 586 EXPECT_TRUE(AddSimplePrerender(url)); |
564 EXPECT_TRUE(AddSimplePrerender(url)); | 587 EXPECT_TRUE(AddSimplePrerender(url)); |
565 EXPECT_TRUE(AddSimplePrerender(alias_url1)); | 588 EXPECT_TRUE(AddSimplePrerender(alias_url1)); |
566 EXPECT_TRUE(AddSimplePrerender(alias_url2)); | 589 EXPECT_TRUE(AddSimplePrerender(alias_url2)); |
567 ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url)); | 590 ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url)); |
568 } | 591 } |
569 | 592 |
570 // Ensure that we ignore prerender requests within the rate limit. | 593 // Ensure that we ignore prerender requests within the rate limit. |
571 TEST_F(PrerenderTest, RateLimitInWindowTest) { | 594 TEST_F(PrerenderTest, RateLimitInWindowTest) { |
| 595 prerender_manager()->set_rate_limit_enabled(true); |
| 596 SetConcurrency(2); |
572 GURL url("http://www.google.com/"); | 597 GURL url("http://www.google.com/"); |
573 DummyPrerenderContents* prerender_contents = | 598 DummyPrerenderContents* prerender_contents = |
574 prerender_manager()->CreateNextPrerenderContents( | 599 prerender_manager()->CreateNextPrerenderContents( |
575 url, | 600 url, |
576 FINAL_STATUS_MANAGER_SHUTDOWN); | 601 FINAL_STATUS_MANAGER_SHUTDOWN); |
577 DummyPrerenderContents* null = NULL; | 602 DummyPrerenderContents* null = NULL; |
578 EXPECT_TRUE(AddSimplePrerender(url)); | 603 EXPECT_TRUE(AddSimplePrerender(url)); |
579 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 604 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
580 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 605 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
581 | 606 |
582 prerender_manager()->set_rate_limit_enabled(true); | |
583 prerender_manager()->AdvanceTimeTicks(TimeDelta::FromMilliseconds(1)); | 607 prerender_manager()->AdvanceTimeTicks(TimeDelta::FromMilliseconds(1)); |
584 | 608 |
585 GURL url1("http://news.google.com/"); | 609 GURL url1("http://news.google.com/"); |
586 prerender_manager()->CreateNextPrerenderContents( | 610 prerender_manager()->CreateNextPrerenderContents( |
587 url, | 611 url1, |
588 FINAL_STATUS_MANAGER_SHUTDOWN); | 612 FINAL_STATUS_MANAGER_SHUTDOWN); |
589 EXPECT_FALSE(AddSimplePrerender(url1)); | 613 EXPECT_FALSE(AddSimplePrerender(url1)); |
590 prerender_manager()->set_rate_limit_enabled(false); | 614 prerender_manager()->set_rate_limit_enabled(false); |
591 } | 615 } |
592 | 616 |
593 // Ensure that we don't ignore prerender requests outside the rate limit. | 617 // Ensure that we don't ignore prerender requests outside the rate limit. |
594 TEST_F(PrerenderTest, RateLimitOutsideWindowTest) { | 618 TEST_F(PrerenderTest, RateLimitOutsideWindowTest) { |
595 // Setting concurrency to one lets us force eviction by adding only one more | 619 SetConcurrency(2); |
596 // prerender. | |
597 prerender_manager()->mutable_config().max_concurrency = 1; | |
598 | 620 |
599 GURL url("http://www.google.com/"); | 621 GURL url("http://www.google.com/"); |
600 DummyPrerenderContents* prerender_contents = | 622 DummyPrerenderContents* prerender_contents = |
601 prerender_manager()->CreateNextPrerenderContents( | 623 prerender_manager()->CreateNextPrerenderContents( |
602 url, | 624 url, |
603 FINAL_STATUS_EVICTED); | 625 FINAL_STATUS_MANAGER_SHUTDOWN); |
604 DummyPrerenderContents* null = NULL; | 626 DummyPrerenderContents* null = NULL; |
605 EXPECT_TRUE(AddSimplePrerender(url)); | 627 EXPECT_TRUE(AddSimplePrerender(url)); |
606 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 628 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
607 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 629 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
608 | 630 |
609 prerender_manager()->set_rate_limit_enabled(true); | 631 prerender_manager()->set_rate_limit_enabled(true); |
610 prerender_manager()->AdvanceTimeTicks( | 632 prerender_manager()->AdvanceTimeTicks( |
611 TimeDelta::FromMilliseconds( | 633 TimeDelta::FromMilliseconds( |
612 UnitTestPrerenderManager::kMinTimeBetweenPrerendersMs + 500)); | 634 UnitTestPrerenderManager::kMinTimeBetweenPrerendersMs + 500)); |
613 | 635 |
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
736 } | 758 } |
737 | 759 |
738 // Tests that prerendering is cancelled when the source render view does not | 760 // Tests that prerendering is cancelled when the source render view does not |
739 // exist. On failure, the DCHECK in CreatePrerenderContents() above should be | 761 // exist. On failure, the DCHECK in CreatePrerenderContents() above should be |
740 // triggered. | 762 // triggered. |
741 TEST_F(PrerenderTest, SourceRenderViewClosed) { | 763 TEST_F(PrerenderTest, SourceRenderViewClosed) { |
742 GURL url("http://www.google.com/"); | 764 GURL url("http://www.google.com/"); |
743 prerender_manager()->CreateNextPrerenderContents( | 765 prerender_manager()->CreateNextPrerenderContents( |
744 url, | 766 url, |
745 FINAL_STATUS_MANAGER_SHUTDOWN); | 767 FINAL_STATUS_MANAGER_SHUTDOWN); |
746 EXPECT_FALSE(prerender_link_manager()->OnAddPrerender( | 768 prerender_link_manager()->OnAddPrerender(100, GetNextPrerenderID(), url, |
747 100, GetNextPrerenderID(), url, | 769 Referrer(), kSize, 200); |
748 Referrer(), kSize, 200)); | 770 EXPECT_FALSE(PrerenderHasHandle(100, last_prerender_id())); |
749 } | 771 } |
750 | 772 |
751 // Tests that prerendering is cancelled when we launch a second prerender of | 773 // Tests that prerendering is cancelled when we launch a second prerender of |
752 // the same target within a short time interval. | 774 // the same target within a short time interval. |
753 TEST_F(PrerenderTest, RecentlyVisited) { | 775 TEST_F(PrerenderTest, RecentlyVisited) { |
754 GURL url("http://www.google.com/"); | 776 GURL url("http://www.google.com/"); |
755 | 777 |
756 prerender_manager()->RecordNavigation(url); | 778 prerender_manager()->RecordNavigation(url); |
757 | 779 |
758 DummyPrerenderContents* prerender_contents = | 780 DummyPrerenderContents* prerender_contents = |
(...skipping 254 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1013 TEST_F(PrerenderTest, LinkManagerCancelTwice) { | 1035 TEST_F(PrerenderTest, LinkManagerCancelTwice) { |
1014 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1036 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1015 GURL url("http://www.myexample.com"); | 1037 GURL url("http://www.myexample.com"); |
1016 DummyPrerenderContents* prerender_contents = | 1038 DummyPrerenderContents* prerender_contents = |
1017 prerender_manager()->CreateNextPrerenderContents( | 1039 prerender_manager()->CreateNextPrerenderContents( |
1018 url, FINAL_STATUS_CANCELLED); | 1040 url, FINAL_STATUS_CANCELLED); |
1019 | 1041 |
1020 EXPECT_TRUE(AddSimplePrerender(url)); | 1042 EXPECT_TRUE(AddSimplePrerender(url)); |
1021 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 1043 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
1022 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | 1044 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
1023 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 1045 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
1024 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, | 1046 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
1025 last_prerender_id()); | 1047 last_prerender_id()); |
1026 | 1048 |
1027 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1049 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1028 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | 1050 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
1029 DummyPrerenderContents* null = NULL; | 1051 DummyPrerenderContents* null = NULL; |
1030 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); | 1052 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); |
1031 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, | 1053 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
1032 last_prerender_id()); | 1054 last_prerender_id()); |
1033 } | 1055 } |
1034 | 1056 |
1035 TEST_F(PrerenderTest, LinkManagerAddTwiceCancelTwice) { | 1057 TEST_F(PrerenderTest, LinkManagerAddTwiceCancelTwice) { |
| 1058 SetConcurrency(2); |
1036 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1059 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1037 GURL url("http://www.myexample.com"); | 1060 GURL url("http://www.myexample.com"); |
1038 DummyPrerenderContents* prerender_contents = | 1061 DummyPrerenderContents* prerender_contents = |
1039 prerender_manager()->CreateNextPrerenderContents( | 1062 prerender_manager()->CreateNextPrerenderContents( |
1040 url, FINAL_STATUS_CANCELLED); | 1063 url, FINAL_STATUS_CANCELLED); |
1041 | 1064 |
1042 EXPECT_TRUE(AddSimplePrerender(url)); | 1065 EXPECT_TRUE(AddSimplePrerender(url)); |
1043 | 1066 |
1044 const int first_prerender_id = last_prerender_id(); | 1067 const int first_prerender_id = last_prerender_id(); |
1045 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 1068 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
1046 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | 1069 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
1047 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 1070 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
1048 EXPECT_TRUE(AddSimplePrerender(url)); | 1071 EXPECT_TRUE(AddSimplePrerender(url)); |
1049 | 1072 |
1050 const int second_prerender_id = last_prerender_id(); | 1073 const int second_prerender_id = last_prerender_id(); |
1051 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 1074 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
1052 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | 1075 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
1053 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 1076 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
1054 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, | 1077 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
1055 first_prerender_id); | 1078 first_prerender_id); |
1056 | 1079 |
1057 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | 1080 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
1058 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 1081 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
1059 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, | 1082 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
1060 second_prerender_id); | 1083 second_prerender_id); |
1061 | 1084 |
1062 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1085 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1063 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | 1086 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
1064 DummyPrerenderContents* null = NULL; | 1087 DummyPrerenderContents* null = NULL; |
1065 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); | 1088 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); |
1066 } | 1089 } |
1067 | 1090 |
1068 TEST_F(PrerenderTest, LinkManagerAddTwiceCancelTwiceThenAbandonTwice) { | 1091 TEST_F(PrerenderTest, LinkManagerAddTwiceCancelTwiceThenAbandonTwice) { |
| 1092 SetConcurrency(2); |
1069 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1093 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1070 GURL url("http://www.myexample.com"); | 1094 GURL url("http://www.myexample.com"); |
1071 DummyPrerenderContents* prerender_contents = | 1095 DummyPrerenderContents* prerender_contents = |
1072 prerender_manager()->CreateNextPrerenderContents( | 1096 prerender_manager()->CreateNextPrerenderContents( |
1073 url, FINAL_STATUS_CANCELLED); | 1097 url, FINAL_STATUS_CANCELLED); |
1074 | 1098 |
1075 EXPECT_TRUE(AddSimplePrerender(url)); | 1099 EXPECT_TRUE(AddSimplePrerender(url)); |
1076 | 1100 |
1077 const int first_prerender_id = last_prerender_id(); | 1101 const int first_prerender_id = last_prerender_id(); |
1078 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 1102 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
(...skipping 25 matching lines...) Expand all Loading... |
1104 | 1128 |
1105 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1129 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1106 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | 1130 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
1107 DummyPrerenderContents* null = NULL; | 1131 DummyPrerenderContents* null = NULL; |
1108 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); | 1132 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); |
1109 } | 1133 } |
1110 | 1134 |
1111 // TODO(gavinp): Update this test after abandon has an effect on Prerenders, | 1135 // TODO(gavinp): Update this test after abandon has an effect on Prerenders, |
1112 // like shortening the timeouts. | 1136 // like shortening the timeouts. |
1113 TEST_F(PrerenderTest, LinkManagerAddTwiceAbandonTwice) { | 1137 TEST_F(PrerenderTest, LinkManagerAddTwiceAbandonTwice) { |
| 1138 SetConcurrency(2); |
1114 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1139 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1115 GURL url("http://www.myexample.com"); | 1140 GURL url("http://www.myexample.com"); |
1116 DummyPrerenderContents* prerender_contents = | 1141 DummyPrerenderContents* prerender_contents = |
1117 prerender_manager()->CreateNextPrerenderContents( | 1142 prerender_manager()->CreateNextPrerenderContents( |
1118 url, FINAL_STATUS_USED); | 1143 url, FINAL_STATUS_USED); |
1119 | 1144 |
1120 EXPECT_TRUE(AddSimplePrerender(url)); | 1145 EXPECT_TRUE(AddSimplePrerender(url)); |
1121 | 1146 |
1122 const int first_prerender_id = last_prerender_id(); | 1147 const int first_prerender_id = last_prerender_id(); |
1123 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 1148 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1236 prerender_manager()->AdvanceTimeTicks( | 1261 prerender_manager()->AdvanceTimeTicks( |
1237 prerender_manager()->config().abandon_time_to_live + | 1262 prerender_manager()->config().abandon_time_to_live + |
1238 TimeDelta::FromSeconds(1)); | 1263 TimeDelta::FromSeconds(1)); |
1239 | 1264 |
1240 DummyPrerenderContents* null = NULL; | 1265 DummyPrerenderContents* null = NULL; |
1241 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | 1266 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
1242 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1267 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1243 } | 1268 } |
1244 | 1269 |
1245 } // namespace prerender | 1270 } // namespace prerender |
OLD | NEW |