| 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_manager.h" | |
| 11 #include "chrome/browser/prerender/prerender_origin.h" | |
| 12 #include "chrome/common/chrome_switches.h" | |
| 13 #include "chrome/test/base/testing_browser_process.h" | |
| 14 #include "chrome/test/base/testing_profile.h" | |
| 15 #include "content/public/browser/render_view_host.h" | |
| 16 #include "content/test/test_browser_thread.h" | |
| 17 #include "googleurl/src/gurl.h" | |
| 18 #include "testing/gtest/include/gtest/gtest.h" | |
| 19 | |
| 20 using content::BrowserThread; | |
| 21 | |
| 22 namespace prerender { | |
| 23 | |
| 24 namespace { | |
| 25 | |
| 26 class DummyPrerenderContents : public PrerenderContents { | |
| 27 public: | |
| 28 DummyPrerenderContents(PrerenderManager* prerender_manager, | |
| 29 PrerenderTracker* prerender_tracker, | |
| 30 const GURL& url, | |
| 31 Origin origin, | |
| 32 FinalStatus expected_final_status) | |
| 33 : PrerenderContents(prerender_manager, prerender_tracker, | |
| 34 NULL, url, content::Referrer(), | |
| 35 origin, PrerenderManager::kNoExperiment), | |
| 36 has_started_(false), | |
| 37 expected_final_status_(expected_final_status) { | |
| 38 } | |
| 39 | |
| 40 virtual ~DummyPrerenderContents() { | |
| 41 EXPECT_EQ(expected_final_status_, final_status()); | |
| 42 } | |
| 43 | |
| 44 virtual void StartPrerendering( | |
| 45 const content::RenderViewHost* source_render_view_host, | |
| 46 content::SessionStorageNamespace* session_storage_namespace) OVERRIDE { | |
| 47 has_started_ = true; | |
| 48 } | |
| 49 | |
| 50 virtual bool GetChildId(int* child_id) const OVERRIDE { | |
| 51 *child_id = 0; | |
| 52 return true; | |
| 53 } | |
| 54 | |
| 55 virtual bool GetRouteId(int* route_id) const OVERRIDE { | |
| 56 *route_id = 0; | |
| 57 return true; | |
| 58 } | |
| 59 | |
| 60 bool has_started() const { return has_started_; } | |
| 61 | |
| 62 FinalStatus expected_final_status() const { return expected_final_status_; } | |
| 63 | |
| 64 private: | |
| 65 bool has_started_; | |
| 66 FinalStatus expected_final_status_; | |
| 67 }; | |
| 68 | |
| 69 class TestPrerenderManager : public PrerenderManager { | |
| 70 public: | |
| 71 explicit TestPrerenderManager(PrerenderTracker* prerender_tracker) | |
| 72 : PrerenderManager(&profile_, prerender_tracker), | |
| 73 time_(base::Time::Now()), | |
| 74 time_ticks_(base::TimeTicks::Now()), | |
| 75 next_prerender_contents_(NULL), | |
| 76 prerender_tracker_(prerender_tracker) { | |
| 77 set_rate_limit_enabled(false); | |
| 78 } | |
| 79 | |
| 80 virtual ~TestPrerenderManager() { | |
| 81 if (next_prerender_contents()) { | |
| 82 next_prerender_contents_.release()->Destroy( | |
| 83 FINAL_STATUS_MANAGER_SHUTDOWN); | |
| 84 } | |
| 85 // Set the final status for all PrerenderContents with an expected final | |
| 86 // status of FINAL_STATUS_USED. These values are normally set when the | |
| 87 // prerendered RVH is swapped into a tab, which doesn't happen in these | |
| 88 // unit tests. | |
| 89 for (ScopedVector<PrerenderContents>::iterator it = | |
| 90 used_prerender_contents_.begin(); | |
| 91 it != used_prerender_contents_.end(); ++it) { | |
| 92 (*it)->set_final_status(FINAL_STATUS_USED); | |
| 93 } | |
| 94 DoShutdown(); | |
| 95 } | |
| 96 | |
| 97 void AdvanceTime(base::TimeDelta delta) { | |
| 98 time_ += delta; | |
| 99 } | |
| 100 | |
| 101 void AdvanceTimeTicks(base::TimeDelta delta) { | |
| 102 time_ticks_ += delta; | |
| 103 } | |
| 104 | |
| 105 DummyPrerenderContents* CreateNextPrerenderContents( | |
| 106 const GURL& url, | |
| 107 FinalStatus expected_final_status) { | |
| 108 DummyPrerenderContents* prerender_contents = | |
| 109 new DummyPrerenderContents(this, prerender_tracker_, url, | |
| 110 ORIGIN_LINK_REL_PRERENDER, | |
| 111 expected_final_status); | |
| 112 SetNextPrerenderContents(prerender_contents); | |
| 113 return prerender_contents; | |
| 114 } | |
| 115 | |
| 116 DummyPrerenderContents* CreateNextPrerenderContents( | |
| 117 const GURL& url, | |
| 118 Origin origin, | |
| 119 FinalStatus expected_final_status) { | |
| 120 DummyPrerenderContents* prerender_contents = | |
| 121 new DummyPrerenderContents(this, prerender_tracker_, url, | |
| 122 origin, expected_final_status); | |
| 123 SetNextPrerenderContents(prerender_contents); | |
| 124 return prerender_contents; | |
| 125 } | |
| 126 | |
| 127 DummyPrerenderContents* CreateNextPrerenderContents( | |
| 128 const GURL& url, | |
| 129 const std::vector<GURL>& alias_urls, | |
| 130 FinalStatus expected_final_status) { | |
| 131 DummyPrerenderContents* prerender_contents = | |
| 132 new DummyPrerenderContents(this, prerender_tracker_, url, | |
| 133 ORIGIN_LINK_REL_PRERENDER, | |
| 134 expected_final_status); | |
| 135 for (std::vector<GURL>::const_iterator it = alias_urls.begin(); | |
| 136 it != alias_urls.end(); | |
| 137 ++it) { | |
| 138 EXPECT_TRUE(prerender_contents->AddAliasURL(*it)); | |
| 139 } | |
| 140 SetNextPrerenderContents(prerender_contents); | |
| 141 return prerender_contents; | |
| 142 } | |
| 143 | |
| 144 // Shorthand to add a simple preload with a reasonable source. | |
| 145 bool AddSimplePrerender(const GURL& url) { | |
| 146 return AddPrerenderFromLinkRelPrerender(-1, -1, | |
| 147 url, | |
| 148 content::Referrer()); | |
| 149 } | |
| 150 | |
| 151 void set_rate_limit_enabled(bool enabled) { | |
| 152 mutable_config().rate_limit_enabled = enabled; | |
| 153 } | |
| 154 | |
| 155 PrerenderContents* next_prerender_contents() { | |
| 156 return next_prerender_contents_.get(); | |
| 157 } | |
| 158 | |
| 159 private: | |
| 160 void SetNextPrerenderContents(DummyPrerenderContents* prerender_contents) { | |
| 161 DCHECK(!next_prerender_contents_.get()); | |
| 162 next_prerender_contents_.reset(prerender_contents); | |
| 163 if (prerender_contents->expected_final_status() == FINAL_STATUS_USED) | |
| 164 used_prerender_contents_.push_back(prerender_contents); | |
| 165 } | |
| 166 | |
| 167 virtual base::Time GetCurrentTime() const OVERRIDE { | |
| 168 return time_; | |
| 169 } | |
| 170 | |
| 171 virtual base::TimeTicks GetCurrentTimeTicks() const OVERRIDE { | |
| 172 return time_ticks_; | |
| 173 } | |
| 174 | |
| 175 virtual PrerenderContents* CreatePrerenderContents( | |
| 176 const GURL& url, | |
| 177 const content::Referrer& referrer, | |
| 178 Origin origin, | |
| 179 uint8 experiment_id) OVERRIDE { | |
| 180 DCHECK(next_prerender_contents_.get()); | |
| 181 DCHECK_EQ(next_prerender_contents_->prerender_url(), url); | |
| 182 DCHECK_EQ(next_prerender_contents_->origin(), origin); | |
| 183 return next_prerender_contents_.release(); | |
| 184 } | |
| 185 | |
| 186 base::Time time_; | |
| 187 base::TimeTicks time_ticks_; | |
| 188 scoped_ptr<PrerenderContents> next_prerender_contents_; | |
| 189 // PrerenderContents with an |expected_final_status| of FINAL_STATUS_USED, | |
| 190 // tracked so they will be automatically deleted. | |
| 191 ScopedVector<PrerenderContents> used_prerender_contents_; | |
| 192 | |
| 193 PrerenderTracker* prerender_tracker_; | |
| 194 | |
| 195 TestingProfile profile_; | |
| 196 }; | |
| 197 | |
| 198 class RestorePrerenderMode { | |
| 199 public: | |
| 200 RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) { | |
| 201 } | |
| 202 | |
| 203 ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); } | |
| 204 private: | |
| 205 PrerenderManager::PrerenderManagerMode prev_mode_; | |
| 206 }; | |
| 207 | |
| 208 } // namespace | |
| 209 | |
| 210 class PrerenderManagerTest : public testing::Test { | |
| 211 public: | |
| 212 PrerenderManagerTest() : ui_thread_(BrowserThread::UI, &message_loop_), | |
| 213 prerender_manager_( | |
| 214 new TestPrerenderManager(prerender_tracker())) { | |
| 215 // Enable omnibox prerendering. | |
| 216 CommandLine::ForCurrentProcess()->AppendSwitchASCII( | |
| 217 switches::kPrerenderFromOmnibox, | |
| 218 switches::kPrerenderFromOmniboxSwitchValueEnabled); | |
| 219 } | |
| 220 | |
| 221 TestPrerenderManager* prerender_manager() { | |
| 222 return prerender_manager_.get(); | |
| 223 } | |
| 224 | |
| 225 private: | |
| 226 PrerenderTracker* prerender_tracker() { | |
| 227 return g_browser_process->prerender_tracker(); | |
| 228 } | |
| 229 | |
| 230 // Needed to pass PrerenderManager's DCHECKs. | |
| 231 MessageLoop message_loop_; | |
| 232 content::TestBrowserThread ui_thread_; | |
| 233 scoped_ptr<TestPrerenderManager> prerender_manager_; | |
| 234 }; | |
| 235 | |
| 236 TEST_F(PrerenderManagerTest, EmptyTest) { | |
| 237 EXPECT_FALSE(prerender_manager()->MaybeUsePrerenderedPage( | |
| 238 NULL, | |
| 239 GURL("http://www.google.com/"))); | |
| 240 } | |
| 241 | |
| 242 TEST_F(PrerenderManagerTest, FoundTest) { | |
| 243 GURL url("http://www.google.com/"); | |
| 244 DummyPrerenderContents* prerender_contents = | |
| 245 prerender_manager()->CreateNextPrerenderContents( | |
| 246 url, | |
| 247 FINAL_STATUS_USED); | |
| 248 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 249 EXPECT_TRUE(prerender_contents->has_started()); | |
| 250 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | |
| 251 } | |
| 252 | |
| 253 // Make sure that if queue a request, and a second prerender request for the | |
| 254 // same URL comes in, that we drop the second request and keep the first one. | |
| 255 TEST_F(PrerenderManagerTest, DropSecondRequestTest) { | |
| 256 GURL url("http://www.google.com/"); | |
| 257 DummyPrerenderContents* prerender_contents = | |
| 258 prerender_manager()->CreateNextPrerenderContents( | |
| 259 url, | |
| 260 FINAL_STATUS_USED); | |
| 261 DummyPrerenderContents* null = NULL; | |
| 262 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 263 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
| 264 EXPECT_TRUE(prerender_contents->has_started()); | |
| 265 | |
| 266 DummyPrerenderContents* prerender_contents1 = | |
| 267 prerender_manager()->CreateNextPrerenderContents( | |
| 268 url, | |
| 269 FINAL_STATUS_MANAGER_SHUTDOWN); | |
| 270 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url)); | |
| 271 EXPECT_EQ(prerender_contents1, | |
| 272 prerender_manager()->next_prerender_contents()); | |
| 273 EXPECT_FALSE(prerender_contents1->has_started()); | |
| 274 | |
| 275 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | |
| 276 } | |
| 277 | |
| 278 // Ensure that we expire a prerendered page after the max. permitted time. | |
| 279 TEST_F(PrerenderManagerTest, ExpireTest) { | |
| 280 GURL url("http://www.google.com/"); | |
| 281 DummyPrerenderContents* prerender_contents = | |
| 282 prerender_manager()->CreateNextPrerenderContents( | |
| 283 url, | |
| 284 FINAL_STATUS_TIMED_OUT); | |
| 285 DummyPrerenderContents* null = NULL; | |
| 286 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 287 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
| 288 EXPECT_TRUE(prerender_contents->has_started()); | |
| 289 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + | |
| 290 base::TimeDelta::FromSeconds(1)); | |
| 291 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
| 292 } | |
| 293 | |
| 294 // LRU Test. Make sure that if we prerender more than one request, that | |
| 295 // the oldest one will be dropped. | |
| 296 TEST_F(PrerenderManagerTest, DropOldestRequestTest) { | |
| 297 GURL url("http://www.google.com/"); | |
| 298 DummyPrerenderContents* prerender_contents = | |
| 299 prerender_manager()->CreateNextPrerenderContents( | |
| 300 url, | |
| 301 FINAL_STATUS_EVICTED); | |
| 302 DummyPrerenderContents* null = NULL; | |
| 303 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 304 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
| 305 EXPECT_TRUE(prerender_contents->has_started()); | |
| 306 | |
| 307 GURL url1("http://news.google.com/"); | |
| 308 DummyPrerenderContents* prerender_contents1 = | |
| 309 prerender_manager()->CreateNextPrerenderContents( | |
| 310 url1, | |
| 311 FINAL_STATUS_USED); | |
| 312 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1)); | |
| 313 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
| 314 EXPECT_TRUE(prerender_contents1->has_started()); | |
| 315 | |
| 316 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
| 317 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); | |
| 318 } | |
| 319 | |
| 320 // Two element prerender test. Ensure that the LRU operates correctly if we | |
| 321 // permit 2 elements to be kept prerendered. | |
| 322 TEST_F(PrerenderManagerTest, TwoElementPrerenderTest) { | |
| 323 prerender_manager()->mutable_config().max_elements = 2; | |
| 324 GURL url("http://www.google.com/"); | |
| 325 DummyPrerenderContents* prerender_contents = | |
| 326 prerender_manager()->CreateNextPrerenderContents( | |
| 327 url, | |
| 328 FINAL_STATUS_EVICTED); | |
| 329 DummyPrerenderContents* null = NULL; | |
| 330 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 331 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
| 332 EXPECT_TRUE(prerender_contents->has_started()); | |
| 333 | |
| 334 GURL url1("http://news.google.com/"); | |
| 335 DummyPrerenderContents* prerender_contents1 = | |
| 336 prerender_manager()->CreateNextPrerenderContents( | |
| 337 url1, | |
| 338 FINAL_STATUS_USED); | |
| 339 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1)); | |
| 340 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
| 341 EXPECT_TRUE(prerender_contents1->has_started()); | |
| 342 | |
| 343 GURL url2("http://images.google.com/"); | |
| 344 DummyPrerenderContents* prerender_contents2 = | |
| 345 prerender_manager()->CreateNextPrerenderContents( | |
| 346 url2, | |
| 347 FINAL_STATUS_USED); | |
| 348 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url2)); | |
| 349 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
| 350 EXPECT_TRUE(prerender_contents2->has_started()); | |
| 351 | |
| 352 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
| 353 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); | |
| 354 ASSERT_EQ(prerender_contents2, prerender_manager()->GetEntry(url2)); | |
| 355 } | |
| 356 | |
| 357 TEST_F(PrerenderManagerTest, AliasURLTest) { | |
| 358 GURL url("http://www.google.com/"); | |
| 359 GURL alias_url1("http://www.google.com/index.html"); | |
| 360 GURL alias_url2("http://google.com/"); | |
| 361 GURL not_an_alias_url("http://google.com/index.html"); | |
| 362 std::vector<GURL> alias_urls; | |
| 363 alias_urls.push_back(alias_url1); | |
| 364 alias_urls.push_back(alias_url2); | |
| 365 | |
| 366 // Test that all of the aliases work, but not_an_alias_url does not. | |
| 367 DummyPrerenderContents* prerender_contents = | |
| 368 prerender_manager()->CreateNextPrerenderContents( | |
| 369 url, alias_urls, FINAL_STATUS_USED); | |
| 370 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 371 ASSERT_EQ(NULL, prerender_manager()->GetEntry(not_an_alias_url)); | |
| 372 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url1)); | |
| 373 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | |
| 374 url, alias_urls, FINAL_STATUS_USED); | |
| 375 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 376 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url2)); | |
| 377 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | |
| 378 url, alias_urls, FINAL_STATUS_USED); | |
| 379 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 380 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | |
| 381 | |
| 382 // Test that alias URLs can not be added. | |
| 383 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | |
| 384 url, alias_urls, FINAL_STATUS_USED); | |
| 385 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 386 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url)); | |
| 387 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(alias_url1)); | |
| 388 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(alias_url2)); | |
| 389 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | |
| 390 } | |
| 391 | |
| 392 // Ensure that we ignore prerender requests within the rate limit. | |
| 393 TEST_F(PrerenderManagerTest, RateLimitInWindowTest) { | |
| 394 GURL url("http://www.google.com/"); | |
| 395 DummyPrerenderContents* prerender_contents = | |
| 396 prerender_manager()->CreateNextPrerenderContents( | |
| 397 url, | |
| 398 FINAL_STATUS_MANAGER_SHUTDOWN); | |
| 399 DummyPrerenderContents* null = NULL; | |
| 400 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 401 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
| 402 EXPECT_TRUE(prerender_contents->has_started()); | |
| 403 | |
| 404 prerender_manager()->set_rate_limit_enabled(true); | |
| 405 prerender_manager()->AdvanceTimeTicks(base::TimeDelta::FromMilliseconds(1)); | |
| 406 | |
| 407 GURL url1("http://news.google.com/"); | |
| 408 prerender_manager()->CreateNextPrerenderContents( | |
| 409 url, | |
| 410 FINAL_STATUS_MANAGER_SHUTDOWN); | |
| 411 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url1)); | |
| 412 prerender_manager()->set_rate_limit_enabled(false); | |
| 413 } | |
| 414 | |
| 415 // Ensure that we don't ignore prerender requests outside the rate limit. | |
| 416 TEST_F(PrerenderManagerTest, RateLimitOutsideWindowTest) { | |
| 417 GURL url("http://www.google.com/"); | |
| 418 DummyPrerenderContents* prerender_contents = | |
| 419 prerender_manager()->CreateNextPrerenderContents( | |
| 420 url, | |
| 421 FINAL_STATUS_EVICTED); | |
| 422 DummyPrerenderContents* null = NULL; | |
| 423 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 424 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
| 425 EXPECT_TRUE(prerender_contents->has_started()); | |
| 426 | |
| 427 prerender_manager()->set_rate_limit_enabled(true); | |
| 428 prerender_manager()->AdvanceTimeTicks( | |
| 429 base::TimeDelta::FromMilliseconds(2000)); | |
| 430 | |
| 431 GURL url1("http://news.google.com/"); | |
| 432 DummyPrerenderContents* rate_limit_prerender_contents = | |
| 433 prerender_manager()->CreateNextPrerenderContents( | |
| 434 url1, | |
| 435 FINAL_STATUS_MANAGER_SHUTDOWN); | |
| 436 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1)); | |
| 437 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | |
| 438 EXPECT_TRUE(rate_limit_prerender_contents->has_started()); | |
| 439 prerender_manager()->set_rate_limit_enabled(false); | |
| 440 } | |
| 441 | |
| 442 TEST_F(PrerenderManagerTest, PendingPrerenderTest) { | |
| 443 GURL url("http://www.google.com/"); | |
| 444 DummyPrerenderContents* prerender_contents = | |
| 445 prerender_manager()->CreateNextPrerenderContents( | |
| 446 url, | |
| 447 FINAL_STATUS_USED); | |
| 448 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 449 | |
| 450 int child_id; | |
| 451 int route_id; | |
| 452 ASSERT_TRUE(prerender_contents->GetChildId(&child_id)); | |
| 453 ASSERT_TRUE(prerender_contents->GetRouteId(&route_id)); | |
| 454 | |
| 455 GURL pending_url("http://news.google.com/"); | |
| 456 | |
| 457 EXPECT_TRUE(prerender_manager()->AddPrerenderFromLinkRelPrerender( | |
| 458 child_id, route_id, | |
| 459 pending_url, content::Referrer(url, WebKit::WebReferrerPolicyDefault))); | |
| 460 | |
| 461 EXPECT_TRUE(prerender_manager()->IsPendingEntry(pending_url)); | |
| 462 EXPECT_TRUE(prerender_contents->has_started()); | |
| 463 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | |
| 464 } | |
| 465 | |
| 466 // Tests that a PrerenderManager created for a browser session in the control | |
| 467 // group works as expected. | |
| 468 TEST_F(PrerenderManagerTest, ControlGroup) { | |
| 469 RestorePrerenderMode restore_prerender_mode; | |
| 470 PrerenderManager::SetMode( | |
| 471 PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP); | |
| 472 GURL url("http://www.google.com/"); | |
| 473 DummyPrerenderContents* prerender_contents = | |
| 474 prerender_manager()->CreateNextPrerenderContents( | |
| 475 url, | |
| 476 FINAL_STATUS_MANAGER_SHUTDOWN); | |
| 477 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 478 EXPECT_FALSE(prerender_contents->has_started()); | |
| 479 } | |
| 480 | |
| 481 // Tests that prerendering is cancelled when the source render view does not | |
| 482 // exist. On failure, the DCHECK in CreatePrerenderContents() above should be | |
| 483 // triggered. | |
| 484 TEST_F(PrerenderManagerTest, SourceRenderViewClosed) { | |
| 485 GURL url("http://www.google.com/"); | |
| 486 prerender_manager()->CreateNextPrerenderContents( | |
| 487 url, | |
| 488 FINAL_STATUS_MANAGER_SHUTDOWN); | |
| 489 EXPECT_FALSE(prerender_manager()->AddPrerenderFromLinkRelPrerender( | |
| 490 100, 100, url, content::Referrer())); | |
| 491 } | |
| 492 | |
| 493 // Tests that the prerender manager ignores fragment references when matching | |
| 494 // prerender URLs in the case the fragment is not in the prerender URL. | |
| 495 TEST_F(PrerenderManagerTest, PageMatchesFragmentTest) { | |
| 496 GURL url("http://www.google.com/"); | |
| 497 GURL fragment_url("http://www.google.com/#test"); | |
| 498 | |
| 499 DummyPrerenderContents* prerender_contents = | |
| 500 prerender_manager()->CreateNextPrerenderContents(url, | |
| 501 FINAL_STATUS_USED); | |
| 502 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 503 EXPECT_TRUE(prerender_contents->has_started()); | |
| 504 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(fragment_url)); | |
| 505 } | |
| 506 | |
| 507 // Tests that the prerender manager ignores fragment references when matching | |
| 508 // prerender URLs in the case the fragment is in the prerender URL. | |
| 509 TEST_F(PrerenderManagerTest, FragmentMatchesPageTest) { | |
| 510 GURL url("http://www.google.com/"); | |
| 511 GURL fragment_url("http://www.google.com/#test"); | |
| 512 | |
| 513 DummyPrerenderContents* prerender_contents = | |
| 514 prerender_manager()->CreateNextPrerenderContents(fragment_url, | |
| 515 FINAL_STATUS_USED); | |
| 516 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(fragment_url)); | |
| 517 EXPECT_TRUE(prerender_contents->has_started()); | |
| 518 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | |
| 519 } | |
| 520 | |
| 521 // Tests that the prerender manager ignores fragment references when matching | |
| 522 // prerender URLs in the case the fragment is in both URLs. | |
| 523 TEST_F(PrerenderManagerTest, FragmentMatchesFragmentTest) { | |
| 524 GURL fragment_url("http://www.google.com/#test"); | |
| 525 GURL other_fragment_url("http://www.google.com/#other_test"); | |
| 526 | |
| 527 DummyPrerenderContents* prerender_contents = | |
| 528 prerender_manager()->CreateNextPrerenderContents(fragment_url, | |
| 529 FINAL_STATUS_USED); | |
| 530 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(fragment_url)); | |
| 531 EXPECT_TRUE(prerender_contents->has_started()); | |
| 532 ASSERT_EQ(prerender_contents, | |
| 533 prerender_manager()->GetEntry(other_fragment_url)); | |
| 534 } | |
| 535 | |
| 536 // Make sure that clearing works as expected. | |
| 537 TEST_F(PrerenderManagerTest, ClearTest) { | |
| 538 GURL url("http://www.google.com/"); | |
| 539 DummyPrerenderContents* prerender_contents = | |
| 540 prerender_manager()->CreateNextPrerenderContents( | |
| 541 url, | |
| 542 FINAL_STATUS_CACHE_OR_HISTORY_CLEARED); | |
| 543 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 544 EXPECT_TRUE(prerender_contents->has_started()); | |
| 545 prerender_manager()->ClearData(PrerenderManager::CLEAR_PRERENDER_CONTENTS); | |
| 546 DummyPrerenderContents* null = NULL; | |
| 547 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | |
| 548 } | |
| 549 | |
| 550 // Make sure canceling works as expected. | |
| 551 TEST_F(PrerenderManagerTest, CancelAllTest) { | |
| 552 GURL url("http://www.google.com/"); | |
| 553 DummyPrerenderContents* prerender_contents = | |
| 554 prerender_manager()->CreateNextPrerenderContents( | |
| 555 url, FINAL_STATUS_CANCELLED); | |
| 556 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 557 EXPECT_TRUE(prerender_contents->has_started()); | |
| 558 prerender_manager()->CancelAllPrerenders(); | |
| 559 const DummyPrerenderContents* null = NULL; | |
| 560 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | |
| 561 } | |
| 562 | |
| 563 // Make sure canceling for omnibox works as expected. | |
| 564 TEST_F(PrerenderManagerTest, CancelOmniboxRemovesOmniboxTest) { | |
| 565 // Check canceling removes the Omnibox url. | |
| 566 GURL url("http://www.google.com/"); | |
| 567 DummyPrerenderContents* prerender_contents = | |
| 568 prerender_manager()->CreateNextPrerenderContents( | |
| 569 url, ORIGIN_OMNIBOX, FINAL_STATUS_CANCELLED); | |
| 570 EXPECT_TRUE(prerender_manager()->AddPrerenderFromOmnibox(url, NULL)); | |
| 571 EXPECT_TRUE(prerender_contents->has_started()); | |
| 572 prerender_manager()->CancelOmniboxPrerenders(); | |
| 573 const DummyPrerenderContents* null = NULL; | |
| 574 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | |
| 575 } | |
| 576 | |
| 577 TEST_F(PrerenderManagerTest, CancelOmniboxDoesNotRemoveLinkTest) { | |
| 578 GURL url("http://www.google.com/"); | |
| 579 DummyPrerenderContents* prerender_contents = | |
| 580 prerender_manager()->CreateNextPrerenderContents( | |
| 581 url, ORIGIN_LINK_REL_PRERENDER, FINAL_STATUS_MANAGER_SHUTDOWN); | |
| 582 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | |
| 583 EXPECT_TRUE(prerender_contents->has_started()); | |
| 584 prerender_manager()->CancelOmniboxPrerenders(); | |
| 585 const DummyPrerenderContents* null = NULL; | |
| 586 EXPECT_NE(null, prerender_manager()->FindEntry(url)); | |
| 587 } | |
| 588 | |
| 589 TEST_F(PrerenderManagerTest, OmniboxNotAllowedWhenDisabled) { | |
| 590 prerender_manager()->set_enabled(false); | |
| 591 EXPECT_FALSE(prerender_manager()->AddPrerenderFromOmnibox( | |
| 592 GURL("http://www.example.com"), NULL)); | |
| 593 } | |
| 594 | |
| 595 TEST_F(PrerenderManagerTest, LinkRelNotAllowedWhenDisabled) { | |
| 596 prerender_manager()->set_enabled(false); | |
| 597 EXPECT_FALSE(prerender_manager()->AddSimplePrerender( | |
| 598 GURL("http://www.example.com"))); | |
| 599 } | |
| 600 | |
| 601 } // namespace prerender | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 9875026:
**NOTFORLANDING** New link rel=prerender API (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src