OLD | NEW |
(Empty) | |
| 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 |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "base/command_line.h" |
| 6 #include "base/memory/scoped_vector.h" |
| 7 #include "base/message_loop.h" |
| 8 #include "base/time.h" |
| 9 #include "chrome/browser/prerender/prerender_contents.h" |
| 10 #include "chrome/browser/prerender/prerender_link_manager.h" |
| 11 #include "chrome/browser/prerender/prerender_manager.h" |
| 12 #include "chrome/browser/prerender/prerender_origin.h" |
| 13 #include "chrome/common/chrome_switches.h" |
| 14 #include "chrome/test/base/testing_browser_process.h" |
| 15 #include "chrome/test/base/testing_profile.h" |
| 16 #include "content/public/browser/render_view_host.h" |
| 17 #include "content/test/test_browser_thread.h" |
| 18 #include "googleurl/src/gurl.h" |
| 19 #include "testing/gtest/include/gtest/gtest.h" |
| 20 #include "ui/gfx/size.h" |
| 21 |
| 22 using content::BrowserThread; |
| 23 |
| 24 namespace prerender { |
| 25 |
| 26 namespace { |
| 27 |
| 28 class DummyPrerenderContents : public PrerenderContents { |
| 29 public: |
| 30 DummyPrerenderContents(PrerenderManager* prerender_manager, |
| 31 PrerenderTracker* prerender_tracker, |
| 32 const GURL& url, |
| 33 Origin origin, |
| 34 FinalStatus expected_final_status) |
| 35 : PrerenderContents(prerender_manager, prerender_tracker, |
| 36 NULL, url, content::Referrer(), |
| 37 origin, PrerenderManager::kNoExperiment), |
| 38 has_started_(false), |
| 39 expected_final_status_(expected_final_status) { |
| 40 } |
| 41 |
| 42 virtual ~DummyPrerenderContents() { |
| 43 EXPECT_EQ(expected_final_status_, final_status()); |
| 44 } |
| 45 |
| 46 virtual void StartPrerendering( |
| 47 int ALLOW_UNUSED creator_child_id, |
| 48 const gfx::Size& ALLOW_UNUSED size, |
| 49 content::SessionStorageNamespace* ALLOW_UNUSED |
| 50 session_storage_namespace) OVERRIDE { |
| 51 has_started_ = true; |
| 52 } |
| 53 |
| 54 virtual bool GetChildId(int* child_id) const OVERRIDE { |
| 55 *child_id = 0; |
| 56 return true; |
| 57 } |
| 58 |
| 59 virtual bool GetRouteId(int* route_id) const OVERRIDE { |
| 60 *route_id = 0; |
| 61 return true; |
| 62 } |
| 63 |
| 64 bool has_started() const { return has_started_; } |
| 65 |
| 66 FinalStatus expected_final_status() const { return expected_final_status_; } |
| 67 |
| 68 bool prerendering_has_been_cancelled() const { |
| 69 return PrerenderContents::prerendering_has_been_cancelled(); |
| 70 } |
| 71 |
| 72 private: |
| 73 bool has_started_; |
| 74 FinalStatus expected_final_status_; |
| 75 }; |
| 76 |
| 77 class TestPrerenderManager : public PrerenderManager { |
| 78 public: |
| 79 explicit TestPrerenderManager(PrerenderTracker* prerender_tracker) |
| 80 : PrerenderManager(&profile_, prerender_tracker), |
| 81 time_(base::Time::Now()), |
| 82 time_ticks_(base::TimeTicks::Now()), |
| 83 next_prerender_contents_(NULL), |
| 84 prerender_tracker_(prerender_tracker) { |
| 85 set_rate_limit_enabled(false); |
| 86 } |
| 87 |
| 88 virtual ~TestPrerenderManager() { |
| 89 if (next_prerender_contents()) { |
| 90 next_prerender_contents_.release()->Destroy( |
| 91 FINAL_STATUS_MANAGER_SHUTDOWN); |
| 92 } |
| 93 // Set the final status for all PrerenderContents with an expected final |
| 94 // status of FINAL_STATUS_USED. These values are normally set when the |
| 95 // prerendered RVH is swapped into a tab, which doesn't happen in these |
| 96 // unit tests. |
| 97 for (ScopedVector<PrerenderContents>::iterator it = |
| 98 used_prerender_contents_.begin(); |
| 99 it != used_prerender_contents_.end(); ++it) { |
| 100 (*it)->set_final_status(FINAL_STATUS_USED); |
| 101 } |
| 102 DoShutdown(); |
| 103 } |
| 104 |
| 105 void AdvanceTime(base::TimeDelta delta) { |
| 106 time_ += delta; |
| 107 } |
| 108 |
| 109 void AdvanceTimeTicks(base::TimeDelta delta) { |
| 110 time_ticks_ += delta; |
| 111 } |
| 112 |
| 113 DummyPrerenderContents* CreateNextPrerenderContents( |
| 114 const GURL& url, |
| 115 FinalStatus expected_final_status) { |
| 116 DummyPrerenderContents* prerender_contents = |
| 117 new DummyPrerenderContents(this, prerender_tracker_, url, |
| 118 ORIGIN_LINK_REL_PRERENDER, |
| 119 expected_final_status); |
| 120 SetNextPrerenderContents(prerender_contents); |
| 121 return prerender_contents; |
| 122 } |
| 123 |
| 124 DummyPrerenderContents* CreateNextPrerenderContents( |
| 125 const GURL& url, |
| 126 Origin origin, |
| 127 FinalStatus expected_final_status) { |
| 128 DummyPrerenderContents* prerender_contents = |
| 129 new DummyPrerenderContents(this, prerender_tracker_, url, |
| 130 origin, expected_final_status); |
| 131 SetNextPrerenderContents(prerender_contents); |
| 132 return prerender_contents; |
| 133 } |
| 134 |
| 135 DummyPrerenderContents* CreateNextPrerenderContents( |
| 136 const GURL& url, |
| 137 const std::vector<GURL>& alias_urls, |
| 138 FinalStatus expected_final_status) { |
| 139 DummyPrerenderContents* prerender_contents = |
| 140 new DummyPrerenderContents(this, prerender_tracker_, url, |
| 141 ORIGIN_LINK_REL_PRERENDER, |
| 142 expected_final_status); |
| 143 for (std::vector<GURL>::const_iterator it = alias_urls.begin(); |
| 144 it != alias_urls.end(); |
| 145 ++it) { |
| 146 EXPECT_TRUE(prerender_contents->AddAliasURL(*it)); |
| 147 } |
| 148 SetNextPrerenderContents(prerender_contents); |
| 149 return prerender_contents; |
| 150 } |
| 151 |
| 152 void set_rate_limit_enabled(bool enabled) { |
| 153 mutable_config().rate_limit_enabled = enabled; |
| 154 } |
| 155 |
| 156 PrerenderContents* next_prerender_contents() { |
| 157 return next_prerender_contents_.get(); |
| 158 } |
| 159 |
| 160 private: |
| 161 void SetNextPrerenderContents(DummyPrerenderContents* prerender_contents) { |
| 162 DCHECK(!next_prerender_contents_.get()); |
| 163 next_prerender_contents_.reset(prerender_contents); |
| 164 if (prerender_contents->expected_final_status() == FINAL_STATUS_USED) |
| 165 used_prerender_contents_.push_back(prerender_contents); |
| 166 } |
| 167 |
| 168 virtual base::Time GetCurrentTime() const OVERRIDE { |
| 169 return time_; |
| 170 } |
| 171 |
| 172 virtual base::TimeTicks GetCurrentTimeTicks() const OVERRIDE { |
| 173 return time_ticks_; |
| 174 } |
| 175 |
| 176 virtual PrerenderContents* CreatePrerenderContents( |
| 177 const GURL& url, |
| 178 const content::Referrer& referrer, |
| 179 Origin origin, |
| 180 uint8 experiment_id) OVERRIDE { |
| 181 DCHECK(next_prerender_contents_.get()); |
| 182 DCHECK_EQ(next_prerender_contents_->prerender_url(), url); |
| 183 DCHECK_EQ(next_prerender_contents_->origin(), origin); |
| 184 return next_prerender_contents_.release(); |
| 185 } |
| 186 |
| 187 base::Time time_; |
| 188 base::TimeTicks time_ticks_; |
| 189 scoped_ptr<PrerenderContents> next_prerender_contents_; |
| 190 // PrerenderContents with an |expected_final_status| of FINAL_STATUS_USED, |
| 191 // tracked so they will be automatically deleted. |
| 192 ScopedVector<PrerenderContents> used_prerender_contents_; |
| 193 |
| 194 PrerenderTracker* prerender_tracker_; |
| 195 |
| 196 TestingProfile profile_; |
| 197 }; |
| 198 |
| 199 class RestorePrerenderMode { |
| 200 public: |
| 201 RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) { |
| 202 } |
| 203 |
| 204 ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); } |
| 205 private: |
| 206 PrerenderManager::PrerenderManagerMode prev_mode_; |
| 207 }; |
| 208 |
| 209 } // namespace |
| 210 |
| 211 class PrerenderTest : public testing::Test { |
| 212 public: |
| 213 static const int kDefaultChildId = -1; |
| 214 static const int kDefaultRenderViewRouteId = -1; |
| 215 |
| 216 PrerenderTest() : ui_thread_(BrowserThread::UI, &message_loop_), |
| 217 prerender_manager_( |
| 218 new TestPrerenderManager(prerender_tracker())), |
| 219 prerender_link_manager_( |
| 220 new PrerenderLinkManager(prerender_manager_.get())), |
| 221 last_prerender_id_(0) { |
| 222 // Enable omnibox prerendering. |
| 223 CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| 224 switches::kPrerenderFromOmnibox, |
| 225 switches::kPrerenderFromOmniboxSwitchValueEnabled); |
| 226 } |
| 227 |
| 228 TestPrerenderManager* prerender_manager() { |
| 229 return prerender_manager_.get(); |
| 230 } |
| 231 |
| 232 PrerenderLinkManager* prerender_link_manager() { |
| 233 return prerender_link_manager_.get(); |
| 234 } |
| 235 |
| 236 bool IsEmptyPrerenderLinkManager() { |
| 237 return prerender_link_manager_->IsEmpty(); |
| 238 } |
| 239 |
| 240 int last_prerender_id() const { |
| 241 return last_prerender_id_; |
| 242 } |
| 243 |
| 244 int GetNextPrerenderID() { |
| 245 return ++last_prerender_id_; |
| 246 } |
| 247 |
| 248 // Shorthand to add a simple preload with a reasonable source. |
| 249 bool AddSimplePrerender(const GURL& url) { |
| 250 return prerender_link_manager()->OnAddPrerender( |
| 251 kDefaultChildId, GetNextPrerenderID(), |
| 252 url, content::Referrer(), |
| 253 gfx::Size(), kDefaultRenderViewRouteId); |
| 254 } |
| 255 |
| 256 private: |
| 257 PrerenderTracker* prerender_tracker() { |
| 258 return g_browser_process->prerender_tracker(); |
| 259 } |
| 260 |
| 261 // Needed to pass PrerenderManager's DCHECKs. |
| 262 MessageLoop message_loop_; |
| 263 content::TestBrowserThread ui_thread_; |
| 264 scoped_ptr<TestPrerenderManager> prerender_manager_; |
| 265 scoped_ptr<PrerenderLinkManager> prerender_link_manager_; |
| 266 int last_prerender_id_; |
| 267 }; |
| 268 |
| 269 TEST_F(PrerenderTest, EmptyTest) { |
| 270 EXPECT_FALSE(prerender_manager()->MaybeUsePrerenderedPage( |
| 271 NULL, |
| 272 GURL("http://www.google.com/"))); |
| 273 } |
| 274 |
| 275 TEST_F(PrerenderTest, FoundTest) { |
| 276 GURL url("http://www.google.com/"); |
| 277 DummyPrerenderContents* prerender_contents = |
| 278 prerender_manager()->CreateNextPrerenderContents( |
| 279 url, |
| 280 FINAL_STATUS_USED); |
| 281 EXPECT_TRUE(AddSimplePrerender(url)); |
| 282 EXPECT_TRUE(prerender_contents->has_started()); |
| 283 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
| 284 } |
| 285 |
| 286 // Make sure that if queue a request, and a second prerender request for the |
| 287 // same URL comes in, that we drop the second request and keep the first one. |
| 288 TEST_F(PrerenderTest, DropSecondRequestTest) { |
| 289 GURL url("http://www.google.com/"); |
| 290 DummyPrerenderContents* prerender_contents = |
| 291 prerender_manager()->CreateNextPrerenderContents( |
| 292 url, |
| 293 FINAL_STATUS_USED); |
| 294 DummyPrerenderContents* null = NULL; |
| 295 EXPECT_TRUE(AddSimplePrerender(url)); |
| 296 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
| 297 EXPECT_TRUE(prerender_contents->has_started()); |
| 298 |
| 299 DummyPrerenderContents* prerender_contents1 = |
| 300 prerender_manager()->CreateNextPrerenderContents( |
| 301 url, |
| 302 FINAL_STATUS_MANAGER_SHUTDOWN); |
| 303 EXPECT_TRUE(AddSimplePrerender(url)); |
| 304 EXPECT_EQ(prerender_contents1, |
| 305 prerender_manager()->next_prerender_contents()); |
| 306 EXPECT_FALSE(prerender_contents1->has_started()); |
| 307 |
| 308 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
| 309 } |
| 310 |
| 311 // Ensure that we expire a prerendered page after the max. permitted time. |
| 312 TEST_F(PrerenderTest, ExpireTest) { |
| 313 GURL url("http://www.google.com/"); |
| 314 DummyPrerenderContents* prerender_contents = |
| 315 prerender_manager()->CreateNextPrerenderContents( |
| 316 url, |
| 317 FINAL_STATUS_TIMED_OUT); |
| 318 DummyPrerenderContents* null = NULL; |
| 319 EXPECT_TRUE(AddSimplePrerender(url)); |
| 320 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
| 321 EXPECT_TRUE(prerender_contents->has_started()); |
| 322 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + |
| 323 base::TimeDelta::FromSeconds(1)); |
| 324 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
| 325 } |
| 326 |
| 327 // LRU Test. Make sure that if we prerender more than one request, that |
| 328 // the oldest one will be dropped. |
| 329 TEST_F(PrerenderTest, DropOldestRequestTest) { |
| 330 GURL url("http://www.google.com/"); |
| 331 DummyPrerenderContents* prerender_contents = |
| 332 prerender_manager()->CreateNextPrerenderContents( |
| 333 url, |
| 334 FINAL_STATUS_EVICTED); |
| 335 DummyPrerenderContents* null = NULL; |
| 336 EXPECT_TRUE(AddSimplePrerender(url)); |
| 337 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
| 338 EXPECT_TRUE(prerender_contents->has_started()); |
| 339 |
| 340 GURL url1("http://news.google.com/"); |
| 341 DummyPrerenderContents* prerender_contents1 = |
| 342 prerender_manager()->CreateNextPrerenderContents( |
| 343 url1, |
| 344 FINAL_STATUS_USED); |
| 345 EXPECT_TRUE(AddSimplePrerender(url1)); |
| 346 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
| 347 EXPECT_TRUE(prerender_contents1->has_started()); |
| 348 |
| 349 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
| 350 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); |
| 351 } |
| 352 |
| 353 // Two element prerender test. Ensure that the LRU operates correctly if we |
| 354 // permit 2 elements to be kept prerendered. |
| 355 TEST_F(PrerenderTest, TwoElementPrerenderTest) { |
| 356 prerender_manager()->mutable_config().max_elements = 2; |
| 357 GURL url("http://www.google.com/"); |
| 358 DummyPrerenderContents* prerender_contents = |
| 359 prerender_manager()->CreateNextPrerenderContents( |
| 360 url, |
| 361 FINAL_STATUS_EVICTED); |
| 362 DummyPrerenderContents* null = NULL; |
| 363 EXPECT_TRUE(AddSimplePrerender(url)); |
| 364 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
| 365 EXPECT_TRUE(prerender_contents->has_started()); |
| 366 |
| 367 GURL url1("http://news.google.com/"); |
| 368 DummyPrerenderContents* prerender_contents1 = |
| 369 prerender_manager()->CreateNextPrerenderContents( |
| 370 url1, |
| 371 FINAL_STATUS_USED); |
| 372 EXPECT_TRUE(AddSimplePrerender(url1)); |
| 373 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
| 374 EXPECT_TRUE(prerender_contents1->has_started()); |
| 375 |
| 376 GURL url2("http://images.google.com/"); |
| 377 DummyPrerenderContents* prerender_contents2 = |
| 378 prerender_manager()->CreateNextPrerenderContents( |
| 379 url2, |
| 380 FINAL_STATUS_USED); |
| 381 EXPECT_TRUE(AddSimplePrerender(url2)); |
| 382 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
| 383 EXPECT_TRUE(prerender_contents2->has_started()); |
| 384 |
| 385 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
| 386 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); |
| 387 ASSERT_EQ(prerender_contents2, prerender_manager()->GetEntry(url2)); |
| 388 } |
| 389 |
| 390 TEST_F(PrerenderTest, AliasURLTest) { |
| 391 GURL url("http://www.google.com/"); |
| 392 GURL alias_url1("http://www.google.com/index.html"); |
| 393 GURL alias_url2("http://google.com/"); |
| 394 GURL not_an_alias_url("http://google.com/index.html"); |
| 395 std::vector<GURL> alias_urls; |
| 396 alias_urls.push_back(alias_url1); |
| 397 alias_urls.push_back(alias_url2); |
| 398 |
| 399 // Test that all of the aliases work, but not_an_alias_url does not. |
| 400 DummyPrerenderContents* prerender_contents = |
| 401 prerender_manager()->CreateNextPrerenderContents( |
| 402 url, alias_urls, FINAL_STATUS_USED); |
| 403 EXPECT_TRUE(AddSimplePrerender(url)); |
| 404 ASSERT_EQ(NULL, prerender_manager()->GetEntry(not_an_alias_url)); |
| 405 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url1)); |
| 406 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
| 407 url, alias_urls, FINAL_STATUS_USED); |
| 408 EXPECT_TRUE(AddSimplePrerender(url)); |
| 409 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url2)); |
| 410 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
| 411 url, alias_urls, FINAL_STATUS_USED); |
| 412 EXPECT_TRUE(AddSimplePrerender(url)); |
| 413 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
| 414 |
| 415 // Test that alias URLs can not be added. |
| 416 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
| 417 url, alias_urls, FINAL_STATUS_USED); |
| 418 EXPECT_TRUE(AddSimplePrerender(url)); |
| 419 EXPECT_TRUE(AddSimplePrerender(url)); |
| 420 EXPECT_TRUE(AddSimplePrerender(alias_url1)); |
| 421 EXPECT_TRUE(AddSimplePrerender(alias_url2)); |
| 422 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
| 423 } |
| 424 |
| 425 // Ensure that we ignore prerender requests within the rate limit. |
| 426 TEST_F(PrerenderTest, RateLimitInWindowTest) { |
| 427 GURL url("http://www.google.com/"); |
| 428 DummyPrerenderContents* prerender_contents = |
| 429 prerender_manager()->CreateNextPrerenderContents( |
| 430 url, |
| 431 FINAL_STATUS_MANAGER_SHUTDOWN); |
| 432 DummyPrerenderContents* null = NULL; |
| 433 EXPECT_TRUE(AddSimplePrerender(url)); |
| 434 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
| 435 EXPECT_TRUE(prerender_contents->has_started()); |
| 436 |
| 437 prerender_manager()->set_rate_limit_enabled(true); |
| 438 prerender_manager()->AdvanceTimeTicks(base::TimeDelta::FromMilliseconds(1)); |
| 439 |
| 440 GURL url1("http://news.google.com/"); |
| 441 prerender_manager()->CreateNextPrerenderContents( |
| 442 url, |
| 443 FINAL_STATUS_MANAGER_SHUTDOWN); |
| 444 EXPECT_FALSE(AddSimplePrerender(url1)); |
| 445 prerender_manager()->set_rate_limit_enabled(false); |
| 446 } |
| 447 |
| 448 // Ensure that we don't ignore prerender requests outside the rate limit. |
| 449 TEST_F(PrerenderTest, RateLimitOutsideWindowTest) { |
| 450 GURL url("http://www.google.com/"); |
| 451 DummyPrerenderContents* prerender_contents = |
| 452 prerender_manager()->CreateNextPrerenderContents( |
| 453 url, |
| 454 FINAL_STATUS_EVICTED); |
| 455 DummyPrerenderContents* null = NULL; |
| 456 EXPECT_TRUE(AddSimplePrerender(url)); |
| 457 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
| 458 EXPECT_TRUE(prerender_contents->has_started()); |
| 459 |
| 460 prerender_manager()->set_rate_limit_enabled(true); |
| 461 prerender_manager()->AdvanceTimeTicks( |
| 462 base::TimeDelta::FromMilliseconds(2000)); |
| 463 |
| 464 GURL url1("http://news.google.com/"); |
| 465 DummyPrerenderContents* rate_limit_prerender_contents = |
| 466 prerender_manager()->CreateNextPrerenderContents( |
| 467 url1, |
| 468 FINAL_STATUS_MANAGER_SHUTDOWN); |
| 469 EXPECT_TRUE(AddSimplePrerender(url1)); |
| 470 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
| 471 EXPECT_TRUE(rate_limit_prerender_contents->has_started()); |
| 472 prerender_manager()->set_rate_limit_enabled(false); |
| 473 } |
| 474 |
| 475 TEST_F(PrerenderTest, PendingPrerenderTest) { |
| 476 GURL url("http://www.google.com/"); |
| 477 DummyPrerenderContents* prerender_contents = |
| 478 prerender_manager()->CreateNextPrerenderContents( |
| 479 url, |
| 480 FINAL_STATUS_USED); |
| 481 EXPECT_TRUE(AddSimplePrerender(url)); |
| 482 |
| 483 int child_id; |
| 484 int route_id; |
| 485 ASSERT_TRUE(prerender_contents->GetChildId(&child_id)); |
| 486 ASSERT_TRUE(prerender_contents->GetRouteId(&route_id)); |
| 487 |
| 488 GURL pending_url("http://news.google.com/"); |
| 489 |
| 490 EXPECT_TRUE(prerender_manager()->AddPrerenderFromLinkRelPrerender( |
| 491 child_id, route_id, |
| 492 pending_url, content::Referrer(url, WebKit::WebReferrerPolicyDefault), |
| 493 gfx::Size())); |
| 494 |
| 495 EXPECT_TRUE(prerender_manager()->IsPendingEntry(pending_url)); |
| 496 EXPECT_TRUE(prerender_contents->has_started()); |
| 497 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
| 498 } |
| 499 |
| 500 // Tests that a PrerenderManager created for a browser session in the control |
| 501 // group works as expected. |
| 502 TEST_F(PrerenderTest, ControlGroup) { |
| 503 RestorePrerenderMode restore_prerender_mode; |
| 504 PrerenderManager::SetMode( |
| 505 PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP); |
| 506 GURL url("http://www.google.com/"); |
| 507 DummyPrerenderContents* prerender_contents = |
| 508 prerender_manager()->CreateNextPrerenderContents( |
| 509 url, |
| 510 FINAL_STATUS_MANAGER_SHUTDOWN); |
| 511 EXPECT_TRUE(AddSimplePrerender(url)); |
| 512 EXPECT_FALSE(prerender_contents->has_started()); |
| 513 } |
| 514 |
| 515 // Tests that prerendering is cancelled when the source render view does not |
| 516 // exist. On failure, the DCHECK in CreatePrerenderContents() above should be |
| 517 // triggered. |
| 518 TEST_F(PrerenderTest, SourceRenderViewClosed) { |
| 519 GURL url("http://www.google.com/"); |
| 520 prerender_manager()->CreateNextPrerenderContents( |
| 521 url, |
| 522 FINAL_STATUS_MANAGER_SHUTDOWN); |
| 523 EXPECT_FALSE(prerender_link_manager()->OnAddPrerender( |
| 524 100, GetNextPrerenderID(), url, |
| 525 content::Referrer(), gfx::Size(), 200)); |
| 526 } |
| 527 |
| 528 // Tests that the prerender manager ignores fragment references when matching |
| 529 // prerender URLs in the case the fragment is not in the prerender URL. |
| 530 TEST_F(PrerenderTest, PageMatchesFragmentTest) { |
| 531 GURL url("http://www.google.com/"); |
| 532 GURL fragment_url("http://www.google.com/#test"); |
| 533 |
| 534 DummyPrerenderContents* prerender_contents = |
| 535 prerender_manager()->CreateNextPrerenderContents(url, |
| 536 FINAL_STATUS_USED); |
| 537 EXPECT_TRUE(AddSimplePrerender(url)); |
| 538 EXPECT_TRUE(prerender_contents->has_started()); |
| 539 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(fragment_url)); |
| 540 } |
| 541 |
| 542 // Tests that the prerender manager ignores fragment references when matching |
| 543 // prerender URLs in the case the fragment is in the prerender URL. |
| 544 // TODO(gavinp): Re-enable this in the Prerender API once we're officially |
| 545 // fragment clean. |
| 546 TEST_F(PrerenderTest, DISABLED_FragmentMatchesPageTest) { |
| 547 GURL url("http://www.google.com/"); |
| 548 GURL fragment_url("http://www.google.com/#test"); |
| 549 |
| 550 DummyPrerenderContents* prerender_contents = |
| 551 prerender_manager()->CreateNextPrerenderContents(fragment_url, |
| 552 FINAL_STATUS_USED); |
| 553 EXPECT_TRUE(AddSimplePrerender(fragment_url)); |
| 554 EXPECT_TRUE(prerender_contents->has_started()); |
| 555 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
| 556 } |
| 557 |
| 558 // Tests that the prerender manager ignores fragment references when matching |
| 559 // prerender URLs in the case the fragment is in both URLs. |
| 560 // TODO(gavinp): Re-enable this in the Prerender API once we're officially |
| 561 // fragment clean. |
| 562 TEST_F(PrerenderTest, DISABLED_FragmentMatchesFragmentTest) { |
| 563 GURL fragment_url("http://www.google.com/#test"); |
| 564 GURL other_fragment_url("http://www.google.com/#other_test"); |
| 565 |
| 566 DummyPrerenderContents* prerender_contents = |
| 567 prerender_manager()->CreateNextPrerenderContents(fragment_url, |
| 568 FINAL_STATUS_USED); |
| 569 EXPECT_TRUE(AddSimplePrerender(fragment_url)); |
| 570 EXPECT_TRUE(prerender_contents->has_started()); |
| 571 ASSERT_EQ(prerender_contents, |
| 572 prerender_manager()->GetEntry(other_fragment_url)); |
| 573 } |
| 574 |
| 575 // Make sure that clearing works as expected. |
| 576 TEST_F(PrerenderTest, ClearTest) { |
| 577 GURL url("http://www.google.com/"); |
| 578 DummyPrerenderContents* prerender_contents = |
| 579 prerender_manager()->CreateNextPrerenderContents( |
| 580 url, |
| 581 FINAL_STATUS_CACHE_OR_HISTORY_CLEARED); |
| 582 EXPECT_TRUE(AddSimplePrerender(url)); |
| 583 EXPECT_TRUE(prerender_contents->has_started()); |
| 584 prerender_manager()->ClearData(PrerenderManager::CLEAR_PRERENDER_CONTENTS); |
| 585 DummyPrerenderContents* null = NULL; |
| 586 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
| 587 } |
| 588 |
| 589 // Make sure canceling works as expected. |
| 590 TEST_F(PrerenderTest, CancelAllTest) { |
| 591 GURL url("http://www.google.com/"); |
| 592 DummyPrerenderContents* prerender_contents = |
| 593 prerender_manager()->CreateNextPrerenderContents( |
| 594 url, FINAL_STATUS_CANCELLED); |
| 595 EXPECT_TRUE(AddSimplePrerender(url)); |
| 596 EXPECT_TRUE(prerender_contents->has_started()); |
| 597 prerender_manager()->CancelAllPrerenders(); |
| 598 const DummyPrerenderContents* null = NULL; |
| 599 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
| 600 } |
| 601 |
| 602 // Make sure canceling for omnibox works as expected. |
| 603 TEST_F(PrerenderTest, CancelOmniboxRemovesOmniboxTest) { |
| 604 // Check canceling removes the Omnibox url. |
| 605 GURL url("http://www.google.com/"); |
| 606 DummyPrerenderContents* prerender_contents = |
| 607 prerender_manager()->CreateNextPrerenderContents( |
| 608 url, ORIGIN_OMNIBOX, FINAL_STATUS_CANCELLED); |
| 609 EXPECT_TRUE(prerender_manager()->AddPrerenderFromOmnibox(url, NULL)); |
| 610 EXPECT_TRUE(prerender_contents->has_started()); |
| 611 prerender_manager()->CancelOmniboxPrerenders(); |
| 612 const DummyPrerenderContents* null = NULL; |
| 613 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
| 614 } |
| 615 |
| 616 TEST_F(PrerenderTest, CancelOmniboxDoesNotRemoveLinkTest) { |
| 617 GURL url("http://www.google.com/"); |
| 618 DummyPrerenderContents* prerender_contents = |
| 619 prerender_manager()->CreateNextPrerenderContents( |
| 620 url, ORIGIN_LINK_REL_PRERENDER, FINAL_STATUS_MANAGER_SHUTDOWN); |
| 621 EXPECT_TRUE(AddSimplePrerender(url)); |
| 622 EXPECT_TRUE(prerender_contents->has_started()); |
| 623 prerender_manager()->CancelOmniboxPrerenders(); |
| 624 const DummyPrerenderContents* null = NULL; |
| 625 EXPECT_NE(null, prerender_manager()->FindEntry(url)); |
| 626 } |
| 627 |
| 628 TEST_F(PrerenderTest, OmniboxNotAllowedWhenDisabled) { |
| 629 prerender_manager()->set_enabled(false); |
| 630 EXPECT_FALSE(prerender_manager()->AddPrerenderFromOmnibox( |
| 631 GURL("http://www.example.com"), NULL)); |
| 632 } |
| 633 |
| 634 TEST_F(PrerenderTest, LinkRelNotAllowedWhenDisabled) { |
| 635 prerender_manager()->set_enabled(false); |
| 636 EXPECT_FALSE(AddSimplePrerender( |
| 637 GURL("http://www.example.com"))); |
| 638 } |
| 639 |
| 640 TEST_F(PrerenderTest, LinkManagerCancel) { |
| 641 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 642 GURL url("http://www.myexample.com"); |
| 643 DummyPrerenderContents* prerender_contents = |
| 644 prerender_manager()->CreateNextPrerenderContents( |
| 645 url, FINAL_STATUS_CANCELLED); |
| 646 |
| 647 EXPECT_TRUE(AddSimplePrerender(url)); |
| 648 |
| 649 EXPECT_TRUE(prerender_contents->has_started()); |
| 650 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 651 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 652 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); |
| 653 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
| 654 last_prerender_id()); |
| 655 |
| 656 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
| 657 DummyPrerenderContents* null = NULL; |
| 658 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
| 659 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 660 } |
| 661 |
| 662 TEST_F(PrerenderTest, LinkManagerCancelThenAbandon) { |
| 663 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 664 GURL url("http://www.myexample.com"); |
| 665 DummyPrerenderContents* prerender_contents = |
| 666 prerender_manager()->CreateNextPrerenderContents( |
| 667 url, FINAL_STATUS_CANCELLED); |
| 668 |
| 669 EXPECT_TRUE(AddSimplePrerender(url)); |
| 670 |
| 671 EXPECT_TRUE(prerender_contents->has_started()); |
| 672 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 673 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 674 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); |
| 675 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
| 676 last_prerender_id()); |
| 677 |
| 678 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 679 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
| 680 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, |
| 681 last_prerender_id()); |
| 682 |
| 683 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 684 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
| 685 DummyPrerenderContents* null = NULL; |
| 686 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
| 687 } |
| 688 |
| 689 // TODO(gavinp): Update this test after abandon has an effect on Prerenders, |
| 690 // like shortening the timeouts. |
| 691 TEST_F(PrerenderTest, LinkManagerAbandon) { |
| 692 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 693 GURL url("http://www.myexample.com"); |
| 694 DummyPrerenderContents* prerender_contents = |
| 695 prerender_manager()->CreateNextPrerenderContents( |
| 696 url, FINAL_STATUS_USED); |
| 697 |
| 698 EXPECT_TRUE(AddSimplePrerender(url)); |
| 699 |
| 700 EXPECT_TRUE(prerender_contents->has_started()); |
| 701 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 702 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 703 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); |
| 704 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, |
| 705 last_prerender_id()); |
| 706 |
| 707 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 708 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
| 709 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 710 } |
| 711 |
| 712 TEST_F(PrerenderTest, LinkManagerCancelTwice) { |
| 713 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 714 GURL url("http://www.myexample.com"); |
| 715 DummyPrerenderContents* prerender_contents = |
| 716 prerender_manager()->CreateNextPrerenderContents( |
| 717 url, FINAL_STATUS_CANCELLED); |
| 718 |
| 719 EXPECT_TRUE(AddSimplePrerender(url)); |
| 720 EXPECT_TRUE(prerender_contents->has_started()); |
| 721 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 722 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 723 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
| 724 last_prerender_id()); |
| 725 |
| 726 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 727 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
| 728 DummyPrerenderContents* null = NULL; |
| 729 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
| 730 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
| 731 last_prerender_id()); |
| 732 } |
| 733 |
| 734 TEST_F(PrerenderTest, LinkManagerAddTwiceCancelTwice) { |
| 735 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 736 GURL url("http://www.myexample.com"); |
| 737 DummyPrerenderContents* prerender_contents = |
| 738 prerender_manager()->CreateNextPrerenderContents( |
| 739 url, FINAL_STATUS_CANCELLED); |
| 740 |
| 741 EXPECT_TRUE(AddSimplePrerender(url)); |
| 742 |
| 743 const int first_prerender_id = last_prerender_id(); |
| 744 EXPECT_TRUE(prerender_contents->has_started()); |
| 745 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 746 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 747 EXPECT_TRUE(AddSimplePrerender(url)); |
| 748 |
| 749 const int second_prerender_id = last_prerender_id(); |
| 750 EXPECT_TRUE(prerender_contents->has_started()); |
| 751 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 752 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 753 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
| 754 first_prerender_id); |
| 755 |
| 756 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 757 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 758 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
| 759 second_prerender_id); |
| 760 |
| 761 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 762 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
| 763 DummyPrerenderContents* null = NULL; |
| 764 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
| 765 } |
| 766 |
| 767 TEST_F(PrerenderTest, LinkManagerAddTwiceCancelTwiceThenAbandonTwice) { |
| 768 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 769 GURL url("http://www.myexample.com"); |
| 770 DummyPrerenderContents* prerender_contents = |
| 771 prerender_manager()->CreateNextPrerenderContents( |
| 772 url, FINAL_STATUS_CANCELLED); |
| 773 |
| 774 EXPECT_TRUE(AddSimplePrerender(url)); |
| 775 |
| 776 const int first_prerender_id = last_prerender_id(); |
| 777 EXPECT_TRUE(prerender_contents->has_started()); |
| 778 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 779 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 780 EXPECT_TRUE(AddSimplePrerender(url)); |
| 781 |
| 782 const int second_prerender_id = last_prerender_id(); |
| 783 EXPECT_TRUE(prerender_contents->has_started()); |
| 784 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 785 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 786 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
| 787 first_prerender_id); |
| 788 |
| 789 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 790 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 791 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
| 792 second_prerender_id); |
| 793 |
| 794 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 795 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
| 796 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, |
| 797 first_prerender_id); |
| 798 |
| 799 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 800 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
| 801 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, |
| 802 second_prerender_id); |
| 803 |
| 804 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 805 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); |
| 806 DummyPrerenderContents* null = NULL; |
| 807 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
| 808 } |
| 809 |
| 810 // TODO(gavinp): Update this test after abandon has an effect on Prerenders, |
| 811 // like shortening the timeouts. |
| 812 TEST_F(PrerenderTest, LinkManagerAddTwiceAbandonTwice) { |
| 813 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 814 GURL url("http://www.myexample.com"); |
| 815 DummyPrerenderContents* prerender_contents = |
| 816 prerender_manager()->CreateNextPrerenderContents( |
| 817 url, FINAL_STATUS_USED); |
| 818 |
| 819 EXPECT_TRUE(AddSimplePrerender(url)); |
| 820 |
| 821 const int first_prerender_id = last_prerender_id(); |
| 822 EXPECT_TRUE(prerender_contents->has_started()); |
| 823 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 824 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 825 EXPECT_TRUE(AddSimplePrerender(url)); |
| 826 |
| 827 const int second_prerender_id = last_prerender_id(); |
| 828 EXPECT_TRUE(prerender_contents->has_started()); |
| 829 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 830 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 831 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, |
| 832 first_prerender_id); |
| 833 |
| 834 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 835 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 836 prerender_link_manager()->OnAbandonPrerender(kDefaultChildId, |
| 837 second_prerender_id); |
| 838 |
| 839 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 840 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 841 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
| 842 } |
| 843 |
| 844 // TODO(gavinp): After abandon shortens the expire time on a Prerender, |
| 845 // add a series of tests testing advancing the time by either the abandon |
| 846 // or normal expire, and verifying the expected behaviour with groups |
| 847 // of links. |
| 848 TEST_F(PrerenderTest, LinkManagerExpireThenCancel) { |
| 849 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 850 GURL url("http://www.myexample.com"); |
| 851 DummyPrerenderContents* prerender_contents = |
| 852 prerender_manager()->CreateNextPrerenderContents( |
| 853 url, FINAL_STATUS_TIMED_OUT); |
| 854 |
| 855 EXPECT_TRUE(AddSimplePrerender(url)); |
| 856 |
| 857 EXPECT_TRUE(prerender_contents->has_started()); |
| 858 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); |
| 859 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); |
| 860 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + |
| 861 base::TimeDelta::FromSeconds(1)); |
| 862 |
| 863 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); |
| 864 DummyPrerenderContents* null = NULL; |
| 865 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
| 866 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
| 867 last_prerender_id()); |
| 868 |
| 869 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 870 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
| 871 } |
| 872 |
| 873 TEST_F(PrerenderTest, LinkManagerExpireThenAddAgain) { |
| 874 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 875 GURL url("http://www.myexample.com"); |
| 876 DummyPrerenderContents* first_prerender_contents = |
| 877 prerender_manager()->CreateNextPrerenderContents( |
| 878 url, FINAL_STATUS_TIMED_OUT); |
| 879 EXPECT_TRUE(AddSimplePrerender(url)); |
| 880 EXPECT_TRUE(first_prerender_contents->has_started()); |
| 881 EXPECT_FALSE(first_prerender_contents->prerendering_has_been_cancelled()); |
| 882 ASSERT_EQ(first_prerender_contents, prerender_manager()->FindEntry(url)); |
| 883 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + |
| 884 base::TimeDelta::FromSeconds(1)); |
| 885 DummyPrerenderContents* null = NULL; |
| 886 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
| 887 DummyPrerenderContents* second_prerender_contents = |
| 888 prerender_manager()->CreateNextPrerenderContents( |
| 889 url, FINAL_STATUS_USED); |
| 890 EXPECT_TRUE(AddSimplePrerender(url)); |
| 891 EXPECT_TRUE(second_prerender_contents->has_started()); |
| 892 ASSERT_EQ(second_prerender_contents, prerender_manager()->GetEntry(url)); |
| 893 // The PrerenderLinkManager is not empty since we never removed the first |
| 894 // prerender. |
| 895 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); |
| 896 } |
| 897 |
| 898 TEST_F(PrerenderTest, LinkManagerCancelThenAddAgain) { |
| 899 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 900 GURL url("http://www.myexample.com"); |
| 901 DummyPrerenderContents* first_prerender_contents = |
| 902 prerender_manager()->CreateNextPrerenderContents( |
| 903 url, FINAL_STATUS_CANCELLED); |
| 904 EXPECT_TRUE(AddSimplePrerender(url)); |
| 905 EXPECT_TRUE(first_prerender_contents->has_started()); |
| 906 EXPECT_FALSE(first_prerender_contents->prerendering_has_been_cancelled()); |
| 907 ASSERT_EQ(first_prerender_contents, prerender_manager()->FindEntry(url)); |
| 908 prerender_link_manager()->OnCancelPrerender(kDefaultChildId, |
| 909 last_prerender_id()); |
| 910 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); |
| 911 EXPECT_TRUE(first_prerender_contents->prerendering_has_been_cancelled()); |
| 912 DummyPrerenderContents* null = NULL; |
| 913 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
| 914 DummyPrerenderContents* second_prerender_contents = |
| 915 prerender_manager()->CreateNextPrerenderContents( |
| 916 url, FINAL_STATUS_USED); |
| 917 EXPECT_TRUE(AddSimplePrerender(url)); |
| 918 EXPECT_TRUE(second_prerender_contents->has_started()); |
| 919 ASSERT_EQ(second_prerender_contents, prerender_manager()->GetEntry(url)); |
| 920 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); |
| 921 } |
| 922 |
| 923 } // namespace prerender |
| 924 |
OLD | NEW |