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 |