OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/command_line.h" | 5 #include "base/command_line.h" |
6 #include "base/memory/scoped_vector.h" | 6 #include "base/memory/scoped_vector.h" |
7 #include "base/message_loop.h" | 7 #include "base/message_loop.h" |
8 #include "base/time.h" | 8 #include "base/time.h" |
9 #include "chrome/browser/prerender/prerender_contents.h" | 9 #include "chrome/browser/prerender/prerender_contents.h" |
10 #include "chrome/browser/prerender/prerender_link_manager.h" | |
10 #include "chrome/browser/prerender/prerender_manager.h" | 11 #include "chrome/browser/prerender/prerender_manager.h" |
11 #include "chrome/browser/prerender/prerender_origin.h" | 12 #include "chrome/browser/prerender/prerender_origin.h" |
12 #include "chrome/common/chrome_switches.h" | 13 #include "chrome/common/chrome_switches.h" |
13 #include "chrome/test/base/testing_browser_process.h" | 14 #include "chrome/test/base/testing_browser_process.h" |
14 #include "chrome/test/base/testing_profile.h" | 15 #include "chrome/test/base/testing_profile.h" |
15 #include "content/public/browser/render_view_host.h" | 16 #include "content/public/browser/render_view_host.h" |
16 #include "content/test/test_browser_thread.h" | 17 #include "content/test/test_browser_thread.h" |
17 #include "googleurl/src/gurl.h" | 18 #include "googleurl/src/gurl.h" |
18 #include "testing/gtest/include/gtest/gtest.h" | 19 #include "testing/gtest/include/gtest/gtest.h" |
20 #include "ui/gfx/size.h" | |
19 | 21 |
20 using content::BrowserThread; | 22 using content::BrowserThread; |
21 | 23 |
22 namespace prerender { | 24 namespace prerender { |
23 | 25 |
24 namespace { | 26 namespace { |
25 | 27 |
26 class DummyPrerenderContents : public PrerenderContents { | 28 class DummyPrerenderContents : public PrerenderContents { |
27 public: | 29 public: |
28 DummyPrerenderContents(PrerenderManager* prerender_manager, | 30 DummyPrerenderContents(PrerenderManager* prerender_manager, |
(...skipping 25 matching lines...) Expand all Loading... | |
54 | 56 |
55 virtual bool GetRouteId(int* route_id) const OVERRIDE { | 57 virtual bool GetRouteId(int* route_id) const OVERRIDE { |
56 *route_id = 0; | 58 *route_id = 0; |
57 return true; | 59 return true; |
58 } | 60 } |
59 | 61 |
60 bool has_started() const { return has_started_; } | 62 bool has_started() const { return has_started_; } |
61 | 63 |
62 FinalStatus expected_final_status() const { return expected_final_status_; } | 64 FinalStatus expected_final_status() const { return expected_final_status_; } |
63 | 65 |
66 bool prerendering_has_been_cancelled() const { | |
67 return PrerenderContents::prerendering_has_been_cancelled(); | |
68 } | |
69 | |
64 private: | 70 private: |
65 bool has_started_; | 71 bool has_started_; |
66 FinalStatus expected_final_status_; | 72 FinalStatus expected_final_status_; |
67 }; | 73 }; |
68 | 74 |
69 class TestPrerenderManager : public PrerenderManager { | 75 class TestPrerenderManager : public PrerenderManager { |
70 public: | 76 public: |
71 explicit TestPrerenderManager(PrerenderTracker* prerender_tracker) | 77 explicit TestPrerenderManager(PrerenderTracker* prerender_tracker) |
72 : PrerenderManager(&profile_, prerender_tracker), | 78 : PrerenderManager(&profile_, prerender_tracker), |
73 time_(base::Time::Now()), | 79 time_(base::Time::Now()), |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
134 expected_final_status); | 140 expected_final_status); |
135 for (std::vector<GURL>::const_iterator it = alias_urls.begin(); | 141 for (std::vector<GURL>::const_iterator it = alias_urls.begin(); |
136 it != alias_urls.end(); | 142 it != alias_urls.end(); |
137 ++it) { | 143 ++it) { |
138 EXPECT_TRUE(prerender_contents->AddAliasURL(*it)); | 144 EXPECT_TRUE(prerender_contents->AddAliasURL(*it)); |
139 } | 145 } |
140 SetNextPrerenderContents(prerender_contents); | 146 SetNextPrerenderContents(prerender_contents); |
141 return prerender_contents; | 147 return prerender_contents; |
142 } | 148 } |
143 | 149 |
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) { | 150 void set_rate_limit_enabled(bool enabled) { |
152 mutable_config().rate_limit_enabled = enabled; | 151 mutable_config().rate_limit_enabled = enabled; |
153 } | 152 } |
154 | 153 |
155 PrerenderContents* next_prerender_contents() { | 154 PrerenderContents* next_prerender_contents() { |
156 return next_prerender_contents_.get(); | 155 return next_prerender_contents_.get(); |
157 } | 156 } |
158 | 157 |
159 private: | 158 private: |
160 void SetNextPrerenderContents(DummyPrerenderContents* prerender_contents) { | 159 void SetNextPrerenderContents(DummyPrerenderContents* prerender_contents) { |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
200 RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) { | 199 RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) { |
201 } | 200 } |
202 | 201 |
203 ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); } | 202 ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); } |
204 private: | 203 private: |
205 PrerenderManager::PrerenderManagerMode prev_mode_; | 204 PrerenderManager::PrerenderManagerMode prev_mode_; |
206 }; | 205 }; |
207 | 206 |
208 } // namespace | 207 } // namespace |
209 | 208 |
210 class PrerenderManagerTest : public testing::Test { | 209 class PrerenderTest : public testing::Test { |
211 public: | 210 public: |
212 PrerenderManagerTest() : ui_thread_(BrowserThread::UI, &message_loop_), | 211 static const int kDefaultChildId = -1; |
213 prerender_manager_( | 212 static const int kDefaultRenderViewRouteId = -1; |
214 new TestPrerenderManager(prerender_tracker())) { | 213 |
214 PrerenderTest() : ui_thread_(BrowserThread::UI, &message_loop_), | |
215 prerender_manager_( | |
216 new TestPrerenderManager(prerender_tracker())), | |
217 prerender_link_manager_( | |
218 new PrerenderLinkManager(prerender_manager_.get())), | |
219 last_prerender_id_(0) { | |
215 // Enable omnibox prerendering. | 220 // Enable omnibox prerendering. |
216 CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 221 CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
217 switches::kPrerenderFromOmnibox, | 222 switches::kPrerenderFromOmnibox, |
218 switches::kPrerenderFromOmniboxSwitchValueEnabled); | 223 switches::kPrerenderFromOmniboxSwitchValueEnabled); |
219 } | 224 } |
220 | 225 |
221 TestPrerenderManager* prerender_manager() { | 226 TestPrerenderManager* prerender_manager() { |
222 return prerender_manager_.get(); | 227 return prerender_manager_.get(); |
223 } | 228 } |
224 | 229 |
230 PrerenderLinkManager* prerender_link_manager() { | |
231 return prerender_link_manager_.get(); | |
232 } | |
233 | |
234 bool IsEmptyPrerenderLinkManager() { | |
235 return prerender_link_manager_->IsEmpty(); | |
236 } | |
237 | |
238 int last_prerender_id() const { | |
239 return last_prerender_id_; | |
240 } | |
241 | |
242 // Shorthand to add a simple preload with a reasonable source. | |
243 bool AddSimplePrerender(const GURL& url) { | |
244 return prerender_link_manager()->OnAddPrerender(kDefaultChildId, | |
245 GetNextPrerenderID(), | |
246 url, | |
247 content::Referrer(), | |
248 gfx::Size(0, 0), | |
249 kDefaultRenderViewRouteId); | |
250 } | |
251 | |
225 private: | 252 private: |
253 int GetNextPrerenderID() { | |
dominich
2012/04/27 21:52:01
does this method even need to exist?
gavinp
2012/04/27 23:31:45
No, done.
| |
254 return ++last_prerender_id_; | |
255 } | |
256 | |
226 PrerenderTracker* prerender_tracker() { | 257 PrerenderTracker* prerender_tracker() { |
227 return g_browser_process->prerender_tracker(); | 258 return g_browser_process->prerender_tracker(); |
228 } | 259 } |
229 | 260 |
230 // Needed to pass PrerenderManager's DCHECKs. | 261 // Needed to pass PrerenderManager's DCHECKs. |
231 MessageLoop message_loop_; | 262 MessageLoop message_loop_; |
232 content::TestBrowserThread ui_thread_; | 263 content::TestBrowserThread ui_thread_; |
233 scoped_ptr<TestPrerenderManager> prerender_manager_; | 264 scoped_ptr<TestPrerenderManager> prerender_manager_; |
265 scoped_ptr<PrerenderLinkManager> prerender_link_manager_; | |
266 int last_prerender_id_; | |
234 }; | 267 }; |
235 | 268 |
236 TEST_F(PrerenderManagerTest, EmptyTest) { | 269 TEST_F(PrerenderTest, EmptyTest) { |
237 EXPECT_FALSE(prerender_manager()->MaybeUsePrerenderedPage( | 270 EXPECT_FALSE(prerender_manager()->MaybeUsePrerenderedPage( |
238 NULL, | 271 NULL, |
239 GURL("http://www.google.com/"))); | 272 GURL("http://www.google.com/"))); |
240 } | 273 } |
241 | 274 |
242 TEST_F(PrerenderManagerTest, FoundTest) { | 275 TEST_F(PrerenderTest, FoundTest) { |
243 GURL url("http://www.google.com/"); | 276 GURL url("http://www.google.com/"); |
244 DummyPrerenderContents* prerender_contents = | 277 DummyPrerenderContents* prerender_contents = |
245 prerender_manager()->CreateNextPrerenderContents( | 278 prerender_manager()->CreateNextPrerenderContents( |
246 url, | 279 url, |
247 FINAL_STATUS_USED); | 280 FINAL_STATUS_USED); |
248 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 281 EXPECT_TRUE(AddSimplePrerender(url)); |
249 EXPECT_TRUE(prerender_contents->has_started()); | 282 EXPECT_TRUE(prerender_contents->has_started()); |
250 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 283 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
251 } | 284 } |
252 | 285 |
253 // Make sure that if queue a request, and a second prerender request for the | 286 // 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. | 287 // same URL comes in, that we drop the second request and keep the first one. |
255 TEST_F(PrerenderManagerTest, DropSecondRequestTest) { | 288 TEST_F(PrerenderTest, DropSecondRequestTest) { |
256 GURL url("http://www.google.com/"); | 289 GURL url("http://www.google.com/"); |
257 DummyPrerenderContents* prerender_contents = | 290 DummyPrerenderContents* prerender_contents = |
258 prerender_manager()->CreateNextPrerenderContents( | 291 prerender_manager()->CreateNextPrerenderContents( |
259 url, | 292 url, |
260 FINAL_STATUS_USED); | 293 FINAL_STATUS_USED); |
261 DummyPrerenderContents* null = NULL; | 294 DummyPrerenderContents* null = NULL; |
262 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 295 EXPECT_TRUE(AddSimplePrerender(url)); |
263 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 296 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
264 EXPECT_TRUE(prerender_contents->has_started()); | 297 EXPECT_TRUE(prerender_contents->has_started()); |
265 | 298 |
266 DummyPrerenderContents* prerender_contents1 = | 299 DummyPrerenderContents* prerender_contents1 = |
267 prerender_manager()->CreateNextPrerenderContents( | 300 prerender_manager()->CreateNextPrerenderContents( |
268 url, | 301 url, |
269 FINAL_STATUS_MANAGER_SHUTDOWN); | 302 FINAL_STATUS_MANAGER_SHUTDOWN); |
270 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url)); | 303 EXPECT_FALSE(AddSimplePrerender(url)); |
271 EXPECT_EQ(prerender_contents1, | 304 EXPECT_EQ(prerender_contents1, |
272 prerender_manager()->next_prerender_contents()); | 305 prerender_manager()->next_prerender_contents()); |
273 EXPECT_FALSE(prerender_contents1->has_started()); | 306 EXPECT_FALSE(prerender_contents1->has_started()); |
274 | 307 |
275 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 308 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
276 } | 309 } |
277 | 310 |
278 // Ensure that we expire a prerendered page after the max. permitted time. | 311 // Ensure that we expire a prerendered page after the max. permitted time. |
279 TEST_F(PrerenderManagerTest, ExpireTest) { | 312 TEST_F(PrerenderTest, ExpireTest) { |
280 GURL url("http://www.google.com/"); | 313 GURL url("http://www.google.com/"); |
281 DummyPrerenderContents* prerender_contents = | 314 DummyPrerenderContents* prerender_contents = |
282 prerender_manager()->CreateNextPrerenderContents( | 315 prerender_manager()->CreateNextPrerenderContents( |
283 url, | 316 url, |
284 FINAL_STATUS_TIMED_OUT); | 317 FINAL_STATUS_TIMED_OUT); |
285 DummyPrerenderContents* null = NULL; | 318 DummyPrerenderContents* null = NULL; |
286 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 319 EXPECT_TRUE(AddSimplePrerender(url)); |
287 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 320 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
288 EXPECT_TRUE(prerender_contents->has_started()); | 321 EXPECT_TRUE(prerender_contents->has_started()); |
289 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + | 322 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + |
290 base::TimeDelta::FromSeconds(1)); | 323 base::TimeDelta::FromSeconds(1)); |
291 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | 324 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
292 } | 325 } |
293 | 326 |
294 // LRU Test. Make sure that if we prerender more than one request, that | 327 // LRU Test. Make sure that if we prerender more than one request, that |
295 // the oldest one will be dropped. | 328 // the oldest one will be dropped. |
296 TEST_F(PrerenderManagerTest, DropOldestRequestTest) { | 329 TEST_F(PrerenderTest, DropOldestRequestTest) { |
297 GURL url("http://www.google.com/"); | 330 GURL url("http://www.google.com/"); |
298 DummyPrerenderContents* prerender_contents = | 331 DummyPrerenderContents* prerender_contents = |
299 prerender_manager()->CreateNextPrerenderContents( | 332 prerender_manager()->CreateNextPrerenderContents( |
300 url, | 333 url, |
301 FINAL_STATUS_EVICTED); | 334 FINAL_STATUS_EVICTED); |
302 DummyPrerenderContents* null = NULL; | 335 DummyPrerenderContents* null = NULL; |
303 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 336 EXPECT_TRUE(AddSimplePrerender(url)); |
304 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 337 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
305 EXPECT_TRUE(prerender_contents->has_started()); | 338 EXPECT_TRUE(prerender_contents->has_started()); |
306 | 339 |
307 GURL url1("http://news.google.com/"); | 340 GURL url1("http://news.google.com/"); |
308 DummyPrerenderContents* prerender_contents1 = | 341 DummyPrerenderContents* prerender_contents1 = |
309 prerender_manager()->CreateNextPrerenderContents( | 342 prerender_manager()->CreateNextPrerenderContents( |
310 url1, | 343 url1, |
311 FINAL_STATUS_USED); | 344 FINAL_STATUS_USED); |
312 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1)); | 345 EXPECT_TRUE(AddSimplePrerender(url1)); |
313 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 346 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
314 EXPECT_TRUE(prerender_contents1->has_started()); | 347 EXPECT_TRUE(prerender_contents1->has_started()); |
315 | 348 |
316 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | 349 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
317 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); | 350 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); |
318 } | 351 } |
319 | 352 |
320 // Two element prerender test. Ensure that the LRU operates correctly if we | 353 // Two element prerender test. Ensure that the LRU operates correctly if we |
321 // permit 2 elements to be kept prerendered. | 354 // permit 2 elements to be kept prerendered. |
322 TEST_F(PrerenderManagerTest, TwoElementPrerenderTest) { | 355 TEST_F(PrerenderTest, TwoElementPrerenderTest) { |
323 prerender_manager()->mutable_config().max_elements = 2; | 356 prerender_manager()->mutable_config().max_elements = 2; |
324 GURL url("http://www.google.com/"); | 357 GURL url("http://www.google.com/"); |
325 DummyPrerenderContents* prerender_contents = | 358 DummyPrerenderContents* prerender_contents = |
326 prerender_manager()->CreateNextPrerenderContents( | 359 prerender_manager()->CreateNextPrerenderContents( |
327 url, | 360 url, |
328 FINAL_STATUS_EVICTED); | 361 FINAL_STATUS_EVICTED); |
329 DummyPrerenderContents* null = NULL; | 362 DummyPrerenderContents* null = NULL; |
330 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 363 EXPECT_TRUE(AddSimplePrerender(url)); |
331 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 364 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
332 EXPECT_TRUE(prerender_contents->has_started()); | 365 EXPECT_TRUE(prerender_contents->has_started()); |
333 | 366 |
334 GURL url1("http://news.google.com/"); | 367 GURL url1("http://news.google.com/"); |
335 DummyPrerenderContents* prerender_contents1 = | 368 DummyPrerenderContents* prerender_contents1 = |
336 prerender_manager()->CreateNextPrerenderContents( | 369 prerender_manager()->CreateNextPrerenderContents( |
337 url1, | 370 url1, |
338 FINAL_STATUS_USED); | 371 FINAL_STATUS_USED); |
339 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1)); | 372 EXPECT_TRUE(AddSimplePrerender(url1)); |
340 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 373 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
341 EXPECT_TRUE(prerender_contents1->has_started()); | 374 EXPECT_TRUE(prerender_contents1->has_started()); |
342 | 375 |
343 GURL url2("http://images.google.com/"); | 376 GURL url2("http://images.google.com/"); |
344 DummyPrerenderContents* prerender_contents2 = | 377 DummyPrerenderContents* prerender_contents2 = |
345 prerender_manager()->CreateNextPrerenderContents( | 378 prerender_manager()->CreateNextPrerenderContents( |
346 url2, | 379 url2, |
347 FINAL_STATUS_USED); | 380 FINAL_STATUS_USED); |
348 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url2)); | 381 EXPECT_TRUE(AddSimplePrerender(url2)); |
349 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 382 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
350 EXPECT_TRUE(prerender_contents2->has_started()); | 383 EXPECT_TRUE(prerender_contents2->has_started()); |
351 | 384 |
352 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | 385 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
353 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); | 386 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); |
354 ASSERT_EQ(prerender_contents2, prerender_manager()->GetEntry(url2)); | 387 ASSERT_EQ(prerender_contents2, prerender_manager()->GetEntry(url2)); |
355 } | 388 } |
356 | 389 |
357 TEST_F(PrerenderManagerTest, AliasURLTest) { | 390 TEST_F(PrerenderTest, AliasURLTest) { |
358 GURL url("http://www.google.com/"); | 391 GURL url("http://www.google.com/"); |
359 GURL alias_url1("http://www.google.com/index.html"); | 392 GURL alias_url1("http://www.google.com/index.html"); |
360 GURL alias_url2("http://google.com/"); | 393 GURL alias_url2("http://google.com/"); |
361 GURL not_an_alias_url("http://google.com/index.html"); | 394 GURL not_an_alias_url("http://google.com/index.html"); |
362 std::vector<GURL> alias_urls; | 395 std::vector<GURL> alias_urls; |
363 alias_urls.push_back(alias_url1); | 396 alias_urls.push_back(alias_url1); |
364 alias_urls.push_back(alias_url2); | 397 alias_urls.push_back(alias_url2); |
365 | 398 |
366 // Test that all of the aliases work, but not_an_alias_url does not. | 399 // Test that all of the aliases work, but not_an_alias_url does not. |
367 DummyPrerenderContents* prerender_contents = | 400 DummyPrerenderContents* prerender_contents = |
368 prerender_manager()->CreateNextPrerenderContents( | 401 prerender_manager()->CreateNextPrerenderContents( |
369 url, alias_urls, FINAL_STATUS_USED); | 402 url, alias_urls, FINAL_STATUS_USED); |
370 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 403 EXPECT_TRUE(AddSimplePrerender(url)); |
371 ASSERT_EQ(NULL, prerender_manager()->GetEntry(not_an_alias_url)); | 404 ASSERT_EQ(NULL, prerender_manager()->GetEntry(not_an_alias_url)); |
372 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url1)); | 405 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url1)); |
373 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | 406 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
374 url, alias_urls, FINAL_STATUS_USED); | 407 url, alias_urls, FINAL_STATUS_USED); |
375 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 408 EXPECT_TRUE(AddSimplePrerender(url)); |
376 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url2)); | 409 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url2)); |
377 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | 410 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
378 url, alias_urls, FINAL_STATUS_USED); | 411 url, alias_urls, FINAL_STATUS_USED); |
379 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 412 EXPECT_TRUE(AddSimplePrerender(url)); |
380 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 413 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
381 | 414 |
382 // Test that alias URLs can not be added. | 415 // Test that alias URLs can not be added. |
383 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | 416 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
384 url, alias_urls, FINAL_STATUS_USED); | 417 url, alias_urls, FINAL_STATUS_USED); |
385 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 418 EXPECT_TRUE(AddSimplePrerender(url)); |
386 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url)); | 419 EXPECT_FALSE(AddSimplePrerender(url)); |
387 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(alias_url1)); | 420 EXPECT_FALSE(AddSimplePrerender(alias_url1)); |
388 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(alias_url2)); | 421 EXPECT_FALSE(AddSimplePrerender(alias_url2)); |
389 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 422 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
390 } | 423 } |
391 | 424 |
392 // Ensure that we ignore prerender requests within the rate limit. | 425 // Ensure that we ignore prerender requests within the rate limit. |
393 TEST_F(PrerenderManagerTest, RateLimitInWindowTest) { | 426 TEST_F(PrerenderTest, RateLimitInWindowTest) { |
394 GURL url("http://www.google.com/"); | 427 GURL url("http://www.google.com/"); |
395 DummyPrerenderContents* prerender_contents = | 428 DummyPrerenderContents* prerender_contents = |
396 prerender_manager()->CreateNextPrerenderContents( | 429 prerender_manager()->CreateNextPrerenderContents( |
397 url, | 430 url, |
398 FINAL_STATUS_MANAGER_SHUTDOWN); | 431 FINAL_STATUS_MANAGER_SHUTDOWN); |
399 DummyPrerenderContents* null = NULL; | 432 DummyPrerenderContents* null = NULL; |
400 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 433 EXPECT_TRUE(AddSimplePrerender(url)); |
401 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 434 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
402 EXPECT_TRUE(prerender_contents->has_started()); | 435 EXPECT_TRUE(prerender_contents->has_started()); |
403 | 436 |
404 prerender_manager()->set_rate_limit_enabled(true); | 437 prerender_manager()->set_rate_limit_enabled(true); |
405 prerender_manager()->AdvanceTimeTicks(base::TimeDelta::FromMilliseconds(1)); | 438 prerender_manager()->AdvanceTimeTicks(base::TimeDelta::FromMilliseconds(1)); |
406 | 439 |
407 GURL url1("http://news.google.com/"); | 440 GURL url1("http://news.google.com/"); |
408 prerender_manager()->CreateNextPrerenderContents( | 441 prerender_manager()->CreateNextPrerenderContents( |
409 url, | 442 url, |
410 FINAL_STATUS_MANAGER_SHUTDOWN); | 443 FINAL_STATUS_MANAGER_SHUTDOWN); |
411 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url1)); | 444 EXPECT_FALSE(AddSimplePrerender(url1)); |
412 prerender_manager()->set_rate_limit_enabled(false); | 445 prerender_manager()->set_rate_limit_enabled(false); |
413 } | 446 } |
414 | 447 |
415 // Ensure that we don't ignore prerender requests outside the rate limit. | 448 // Ensure that we don't ignore prerender requests outside the rate limit. |
416 TEST_F(PrerenderManagerTest, RateLimitOutsideWindowTest) { | 449 TEST_F(PrerenderTest, RateLimitOutsideWindowTest) { |
417 GURL url("http://www.google.com/"); | 450 GURL url("http://www.google.com/"); |
418 DummyPrerenderContents* prerender_contents = | 451 DummyPrerenderContents* prerender_contents = |
419 prerender_manager()->CreateNextPrerenderContents( | 452 prerender_manager()->CreateNextPrerenderContents( |
420 url, | 453 url, |
421 FINAL_STATUS_EVICTED); | 454 FINAL_STATUS_EVICTED); |
422 DummyPrerenderContents* null = NULL; | 455 DummyPrerenderContents* null = NULL; |
423 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 456 EXPECT_TRUE(AddSimplePrerender(url)); |
424 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 457 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
425 EXPECT_TRUE(prerender_contents->has_started()); | 458 EXPECT_TRUE(prerender_contents->has_started()); |
426 | 459 |
427 prerender_manager()->set_rate_limit_enabled(true); | 460 prerender_manager()->set_rate_limit_enabled(true); |
428 prerender_manager()->AdvanceTimeTicks( | 461 prerender_manager()->AdvanceTimeTicks( |
429 base::TimeDelta::FromMilliseconds(2000)); | 462 base::TimeDelta::FromMilliseconds(2000)); |
430 | 463 |
431 GURL url1("http://news.google.com/"); | 464 GURL url1("http://news.google.com/"); |
432 DummyPrerenderContents* rate_limit_prerender_contents = | 465 DummyPrerenderContents* rate_limit_prerender_contents = |
433 prerender_manager()->CreateNextPrerenderContents( | 466 prerender_manager()->CreateNextPrerenderContents( |
434 url1, | 467 url1, |
435 FINAL_STATUS_MANAGER_SHUTDOWN); | 468 FINAL_STATUS_MANAGER_SHUTDOWN); |
436 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1)); | 469 EXPECT_TRUE(AddSimplePrerender(url1)); |
437 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 470 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
438 EXPECT_TRUE(rate_limit_prerender_contents->has_started()); | 471 EXPECT_TRUE(rate_limit_prerender_contents->has_started()); |
439 prerender_manager()->set_rate_limit_enabled(false); | 472 prerender_manager()->set_rate_limit_enabled(false); |
440 } | 473 } |
441 | 474 |
442 TEST_F(PrerenderManagerTest, PendingPrerenderTest) { | 475 TEST_F(PrerenderTest, PendingPrerenderTest) { |
443 GURL url("http://www.google.com/"); | 476 GURL url("http://www.google.com/"); |
444 DummyPrerenderContents* prerender_contents = | 477 DummyPrerenderContents* prerender_contents = |
445 prerender_manager()->CreateNextPrerenderContents( | 478 prerender_manager()->CreateNextPrerenderContents( |
446 url, | 479 url, |
447 FINAL_STATUS_USED); | 480 FINAL_STATUS_USED); |
448 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 481 EXPECT_TRUE(AddSimplePrerender(url)); |
449 | 482 |
450 int child_id; | 483 int child_id; |
451 int route_id; | 484 int route_id; |
452 ASSERT_TRUE(prerender_contents->GetChildId(&child_id)); | 485 ASSERT_TRUE(prerender_contents->GetChildId(&child_id)); |
453 ASSERT_TRUE(prerender_contents->GetRouteId(&route_id)); | 486 ASSERT_TRUE(prerender_contents->GetRouteId(&route_id)); |
454 | 487 |
455 GURL pending_url("http://news.google.com/"); | 488 GURL pending_url("http://news.google.com/"); |
456 | 489 |
457 EXPECT_TRUE(prerender_manager()->AddPrerenderFromLinkRelPrerender( | 490 EXPECT_TRUE(prerender_manager()->AddPrerenderFromLinkRelPrerender( |
458 child_id, route_id, | 491 child_id, route_id, |
459 pending_url, content::Referrer(url, WebKit::WebReferrerPolicyDefault))); | 492 pending_url, content::Referrer(url, WebKit::WebReferrerPolicyDefault))); |
460 | 493 |
461 EXPECT_TRUE(prerender_manager()->IsPendingEntry(pending_url)); | 494 EXPECT_TRUE(prerender_manager()->IsPendingEntry(pending_url)); |
462 EXPECT_TRUE(prerender_contents->has_started()); | 495 EXPECT_TRUE(prerender_contents->has_started()); |
463 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 496 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
464 } | 497 } |
465 | 498 |
466 // Tests that a PrerenderManager created for a browser session in the control | 499 // Tests that a PrerenderManager created for a browser session in the control |
467 // group works as expected. | 500 // group works as expected. |
468 TEST_F(PrerenderManagerTest, ControlGroup) { | 501 TEST_F(PrerenderTest, ControlGroup) { |
469 RestorePrerenderMode restore_prerender_mode; | 502 RestorePrerenderMode restore_prerender_mode; |
470 PrerenderManager::SetMode( | 503 PrerenderManager::SetMode( |
471 PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP); | 504 PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP); |
472 GURL url("http://www.google.com/"); | 505 GURL url("http://www.google.com/"); |
473 DummyPrerenderContents* prerender_contents = | 506 DummyPrerenderContents* prerender_contents = |
474 prerender_manager()->CreateNextPrerenderContents( | 507 prerender_manager()->CreateNextPrerenderContents( |
475 url, | 508 url, |
476 FINAL_STATUS_MANAGER_SHUTDOWN); | 509 FINAL_STATUS_MANAGER_SHUTDOWN); |
477 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 510 EXPECT_TRUE(AddSimplePrerender(url)); |
478 EXPECT_FALSE(prerender_contents->has_started()); | 511 EXPECT_FALSE(prerender_contents->has_started()); |
479 } | 512 } |
480 | 513 |
481 // Tests that prerendering is cancelled when the source render view does not | 514 // Tests that prerendering is cancelled when the source render view does not |
482 // exist. On failure, the DCHECK in CreatePrerenderContents() above should be | 515 // exist. On failure, the DCHECK in CreatePrerenderContents() above should be |
483 // triggered. | 516 // triggered. |
484 TEST_F(PrerenderManagerTest, SourceRenderViewClosed) { | 517 TEST_F(PrerenderTest, SourceRenderViewClosed) { |
485 GURL url("http://www.google.com/"); | 518 GURL url("http://www.google.com/"); |
486 prerender_manager()->CreateNextPrerenderContents( | 519 prerender_manager()->CreateNextPrerenderContents( |
487 url, | 520 url, |
488 FINAL_STATUS_MANAGER_SHUTDOWN); | 521 FINAL_STATUS_MANAGER_SHUTDOWN); |
489 EXPECT_FALSE(prerender_manager()->AddPrerenderFromLinkRelPrerender( | 522 EXPECT_FALSE(prerender_manager()->AddPrerenderFromLinkRelPrerender( |
490 100, 100, url, content::Referrer())); | 523 100, 100, url, content::Referrer())); |
491 } | 524 } |
492 | 525 |
493 // Tests that the prerender manager ignores fragment references when matching | 526 // Tests that the prerender manager ignores fragment references when matching |
494 // prerender URLs in the case the fragment is not in the prerender URL. | 527 // prerender URLs in the case the fragment is not in the prerender URL. |
495 TEST_F(PrerenderManagerTest, PageMatchesFragmentTest) { | 528 TEST_F(PrerenderTest, PageMatchesFragmentTest) { |
496 GURL url("http://www.google.com/"); | 529 GURL url("http://www.google.com/"); |
497 GURL fragment_url("http://www.google.com/#test"); | 530 GURL fragment_url("http://www.google.com/#test"); |
498 | 531 |
499 DummyPrerenderContents* prerender_contents = | 532 DummyPrerenderContents* prerender_contents = |
500 prerender_manager()->CreateNextPrerenderContents(url, | 533 prerender_manager()->CreateNextPrerenderContents(url, |
501 FINAL_STATUS_USED); | 534 FINAL_STATUS_USED); |
502 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 535 EXPECT_TRUE(AddSimplePrerender(url)); |
503 EXPECT_TRUE(prerender_contents->has_started()); | 536 EXPECT_TRUE(prerender_contents->has_started()); |
504 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(fragment_url)); | 537 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(fragment_url)); |
505 } | 538 } |
506 | 539 |
507 // Tests that the prerender manager ignores fragment references when matching | 540 // Tests that the prerender manager ignores fragment references when matching |
508 // prerender URLs in the case the fragment is in the prerender URL. | 541 // prerender URLs in the case the fragment is in the prerender URL. |
509 TEST_F(PrerenderManagerTest, FragmentMatchesPageTest) { | 542 // TODO(gavinp): Re-enable this in the Prerender API once we're officially |
543 // fragment clean. | |
544 TEST_F(PrerenderTest, DISABLED_FragmentMatchesPageTest) { | |
510 GURL url("http://www.google.com/"); | 545 GURL url("http://www.google.com/"); |
511 GURL fragment_url("http://www.google.com/#test"); | 546 GURL fragment_url("http://www.google.com/#test"); |
512 | 547 |
513 DummyPrerenderContents* prerender_contents = | 548 DummyPrerenderContents* prerender_contents = |
514 prerender_manager()->CreateNextPrerenderContents(fragment_url, | 549 prerender_manager()->CreateNextPrerenderContents(fragment_url, |
515 FINAL_STATUS_USED); | 550 FINAL_STATUS_USED); |
516 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(fragment_url)); | 551 EXPECT_TRUE(AddSimplePrerender(fragment_url)); |
517 EXPECT_TRUE(prerender_contents->has_started()); | 552 EXPECT_TRUE(prerender_contents->has_started()); |
518 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 553 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
519 } | 554 } |
520 | 555 |
521 // Tests that the prerender manager ignores fragment references when matching | 556 // Tests that the prerender manager ignores fragment references when matching |
522 // prerender URLs in the case the fragment is in both URLs. | 557 // prerender URLs in the case the fragment is in both URLs. |
523 TEST_F(PrerenderManagerTest, FragmentMatchesFragmentTest) { | 558 // TODO(gavinp): Re-enable this in the Prerender API once we're officially |
559 // fragment clean. | |
560 TEST_F(PrerenderTest, DISABLED_FragmentMatchesFragmentTest) { | |
524 GURL fragment_url("http://www.google.com/#test"); | 561 GURL fragment_url("http://www.google.com/#test"); |
525 GURL other_fragment_url("http://www.google.com/#other_test"); | 562 GURL other_fragment_url("http://www.google.com/#other_test"); |
526 | 563 |
527 DummyPrerenderContents* prerender_contents = | 564 DummyPrerenderContents* prerender_contents = |
528 prerender_manager()->CreateNextPrerenderContents(fragment_url, | 565 prerender_manager()->CreateNextPrerenderContents(fragment_url, |
529 FINAL_STATUS_USED); | 566 FINAL_STATUS_USED); |
530 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(fragment_url)); | 567 EXPECT_TRUE(AddSimplePrerender(fragment_url)); |
531 EXPECT_TRUE(prerender_contents->has_started()); | 568 EXPECT_TRUE(prerender_contents->has_started()); |
532 ASSERT_EQ(prerender_contents, | 569 ASSERT_EQ(prerender_contents, |
533 prerender_manager()->GetEntry(other_fragment_url)); | 570 prerender_manager()->GetEntry(other_fragment_url)); |
534 } | 571 } |
535 | 572 |
536 // Make sure that clearing works as expected. | 573 // Make sure that clearing works as expected. |
537 TEST_F(PrerenderManagerTest, ClearTest) { | 574 TEST_F(PrerenderTest, ClearTest) { |
538 GURL url("http://www.google.com/"); | 575 GURL url("http://www.google.com/"); |
539 DummyPrerenderContents* prerender_contents = | 576 DummyPrerenderContents* prerender_contents = |
540 prerender_manager()->CreateNextPrerenderContents( | 577 prerender_manager()->CreateNextPrerenderContents( |
541 url, | 578 url, |
542 FINAL_STATUS_CACHE_OR_HISTORY_CLEARED); | 579 FINAL_STATUS_CACHE_OR_HISTORY_CLEARED); |
543 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 580 EXPECT_TRUE(AddSimplePrerender(url)); |
544 EXPECT_TRUE(prerender_contents->has_started()); | 581 EXPECT_TRUE(prerender_contents->has_started()); |
545 prerender_manager()->ClearData(PrerenderManager::CLEAR_PRERENDER_CONTENTS); | 582 prerender_manager()->ClearData(PrerenderManager::CLEAR_PRERENDER_CONTENTS); |
546 DummyPrerenderContents* null = NULL; | 583 DummyPrerenderContents* null = NULL; |
547 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | 584 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
548 } | 585 } |
549 | 586 |
550 // Make sure canceling works as expected. | 587 // Make sure canceling works as expected. |
551 TEST_F(PrerenderManagerTest, CancelAllTest) { | 588 TEST_F(PrerenderTest, CancelAllTest) { |
552 GURL url("http://www.google.com/"); | 589 GURL url("http://www.google.com/"); |
553 DummyPrerenderContents* prerender_contents = | 590 DummyPrerenderContents* prerender_contents = |
554 prerender_manager()->CreateNextPrerenderContents( | 591 prerender_manager()->CreateNextPrerenderContents( |
555 url, FINAL_STATUS_CANCELLED); | 592 url, FINAL_STATUS_CANCELLED); |
556 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 593 EXPECT_TRUE(AddSimplePrerender(url)); |
557 EXPECT_TRUE(prerender_contents->has_started()); | 594 EXPECT_TRUE(prerender_contents->has_started()); |
558 prerender_manager()->CancelAllPrerenders(); | 595 prerender_manager()->CancelAllPrerenders(); |
559 const DummyPrerenderContents* null = NULL; | 596 const DummyPrerenderContents* null = NULL; |
560 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | 597 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
561 } | 598 } |
562 | 599 |
563 // Make sure canceling for omnibox works as expected. | 600 // Make sure canceling for omnibox works as expected. |
564 TEST_F(PrerenderManagerTest, CancelOmniboxRemovesOmniboxTest) { | 601 TEST_F(PrerenderTest, CancelOmniboxRemovesOmniboxTest) { |
565 // Check canceling removes the Omnibox url. | 602 // Check canceling removes the Omnibox url. |
566 GURL url("http://www.google.com/"); | 603 GURL url("http://www.google.com/"); |
567 DummyPrerenderContents* prerender_contents = | 604 DummyPrerenderContents* prerender_contents = |
568 prerender_manager()->CreateNextPrerenderContents( | 605 prerender_manager()->CreateNextPrerenderContents( |
569 url, ORIGIN_OMNIBOX, FINAL_STATUS_CANCELLED); | 606 url, ORIGIN_OMNIBOX, FINAL_STATUS_CANCELLED); |
570 EXPECT_TRUE(prerender_manager()->AddPrerenderFromOmnibox(url, NULL)); | 607 EXPECT_TRUE(prerender_manager()->AddPrerenderFromOmnibox(url, NULL)); |
571 EXPECT_TRUE(prerender_contents->has_started()); | 608 EXPECT_TRUE(prerender_contents->has_started()); |
572 prerender_manager()->CancelOmniboxPrerenders(); | 609 prerender_manager()->CancelOmniboxPrerenders(); |
573 const DummyPrerenderContents* null = NULL; | 610 const DummyPrerenderContents* null = NULL; |
574 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | 611 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
575 } | 612 } |
576 | 613 |
577 TEST_F(PrerenderManagerTest, CancelOmniboxDoesNotRemoveLinkTest) { | 614 TEST_F(PrerenderTest, CancelOmniboxDoesNotRemoveLinkTest) { |
578 GURL url("http://www.google.com/"); | 615 GURL url("http://www.google.com/"); |
579 DummyPrerenderContents* prerender_contents = | 616 DummyPrerenderContents* prerender_contents = |
580 prerender_manager()->CreateNextPrerenderContents( | 617 prerender_manager()->CreateNextPrerenderContents( |
581 url, ORIGIN_LINK_REL_PRERENDER, FINAL_STATUS_MANAGER_SHUTDOWN); | 618 url, ORIGIN_LINK_REL_PRERENDER, FINAL_STATUS_MANAGER_SHUTDOWN); |
582 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 619 EXPECT_TRUE(AddSimplePrerender(url)); |
583 EXPECT_TRUE(prerender_contents->has_started()); | 620 EXPECT_TRUE(prerender_contents->has_started()); |
584 prerender_manager()->CancelOmniboxPrerenders(); | 621 prerender_manager()->CancelOmniboxPrerenders(); |
585 const DummyPrerenderContents* null = NULL; | 622 const DummyPrerenderContents* null = NULL; |
586 EXPECT_NE(null, prerender_manager()->FindEntry(url)); | 623 EXPECT_NE(null, prerender_manager()->FindEntry(url)); |
587 } | 624 } |
588 | 625 |
589 TEST_F(PrerenderManagerTest, OmniboxNotAllowedWhenDisabled) { | 626 TEST_F(PrerenderTest, OmniboxNotAllowedWhenDisabled) { |
590 prerender_manager()->set_enabled(false); | 627 prerender_manager()->set_enabled(false); |
591 EXPECT_FALSE(prerender_manager()->AddPrerenderFromOmnibox( | 628 EXPECT_FALSE(prerender_manager()->AddPrerenderFromOmnibox( |
592 GURL("http://www.example.com"), NULL)); | 629 GURL("http://www.example.com"), NULL)); |
593 } | 630 } |
594 | 631 |
595 TEST_F(PrerenderManagerTest, LinkRelNotAllowedWhenDisabled) { | 632 TEST_F(PrerenderTest, LinkRelNotAllowedWhenDisabled) { |
596 prerender_manager()->set_enabled(false); | 633 prerender_manager()->set_enabled(false); |
597 EXPECT_FALSE(prerender_manager()->AddSimplePrerender( | 634 EXPECT_FALSE(AddSimplePrerender( |
598 GURL("http://www.example.com"))); | 635 GURL("http://www.example.com"))); |
599 } | 636 } |
600 | 637 |
638 TEST_F(PrerenderTest, LinkManagerCancel) { | |
639 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
640 GURL url("http://www.myexample.com"); | |
641 DummyPrerenderContents* prerender_contents = | |
642 prerender_manager()->CreateNextPrerenderContents( | |
643 url, | |
644 FINAL_STATUS_CANCELLED); | |
645 EXPECT_TRUE(AddSimplePrerender(url)); | |
646 EXPECT_TRUE(prerender_contents->has_started()); | |
647 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
648 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
649 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
650 kDefaultChildId); | |
651 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | |
652 DummyPrerenderContents* null = NULL; | |
653 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
654 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
655 } | |
656 | |
657 TEST_F(PrerenderTest, LinkManagerCancelTwice) { | |
658 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
659 GURL url("http://www.myexample.com"); | |
660 DummyPrerenderContents* prerender_contents = | |
661 prerender_manager()->CreateNextPrerenderContents( | |
662 url, | |
663 FINAL_STATUS_CANCELLED); | |
664 EXPECT_TRUE(AddSimplePrerender(url)); | |
665 EXPECT_TRUE(prerender_contents->has_started()); | |
666 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
667 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
668 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
669 kDefaultChildId); | |
670 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
671 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | |
672 DummyPrerenderContents* null = NULL; | |
673 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
674 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
675 kDefaultChildId); | |
676 } | |
677 | |
678 TEST_F(PrerenderTest, LinkManagerAddTwiceCancelTwice) { | |
679 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
680 GURL url("http://www.myexample.com"); | |
681 DummyPrerenderContents* prerender_contents = | |
682 prerender_manager()->CreateNextPrerenderContents( | |
683 url, FINAL_STATUS_CANCELLED); | |
684 EXPECT_TRUE(AddSimplePrerender(url)); | |
685 const int first_prerender_id = last_prerender_id(); | |
686 EXPECT_TRUE(prerender_contents->has_started()); | |
687 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
688 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
689 // The second prerender doesn't successfully add (it's a dupe), but | |
690 // we should still be able to use the |prerender_id| to refer to it | |
691 // after the add, and it should still prevent subsequent removal | |
692 // of the prerender when the first one is canceled. | |
693 EXPECT_FALSE(AddSimplePrerender(url)); | |
694 const int second_prerender_id = last_prerender_id(); | |
695 EXPECT_TRUE(prerender_contents->has_started()); | |
696 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
697 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
698 prerender_link_manager()->OnCancelPrerender(first_prerender_id, | |
699 kDefaultChildId); | |
700 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
701 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | |
702 DummyPrerenderContents* null = NULL; | |
703 ASSERT_EQ(null, prerender_manager()->FindEntry(url)); | |
704 prerender_link_manager()->OnCancelPrerender(second_prerender_id, | |
705 kDefaultChildId); | |
706 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
707 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | |
708 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
709 } | |
710 | |
711 TEST_F(PrerenderTest, LinkManagerExpireThenCancel) { | |
712 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
713 GURL url("http://www.myexample.com"); | |
714 DummyPrerenderContents* prerender_contents = | |
715 prerender_manager()->CreateNextPrerenderContents( | |
716 url, | |
717 FINAL_STATUS_TIMED_OUT); | |
718 EXPECT_TRUE(AddSimplePrerender(url)); | |
719 EXPECT_TRUE(prerender_contents->has_started()); | |
720 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
721 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
722 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + | |
723 base::TimeDelta::FromSeconds(1)); | |
724 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); | |
725 DummyPrerenderContents* null = NULL; | |
726 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
727 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
728 kDefaultChildId); | |
729 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
730 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
731 } | |
732 | |
733 TEST_F(PrerenderTest, LinkManagerExpireThenAddAgain) { | |
734 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
735 GURL url("http://www.myexample.com"); | |
736 DummyPrerenderContents* first_prerender_contents = | |
737 prerender_manager()->CreateNextPrerenderContents( | |
738 url, | |
739 FINAL_STATUS_TIMED_OUT); | |
740 EXPECT_TRUE(AddSimplePrerender(url)); | |
741 EXPECT_TRUE(first_prerender_contents->has_started()); | |
742 EXPECT_FALSE(first_prerender_contents->prerendering_has_been_cancelled()); | |
743 ASSERT_EQ(first_prerender_contents, prerender_manager()->FindEntry(url)); | |
744 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + | |
745 base::TimeDelta::FromSeconds(1)); | |
746 DummyPrerenderContents* null = NULL; | |
747 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
748 // Unlike in LinkManagerAddTwiceCancelTwice, we expect this time adding to | |
749 // return true; the prerender has in the meantime been expired by the | |
750 // prerender manager, and so this is an add in the prerender manager sense. | |
751 DummyPrerenderContents* second_prerender_contents = | |
752 prerender_manager()->CreateNextPrerenderContents( | |
753 url, | |
754 FINAL_STATUS_USED); | |
755 EXPECT_TRUE(AddSimplePrerender(url)); | |
756 EXPECT_TRUE(second_prerender_contents->has_started()); | |
757 ASSERT_EQ(second_prerender_contents, prerender_manager()->GetEntry(url)); | |
758 // The PrerenderLinkManager is not empty since we never removed the first | |
759 // prerender. | |
760 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); | |
761 } | |
762 | |
763 TEST_F(PrerenderTest, LinkManagerCancelThenAddAgain) { | |
764 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
765 GURL url("http://www.myexample.com"); | |
766 DummyPrerenderContents* first_prerender_contents = | |
767 prerender_manager()->CreateNextPrerenderContents( | |
768 url, | |
769 FINAL_STATUS_CANCELLED); | |
770 EXPECT_TRUE(AddSimplePrerender(url)); | |
771 EXPECT_TRUE(first_prerender_contents->has_started()); | |
772 EXPECT_FALSE(first_prerender_contents->prerendering_has_been_cancelled()); | |
773 ASSERT_EQ(first_prerender_contents, prerender_manager()->FindEntry(url)); | |
774 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
775 kDefaultChildId); | |
776 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
777 EXPECT_TRUE(first_prerender_contents->prerendering_has_been_cancelled()); | |
778 DummyPrerenderContents* null = NULL; | |
779 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
780 DummyPrerenderContents* second_prerender_contents = | |
781 prerender_manager()->CreateNextPrerenderContents( | |
782 url, | |
783 FINAL_STATUS_USED); | |
784 EXPECT_TRUE(AddSimplePrerender(url)); | |
785 EXPECT_TRUE(second_prerender_contents->has_started()); | |
786 ASSERT_EQ(second_prerender_contents, prerender_manager()->GetEntry(url)); | |
787 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); | |
788 } | |
789 | |
601 } // namespace prerender | 790 } // namespace prerender |
791 | |
OLD | NEW |