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_link_concurrency_per_launcher = |
| 309 concurrency; |
| 310 prerender_manager()->mutable_config().max_link_concurrency = |
| 311 std::max(prerender_manager()->mutable_config().max_link_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 |
318 // Shorthand to add a simple preload with a reasonable source. | 327 bool LauncherHasRunningPrerender(int child_id, int prerender_id) { |
| 328 PrerenderLinkManager::LinkPrerender* prerender = |
| 329 prerender_link_manager()->FindByLauncherChildIdAndPrerenderId( |
| 330 child_id, prerender_id); |
| 331 return prerender && prerender->handle; |
| 332 } |
| 333 |
| 334 // Shorthand to add a simple prerender with a reasonable source. Returns |
| 335 // true iff the prerender has been added to the PrerenderManager by the |
| 336 // PrerenderLinkManager and the PrerenderManager returned a handle. |
319 bool AddSimplePrerender(const GURL& url) { | 337 bool AddSimplePrerender(const GURL& url) { |
320 return prerender_link_manager()->OnAddPrerender( | 338 prerender_link_manager()->OnAddPrerender(kDefaultChildId, |
321 kDefaultChildId, GetNextPrerenderID(), | 339 GetNextPrerenderID(), |
322 url, content::Referrer(), | 340 url, content::Referrer(), |
323 kSize, kDefaultRenderViewRouteId); | 341 kSize, kDefaultRenderViewRouteId); |
| 342 return LauncherHasRunningPrerender(kDefaultChildId, last_prerender_id()); |
324 } | 343 } |
325 | 344 |
326 private: | 345 private: |
327 PrerenderTracker* prerender_tracker() { | 346 PrerenderTracker* prerender_tracker() { |
328 return g_browser_process->prerender_tracker(); | 347 return g_browser_process->prerender_tracker(); |
329 } | 348 } |
330 | 349 |
331 // Needed to pass PrerenderManager's DCHECKs. | 350 // Needed to pass PrerenderManager's DCHECKs. |
332 TestingProfile profile_; | 351 TestingProfile profile_; |
333 MessageLoop message_loop_; | 352 MessageLoop message_loop_; |
334 content::TestBrowserThread ui_thread_; | 353 content::TestBrowserThread ui_thread_; |
335 scoped_ptr<UnitTestPrerenderManager> prerender_manager_; | 354 scoped_ptr<UnitTestPrerenderManager> prerender_manager_; |
336 scoped_ptr<PrerenderLinkManager> prerender_link_manager_; | 355 scoped_ptr<PrerenderLinkManager> prerender_link_manager_; |
337 int last_prerender_id_; | 356 int last_prerender_id_; |
338 }; | 357 }; |
339 | 358 |
340 TEST_F(PrerenderTest, FoundTest) { | 359 TEST_F(PrerenderTest, FoundTest) { |
341 GURL url("http://www.google.com/"); | 360 GURL url("http://www.google.com/"); |
342 DummyPrerenderContents* prerender_contents = | 361 DummyPrerenderContents* prerender_contents = |
343 prerender_manager()->CreateNextPrerenderContents( | 362 prerender_manager()->CreateNextPrerenderContents( |
344 url, | 363 url, |
345 FINAL_STATUS_USED); | 364 FINAL_STATUS_USED); |
346 EXPECT_TRUE(AddSimplePrerender(url)); | 365 EXPECT_TRUE(AddSimplePrerender(url)); |
347 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 366 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
348 ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url)); | 367 ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url)); |
349 } | 368 } |
350 | 369 |
| 370 // Make sure that if queue a request, and a second prerender request for the |
| 371 // same URL comes in, that the second request attaches to the first prerender, |
| 372 // and we don't use the second prerender contents. |
351 TEST_F(PrerenderTest, DuplicateTest) { | 373 TEST_F(PrerenderTest, DuplicateTest) { |
| 374 SetConcurrency(2); |
352 GURL url("http://www.google.com/"); | 375 GURL url("http://www.google.com/"); |
353 DummyPrerenderContents* prerender_contents = | 376 DummyPrerenderContents* prerender_contents = |
354 prerender_manager()->CreateNextPrerenderContents( | 377 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, | 378 url, |
379 FINAL_STATUS_USED); | 379 FINAL_STATUS_USED); |
380 DummyPrerenderContents* null = NULL; | 380 DummyPrerenderContents* null = NULL; |
381 EXPECT_TRUE(AddSimplePrerender(url)); | 381 EXPECT_TRUE(AddSimplePrerender(url)); |
382 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 382 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
383 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 383 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
384 | 384 |
385 DummyPrerenderContents* prerender_contents1 = | 385 DummyPrerenderContents* prerender_contents1 = |
386 prerender_manager()->CreateNextPrerenderContents( | 386 prerender_manager()->CreateNextPrerenderContents( |
387 url, | 387 url, |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
477 last_prerender_id()); | 477 last_prerender_id()); |
478 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 478 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
479 | 479 |
480 DummyPrerenderContents* null = NULL; | 480 DummyPrerenderContents* null = NULL; |
481 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 481 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
482 | 482 |
483 prerender_manager()->AdvanceTimeTicks(second_advance); | 483 prerender_manager()->AdvanceTimeTicks(second_advance); |
484 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | 484 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
485 } | 485 } |
486 | 486 |
487 // LRU Test. Make sure that if we prerender more requests than we support, that | 487 // Make sure that if we prerender more requests than we support, that we launch |
488 // the oldest one will be dropped. | 488 // them in the order given up until we reach MaxConcurrency, at which point we |
489 TEST_F(PrerenderTest, DropOldestRequestTest) { | 489 // queue them and launch them in the order given. As well, insure that limits |
490 std::vector<int> concurrencies_to_test; | 490 // are enforced for the system as a whole and on a per launcher basis. |
491 concurrencies_to_test.push_back( | 491 TEST_F(PrerenderTest, MaxConcurrencyTest) { |
492 prerender_manager()->config().max_concurrency); | 492 struct TestConcurrency { |
493 concurrencies_to_test.push_back(1); | 493 size_t max_link_concurrency; |
494 concurrencies_to_test.push_back(2); | 494 size_t max_link_concurrency_per_launcher; |
| 495 }; |
| 496 |
| 497 TestConcurrency concurrencies_to_test[] = { |
| 498 { prerender_manager()->config().max_link_concurrency, |
| 499 prerender_manager()->config().max_link_concurrency_per_launcher}, |
| 500 |
| 501 // With the system limit higher than the per launcher limit, the per |
| 502 // launcher limit should be in effect. |
| 503 { 2, 1 }, |
| 504 |
| 505 // With the per launcher limit higher than system limit, the system limit |
| 506 // should be in effect. |
| 507 { 2, 4 }, |
| 508 }; |
495 | 509 |
496 DummyPrerenderContents* null = NULL; | 510 DummyPrerenderContents* null = NULL; |
497 GURL url_to_evict("http://www.google.com/evictme"); | 511 GURL url_to_delay("http://www.google.com/delayme"); |
498 | 512 |
499 for (std::vector<int>::const_iterator i = concurrencies_to_test.begin(); | 513 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(concurrencies_to_test); ++i) { |
500 i != concurrencies_to_test.end(); | 514 prerender_manager()->mutable_config().max_link_concurrency = |
501 ++i) { | 515 concurrencies_to_test[i].max_link_concurrency; |
502 const int max_concurrency = *i; | 516 prerender_manager()->mutable_config().max_link_concurrency_per_launcher = |
503 prerender_manager()->mutable_config().max_concurrency = max_concurrency; | 517 concurrencies_to_test[i].max_link_concurrency_per_launcher; |
504 | 518 |
505 DummyPrerenderContents* prerender_contents_to_evict = | 519 const size_t effective_max_link_concurrency = |
506 prerender_manager()->CreateNextPrerenderContents( | 520 std::min(concurrencies_to_test[i].max_link_concurrency, |
507 url_to_evict, FINAL_STATUS_EVICTED); | 521 concurrencies_to_test[i].max_link_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 | 522 |
512 std::vector<GURL> urls; | 523 std::vector<GURL> urls; |
513 std::vector<PrerenderContents*> prerender_contentses; | 524 std::vector<PrerenderContents*> prerender_contentses; |
514 | 525 |
515 for (int j = 0; j < max_concurrency; ++j) { | 526 // Launch prerenders up to the maximum this launcher can support. |
516 urls.push_back(GURL(base::StringPrintf("http://google.com/use#%d", j))); | 527 for (size_t j = 0; j < effective_max_link_concurrency; ++j) { |
| 528 urls.push_back( |
| 529 GURL(base::StringPrintf("http://google.com/use#%" PRIuS, j))); |
517 prerender_contentses.push_back( | 530 prerender_contentses.push_back( |
518 prerender_manager()->CreateNextPrerenderContents(urls.back(), | 531 prerender_manager()->CreateNextPrerenderContents(urls.back(), |
519 FINAL_STATUS_USED)); | 532 FINAL_STATUS_USED)); |
520 EXPECT_TRUE(AddSimplePrerender(urls.back())); | 533 EXPECT_TRUE(AddSimplePrerender(urls.back())); |
521 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 534 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
522 EXPECT_TRUE(prerender_contentses.back()->prerendering_has_started()); | 535 EXPECT_TRUE(prerender_contentses.back()->prerendering_has_started()); |
523 } | 536 } |
524 | 537 |
525 ASSERT_EQ(null, prerender_manager()->FindEntry(url_to_evict)); | 538 if (concurrencies_to_test[i].max_link_concurrency > |
526 for (int j = 0; j < max_concurrency; ++j) { | 539 effective_max_link_concurrency) { |
527 ASSERT_EQ(prerender_contentses[j], | 540 // We should be able to launch more prerenders on this system, but not for |
| 541 // our current launcher. |
| 542 int child_id; |
| 543 int route_id; |
| 544 ASSERT_TRUE(prerender_contentses.back()->GetChildId(&child_id)); |
| 545 ASSERT_TRUE(prerender_contentses.back()->GetRouteId(&route_id)); |
| 546 |
| 547 GURL extra_url("http://google.com/extraurl"); |
| 548 prerender_link_manager()->OnAddPrerender(child_id, |
| 549 GetNextPrerenderID(), |
| 550 extra_url, content::Referrer(), |
| 551 kSize, route_id); |
| 552 const int prerender_id = last_prerender_id(); |
| 553 EXPECT_TRUE(LauncherHasRunningPrerender(child_id, prerender_id)); |
| 554 prerender_link_manager()->OnCancelPrerender(child_id, prerender_id); |
| 555 EXPECT_FALSE(LauncherHasRunningPrerender(child_id, prerender_id)); |
| 556 } |
| 557 |
| 558 DummyPrerenderContents* prerender_contents_to_delay = |
| 559 prerender_manager()->CreateNextPrerenderContents(url_to_delay, |
| 560 FINAL_STATUS_USED); |
| 561 EXPECT_FALSE(AddSimplePrerender(url_to_delay)); |
| 562 EXPECT_FALSE(prerender_contents_to_delay->prerendering_has_started()); |
| 563 EXPECT_NE(null, prerender_manager()->next_prerender_contents()); |
| 564 EXPECT_EQ(null, prerender_manager()->FindEntry(url_to_delay)); |
| 565 for (size_t j = 0; j < effective_max_link_concurrency; ++j) { |
| 566 EXPECT_EQ(prerender_contentses[j], |
528 prerender_manager()->FindAndUseEntry(urls[j])); | 567 prerender_manager()->FindAndUseEntry(urls[j])); |
| 568 EXPECT_TRUE(prerender_contents_to_delay->prerendering_has_started()); |
529 } | 569 } |
| 570 |
| 571 EXPECT_EQ(prerender_contents_to_delay, |
| 572 prerender_manager()->FindAndUseEntry(url_to_delay)); |
| 573 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
530 } | 574 } |
531 } | 575 } |
532 | 576 |
533 TEST_F(PrerenderTest, AliasURLTest) { | 577 TEST_F(PrerenderTest, AliasURLTest) { |
| 578 SetConcurrency(7); |
| 579 |
534 GURL url("http://www.google.com/"); | 580 GURL url("http://www.google.com/"); |
535 GURL alias_url1("http://www.google.com/index.html"); | 581 GURL alias_url1("http://www.google.com/index.html"); |
536 GURL alias_url2("http://google.com/"); | 582 GURL alias_url2("http://google.com/"); |
537 GURL not_an_alias_url("http://google.com/index.html"); | 583 GURL not_an_alias_url("http://google.com/index.html"); |
538 std::vector<GURL> alias_urls; | 584 std::vector<GURL> alias_urls; |
539 alias_urls.push_back(alias_url1); | 585 alias_urls.push_back(alias_url1); |
540 alias_urls.push_back(alias_url2); | 586 alias_urls.push_back(alias_url2); |
541 | 587 |
542 // Test that all of the aliases work, but not_an_alias_url does not. | 588 // Test that all of the aliases work, but not_an_alias_url does not. |
543 DummyPrerenderContents* prerender_contents = | 589 DummyPrerenderContents* prerender_contents = |
(...skipping 16 matching lines...) Expand all Loading... |
560 // Test that alias URLs can not be added. | 606 // Test that alias URLs can not be added. |
561 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | 607 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
562 url, alias_urls, FINAL_STATUS_USED); | 608 url, alias_urls, FINAL_STATUS_USED); |
563 EXPECT_TRUE(AddSimplePrerender(url)); | 609 EXPECT_TRUE(AddSimplePrerender(url)); |
564 EXPECT_TRUE(AddSimplePrerender(url)); | 610 EXPECT_TRUE(AddSimplePrerender(url)); |
565 EXPECT_TRUE(AddSimplePrerender(alias_url1)); | 611 EXPECT_TRUE(AddSimplePrerender(alias_url1)); |
566 EXPECT_TRUE(AddSimplePrerender(alias_url2)); | 612 EXPECT_TRUE(AddSimplePrerender(alias_url2)); |
567 ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url)); | 613 ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url)); |
568 } | 614 } |
569 | 615 |
570 // Ensure that we ignore prerender requests within the rate limit. | |
571 TEST_F(PrerenderTest, RateLimitInWindowTest) { | |
572 GURL url("http://www.google.com/"); | |
573 DummyPrerenderContents* prerender_contents = | |
574 prerender_manager()->CreateNextPrerenderContents( | |
575 url, | |
576 FINAL_STATUS_MANAGER_SHUTDOWN); | |
577 DummyPrerenderContents* null = NULL; | |
578 EXPECT_TRUE(AddSimplePrerender(url)); | |
579 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
580 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | |
581 | |
582 prerender_manager()->set_rate_limit_enabled(true); | |
583 prerender_manager()->AdvanceTimeTicks(TimeDelta::FromMilliseconds(1)); | |
584 | |
585 GURL url1("http://news.google.com/"); | |
586 prerender_manager()->CreateNextPrerenderContents( | |
587 url, | |
588 FINAL_STATUS_MANAGER_SHUTDOWN); | |
589 EXPECT_FALSE(AddSimplePrerender(url1)); | |
590 prerender_manager()->set_rate_limit_enabled(false); | |
591 } | |
592 | |
593 // Ensure that we don't ignore prerender requests outside the rate limit. | |
594 TEST_F(PrerenderTest, RateLimitOutsideWindowTest) { | |
595 // Setting concurrency to one lets us force eviction by adding only one more | |
596 // prerender. | |
597 prerender_manager()->mutable_config().max_concurrency = 1; | |
598 | |
599 GURL url("http://www.google.com/"); | |
600 DummyPrerenderContents* prerender_contents = | |
601 prerender_manager()->CreateNextPrerenderContents( | |
602 url, | |
603 FINAL_STATUS_EVICTED); | |
604 DummyPrerenderContents* null = NULL; | |
605 EXPECT_TRUE(AddSimplePrerender(url)); | |
606 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
607 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | |
608 | |
609 prerender_manager()->set_rate_limit_enabled(true); | |
610 prerender_manager()->AdvanceTimeTicks( | |
611 TimeDelta::FromMilliseconds( | |
612 UnitTestPrerenderManager::kMinTimeBetweenPrerendersMs + 500)); | |
613 | |
614 GURL url1("http://news.google.com/"); | |
615 DummyPrerenderContents* rate_limit_prerender_contents = | |
616 prerender_manager()->CreateNextPrerenderContents( | |
617 url1, | |
618 FINAL_STATUS_MANAGER_SHUTDOWN); | |
619 EXPECT_TRUE(AddSimplePrerender(url1)); | |
620 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
621 EXPECT_TRUE(rate_limit_prerender_contents->prerendering_has_started()); | |
622 prerender_manager()->set_rate_limit_enabled(false); | |
623 } | |
624 | |
625 TEST_F(PrerenderTest, PendingPrerenderTest) { | 616 TEST_F(PrerenderTest, PendingPrerenderTest) { |
626 GURL url("http://www.google.com/"); | 617 GURL url("http://www.google.com/"); |
627 DummyPrerenderContents* prerender_contents = | 618 DummyPrerenderContents* prerender_contents = |
628 prerender_manager()->CreateNextPrerenderContents( | 619 prerender_manager()->CreateNextPrerenderContents( |
629 url, | 620 url, |
630 FINAL_STATUS_USED); | 621 FINAL_STATUS_USED); |
631 EXPECT_TRUE(AddSimplePrerender(url)); | 622 EXPECT_TRUE(AddSimplePrerender(url)); |
632 | 623 |
633 int child_id; | 624 int child_id; |
634 int route_id; | 625 int route_id; |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
736 } | 727 } |
737 | 728 |
738 // Tests that prerendering is cancelled when the source render view does not | 729 // Tests that prerendering is cancelled when the source render view does not |
739 // exist. On failure, the DCHECK in CreatePrerenderContents() above should be | 730 // exist. On failure, the DCHECK in CreatePrerenderContents() above should be |
740 // triggered. | 731 // triggered. |
741 TEST_F(PrerenderTest, SourceRenderViewClosed) { | 732 TEST_F(PrerenderTest, SourceRenderViewClosed) { |
742 GURL url("http://www.google.com/"); | 733 GURL url("http://www.google.com/"); |
743 prerender_manager()->CreateNextPrerenderContents( | 734 prerender_manager()->CreateNextPrerenderContents( |
744 url, | 735 url, |
745 FINAL_STATUS_MANAGER_SHUTDOWN); | 736 FINAL_STATUS_MANAGER_SHUTDOWN); |
746 EXPECT_FALSE(prerender_link_manager()->OnAddPrerender( | 737 prerender_link_manager()->OnAddPrerender(100, GetNextPrerenderID(), url, |
747 100, GetNextPrerenderID(), url, | 738 Referrer(), kSize, 200); |
748 Referrer(), kSize, 200)); | 739 EXPECT_FALSE(LauncherHasRunningPrerender(100, last_prerender_id())); |
749 } | 740 } |
750 | 741 |
751 // Tests that prerendering is cancelled when we launch a second prerender of | 742 // Tests that prerendering is cancelled when we launch a second prerender of |
752 // the same target within a short time interval. | 743 // the same target within a short time interval. |
753 TEST_F(PrerenderTest, RecentlyVisited) { | 744 TEST_F(PrerenderTest, RecentlyVisited) { |
754 GURL url("http://www.google.com/"); | 745 GURL url("http://www.google.com/"); |
755 | 746 |
756 prerender_manager()->RecordNavigation(url); | 747 prerender_manager()->RecordNavigation(url); |
757 | 748 |
758 DummyPrerenderContents* prerender_contents = | 749 DummyPrerenderContents* prerender_contents = |
(...skipping 254 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1013 TEST_F(PrerenderTest, LinkManagerCancelTwice) { | 1004 TEST_F(PrerenderTest, LinkManagerCancelTwice) { |
1014 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1005 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1015 GURL url("http://www.myexample.com"); | 1006 GURL url("http://www.myexample.com"); |
1016 DummyPrerenderContents* prerender_contents = | 1007 DummyPrerenderContents* prerender_contents = |
1017 prerender_manager()->CreateNextPrerenderContents( | 1008 prerender_manager()->CreateNextPrerenderContents( |
1018 url, FINAL_STATUS_CANCELLED); | 1009 url, FINAL_STATUS_CANCELLED); |
1019 | 1010 |
1020 EXPECT_TRUE(AddSimplePrerender(url)); | 1011 EXPECT_TRUE(AddSimplePrerender(url)); |
1021 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 1012 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
1022 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | 1013 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
1023 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 1014 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
1024 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, | 1015 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
1025 last_prerender_id()); | 1016 last_prerender_id()); |
1026 | 1017 |
1027 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1018 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1028 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | 1019 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
1029 DummyPrerenderContents* null = NULL; | 1020 DummyPrerenderContents* null = NULL; |
1030 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); | 1021 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); |
1031 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, | 1022 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
1032 last_prerender_id()); | 1023 last_prerender_id()); |
1033 } | 1024 } |
1034 | 1025 |
1035 TEST_F(PrerenderTest, LinkManagerAddTwiceCancelTwice) { | 1026 TEST_F(PrerenderTest, LinkManagerAddTwiceCancelTwice) { |
| 1027 SetConcurrency(2); |
1036 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1028 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1037 GURL url("http://www.myexample.com"); | 1029 GURL url("http://www.myexample.com"); |
1038 DummyPrerenderContents* prerender_contents = | 1030 DummyPrerenderContents* prerender_contents = |
1039 prerender_manager()->CreateNextPrerenderContents( | 1031 prerender_manager()->CreateNextPrerenderContents( |
1040 url, FINAL_STATUS_CANCELLED); | 1032 url, FINAL_STATUS_CANCELLED); |
1041 | 1033 |
1042 EXPECT_TRUE(AddSimplePrerender(url)); | 1034 EXPECT_TRUE(AddSimplePrerender(url)); |
1043 | 1035 |
1044 const int first_prerender_id = last_prerender_id(); | 1036 const int first_prerender_id = last_prerender_id(); |
1045 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 1037 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
1046 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | 1038 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
1047 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 1039 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
1048 EXPECT_TRUE(AddSimplePrerender(url)); | 1040 EXPECT_TRUE(AddSimplePrerender(url)); |
1049 | 1041 |
1050 const int second_prerender_id = last_prerender_id(); | 1042 const int second_prerender_id = last_prerender_id(); |
1051 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 1043 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
1052 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | 1044 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
1053 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 1045 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
1054 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, | 1046 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
1055 first_prerender_id); | 1047 first_prerender_id); |
1056 | 1048 |
1057 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | 1049 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
1058 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 1050 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
1059 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, | 1051 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
1060 second_prerender_id); | 1052 second_prerender_id); |
1061 | 1053 |
1062 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1054 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1063 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | 1055 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
1064 DummyPrerenderContents* null = NULL; | 1056 DummyPrerenderContents* null = NULL; |
1065 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); | 1057 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); |
1066 } | 1058 } |
1067 | 1059 |
1068 TEST_F(PrerenderTest, LinkManagerAddTwiceCancelTwiceThenAbandonTwice) { | 1060 TEST_F(PrerenderTest, LinkManagerAddTwiceCancelTwiceThenAbandonTwice) { |
| 1061 SetConcurrency(2); |
1069 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1062 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1070 GURL url("http://www.myexample.com"); | 1063 GURL url("http://www.myexample.com"); |
1071 DummyPrerenderContents* prerender_contents = | 1064 DummyPrerenderContents* prerender_contents = |
1072 prerender_manager()->CreateNextPrerenderContents( | 1065 prerender_manager()->CreateNextPrerenderContents( |
1073 url, FINAL_STATUS_CANCELLED); | 1066 url, FINAL_STATUS_CANCELLED); |
1074 | 1067 |
1075 EXPECT_TRUE(AddSimplePrerender(url)); | 1068 EXPECT_TRUE(AddSimplePrerender(url)); |
1076 | 1069 |
1077 const int first_prerender_id = last_prerender_id(); | 1070 const int first_prerender_id = last_prerender_id(); |
1078 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 1071 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
(...skipping 24 matching lines...) Expand all Loading... |
1103 second_prerender_id); | 1096 second_prerender_id); |
1104 | 1097 |
1105 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1098 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1106 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | 1099 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
1107 DummyPrerenderContents* null = NULL; | 1100 DummyPrerenderContents* null = NULL; |
1108 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); | 1101 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); |
1109 } | 1102 } |
1110 | 1103 |
1111 // TODO(gavinp): Update this test after abandon has an effect on Prerenders, | 1104 // TODO(gavinp): Update this test after abandon has an effect on Prerenders, |
1112 // like shortening the timeouts. | 1105 // like shortening the timeouts. |
1113 TEST_F(PrerenderTest, LinkManagerAddTwiceAbandonTwice) { | 1106 TEST_F(PrerenderTest, LinkManagerAddTwiceAbandonTwiceUseTwice) { |
| 1107 SetConcurrency(2); |
1114 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1108 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1115 GURL url("http://www.myexample.com"); | 1109 GURL url("http://www.myexample.com"); |
1116 DummyPrerenderContents* prerender_contents = | 1110 DummyPrerenderContents* prerender_contents = |
1117 prerender_manager()->CreateNextPrerenderContents( | 1111 prerender_manager()->CreateNextPrerenderContents( |
1118 url, FINAL_STATUS_USED); | 1112 url, FINAL_STATUS_USED); |
1119 | 1113 |
1120 EXPECT_TRUE(AddSimplePrerender(url)); | 1114 EXPECT_TRUE(AddSimplePrerender(url)); |
1121 | 1115 |
1122 const int first_prerender_id = last_prerender_id(); | 1116 const int first_prerender_id = last_prerender_id(); |
1123 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 1117 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
1124 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | 1118 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
1125 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 1119 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
1126 EXPECT_TRUE(AddSimplePrerender(url)); | 1120 EXPECT_TRUE(AddSimplePrerender(url)); |
1127 | 1121 |
1128 const int second_prerender_id = last_prerender_id(); | 1122 const int second_prerender_id = last_prerender_id(); |
1129 EXPECT_TRUE(prerender_contents->prerendering_has_started()); | 1123 EXPECT_TRUE(prerender_contents->prerendering_has_started()); |
1130 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | 1124 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
1131 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 1125 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
1132 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, | 1126 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, |
1133 first_prerender_id); | 1127 first_prerender_id); |
1134 | 1128 |
1135 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | 1129 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
1136 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | 1130 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
1137 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, | 1131 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, |
1138 second_prerender_id); | 1132 second_prerender_id); |
1139 | 1133 |
1140 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | 1134 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
1141 ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url)); | 1135 ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url)); |
| 1136 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1142 } | 1137 } |
1143 | 1138 |
1144 // TODO(gavinp): After abandon shortens the expire time on a Prerender, | 1139 // TODO(gavinp): After abandon shortens the expire time on a Prerender, |
1145 // add a series of tests testing advancing the time by either the abandon | 1140 // add a series of tests testing advancing the time by either the abandon |
1146 // or normal expire, and verifying the expected behaviour with groups | 1141 // or normal expire, and verifying the expected behaviour with groups |
1147 // of links. | 1142 // of links. |
1148 TEST_F(PrerenderTest, LinkManagerExpireThenCancel) { | 1143 TEST_F(PrerenderTest, LinkManagerExpireThenCancel) { |
1149 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1144 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1150 GURL url("http://www.myexample.com"); | 1145 GURL url("http://www.myexample.com"); |
1151 DummyPrerenderContents* prerender_contents = | 1146 DummyPrerenderContents* prerender_contents = |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1235 | 1230 |
1236 prerender_manager()->AdvanceTimeTicks( | 1231 prerender_manager()->AdvanceTimeTicks( |
1237 prerender_manager()->config().abandon_time_to_live + | 1232 prerender_manager()->config().abandon_time_to_live + |
1238 TimeDelta::FromSeconds(1)); | 1233 TimeDelta::FromSeconds(1)); |
1239 | 1234 |
1240 DummyPrerenderContents* null = NULL; | 1235 DummyPrerenderContents* null = NULL; |
1241 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | 1236 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
1242 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | 1237 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
1243 } | 1238 } |
1244 | 1239 |
| 1240 // Creates two prerenders, one of which should be blocked by the |
| 1241 // max_link_concurrency; abandons both of them and waits to make sure both |
| 1242 // are cleared from the PrerenderLinkManager. |
| 1243 TEST_F(PrerenderTest, LinkManagerAbandonInactivePrerender) { |
| 1244 SetConcurrency(1); |
| 1245 ASSERT_LT(prerender_manager()->config().abandon_time_to_live, |
| 1246 prerender_manager()->config().time_to_live); |
| 1247 GURL first_url("http://www.myexample.com"); |
| 1248 DummyPrerenderContents* prerender_contents = |
| 1249 prerender_manager()->CreateNextPrerenderContents( |
| 1250 first_url, FINAL_STATUS_TIMED_OUT); |
| 1251 EXPECT_TRUE(AddSimplePrerender(first_url)); |
| 1252 const int first_prerender_id = last_prerender_id(); |
| 1253 |
| 1254 GURL second_url("http://www.neverlaunched.com"); |
| 1255 EXPECT_FALSE(AddSimplePrerender(second_url)); |
| 1256 const int second_prerender_id = last_prerender_id(); |
| 1257 |
| 1258 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); |
| 1259 |
| 1260 DummyPrerenderContents* null = NULL; |
| 1261 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(first_url)); |
| 1262 EXPECT_EQ(null, prerender_manager()->FindEntry(second_url)); |
| 1263 |
| 1264 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, |
| 1265 first_prerender_id); |
| 1266 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, |
| 1267 second_prerender_id); |
| 1268 |
| 1269 prerender_manager()->AdvanceTimeTicks( |
| 1270 prerender_manager()->config().abandon_time_to_live + |
| 1271 TimeDelta::FromSeconds(1)); |
| 1272 EXPECT_EQ(null, prerender_manager()->FindEntry(first_url)); |
| 1273 EXPECT_EQ(null, prerender_manager()->FindEntry(second_url)); |
| 1274 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 1275 } |
| 1276 |
| 1277 // Creates two prerenders, the second one started by the first, both of which |
| 1278 // should be blocked by max_concurrency; abandons both of them and waits to make |
| 1279 // sure both are cleared from the PrerenderLinkManager. |
| 1280 TEST_F(PrerenderTest, LinkManagerClearOnPendingAbandon) { |
| 1281 SetConcurrency(1); |
| 1282 ASSERT_LT(prerender_manager()->config().abandon_time_to_live, |
| 1283 prerender_manager()->config().time_to_live); |
| 1284 GURL first_url("http://www.myexample.com"); |
| 1285 DummyPrerenderContents* prerender_contents = |
| 1286 prerender_manager()->CreateNextPrerenderContents( |
| 1287 first_url, FINAL_STATUS_TIMED_OUT); |
| 1288 EXPECT_TRUE(AddSimplePrerender(first_url)); |
| 1289 const int first_prerender_id = last_prerender_id(); |
| 1290 |
| 1291 int child_id; |
| 1292 int route_id; |
| 1293 ASSERT_TRUE(prerender_contents->GetChildId(&child_id)); |
| 1294 ASSERT_TRUE(prerender_contents->GetRouteId(&route_id)); |
| 1295 |
| 1296 GURL pending_url("http://www.neverlaunched.com"); |
| 1297 prerender_link_manager()->OnAddPrerender(child_id, |
| 1298 GetNextPrerenderID(), |
| 1299 pending_url, content::Referrer(), |
| 1300 kSize, route_id); |
| 1301 const int second_prerender_id = last_prerender_id(); |
| 1302 |
| 1303 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); |
| 1304 |
| 1305 DummyPrerenderContents* null = NULL; |
| 1306 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(first_url)); |
| 1307 EXPECT_EQ(null, prerender_manager()->FindEntry(pending_url)); |
| 1308 |
| 1309 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, |
| 1310 first_prerender_id); |
| 1311 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, |
| 1312 second_prerender_id); |
| 1313 |
| 1314 prerender_manager()->AdvanceTimeTicks( |
| 1315 prerender_manager()->config().abandon_time_to_live + |
| 1316 TimeDelta::FromSeconds(1)); |
| 1317 EXPECT_EQ(null, prerender_manager()->FindEntry(first_url)); |
| 1318 EXPECT_EQ(null, prerender_manager()->FindEntry(pending_url)); |
| 1319 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 1320 } |
| 1321 |
| 1322 // Creates two prerenders, one of which should be blocked by the |
| 1323 // max_link_concurrency; uses one after the max wait to launch, and |
| 1324 // ensures the second prerender does not start. |
| 1325 TEST_F(PrerenderTest, LinkManagerWaitToLaunchNotLaunched) { |
| 1326 SetConcurrency(1); |
| 1327 ASSERT_LT(prerender_manager()->config().max_wait_to_launch, |
| 1328 prerender_manager()->config().time_to_live); |
| 1329 GURL first_url("http://www.myexample.com"); |
| 1330 DummyPrerenderContents* prerender_contents = |
| 1331 prerender_manager()->CreateNextPrerenderContents( |
| 1332 first_url, FINAL_STATUS_TIMED_OUT); |
| 1333 EXPECT_TRUE(AddSimplePrerender(first_url)); |
| 1334 |
| 1335 GURL second_url("http://www.neverlaunched.com"); |
| 1336 EXPECT_FALSE(AddSimplePrerender(second_url)); |
| 1337 |
| 1338 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); |
| 1339 |
| 1340 DummyPrerenderContents* null = NULL; |
| 1341 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(first_url)); |
| 1342 EXPECT_EQ(null, prerender_manager()->FindEntry(second_url)); |
| 1343 |
| 1344 prerender_manager()->AdvanceTimeTicks( |
| 1345 prerender_manager()->config().max_wait_to_launch + |
| 1346 TimeDelta::FromSeconds(1)); |
| 1347 EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(first_url)); |
| 1348 EXPECT_EQ(null, prerender_manager()->FindEntry(second_url)); |
| 1349 |
| 1350 EXPECT_EQ(prerender_contents, |
| 1351 prerender_manager()->FindAndUseEntry(first_url)); |
| 1352 |
| 1353 EXPECT_EQ(null, prerender_manager()->FindEntry(first_url)); |
| 1354 EXPECT_EQ(null, prerender_manager()->FindEntry(second_url)); |
| 1355 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 1356 } |
| 1357 |
1245 } // namespace prerender | 1358 } // namespace prerender |
OLD | NEW |