Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(25)

Side by Side Diff: chrome/browser/prerender/prerender_unittest.cc

Issue 11551003: Change multi-prerender API to include per launcher slots. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: guh Created 8 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
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
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
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
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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698