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/26 22:50:58
nit: method could be const
gavinp
2012/04/27 20:31:32
I don't think so, unless I make last_prerender_id_
dominich
2012/04/27 21:52:01
You're right, of course. Review blindness.
| |
254 ++last_prerender_id_; | |
255 return last_prerender_id_; | |
dominich
2012/04/26 22:50:58
nit: or 'return ++last_prerender_id_;'
gavinp
2012/04/27 20:31:32
Done, though I bet a guinea that it compiles to th
| |
256 } | |
257 | |
226 PrerenderTracker* prerender_tracker() { | 258 PrerenderTracker* prerender_tracker() { |
227 return g_browser_process->prerender_tracker(); | 259 return g_browser_process->prerender_tracker(); |
228 } | 260 } |
229 | 261 |
230 // Needed to pass PrerenderManager's DCHECKs. | 262 // Needed to pass PrerenderManager's DCHECKs. |
231 MessageLoop message_loop_; | 263 MessageLoop message_loop_; |
232 content::TestBrowserThread ui_thread_; | 264 content::TestBrowserThread ui_thread_; |
233 scoped_ptr<TestPrerenderManager> prerender_manager_; | 265 scoped_ptr<TestPrerenderManager> prerender_manager_; |
266 scoped_ptr<PrerenderLinkManager> prerender_link_manager_; | |
267 int last_prerender_id_; | |
234 }; | 268 }; |
235 | 269 |
236 TEST_F(PrerenderManagerTest, EmptyTest) { | 270 TEST_F(PrerenderTest, EmptyTest) { |
237 EXPECT_FALSE(prerender_manager()->MaybeUsePrerenderedPage( | 271 EXPECT_FALSE(prerender_manager()->MaybeUsePrerenderedPage( |
238 NULL, | 272 NULL, |
239 GURL("http://www.google.com/"))); | 273 GURL("http://www.google.com/"))); |
240 } | 274 } |
241 | 275 |
242 TEST_F(PrerenderManagerTest, FoundTest) { | 276 TEST_F(PrerenderTest, FoundTest) { |
243 GURL url("http://www.google.com/"); | 277 GURL url("http://www.google.com/"); |
244 DummyPrerenderContents* prerender_contents = | 278 DummyPrerenderContents* prerender_contents = |
245 prerender_manager()->CreateNextPrerenderContents( | 279 prerender_manager()->CreateNextPrerenderContents( |
246 url, | 280 url, |
247 FINAL_STATUS_USED); | 281 FINAL_STATUS_USED); |
248 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 282 EXPECT_TRUE(AddSimplePrerender(url)); |
249 EXPECT_TRUE(prerender_contents->has_started()); | 283 EXPECT_TRUE(prerender_contents->has_started()); |
250 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 284 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
251 } | 285 } |
252 | 286 |
253 // Make sure that if queue a request, and a second prerender request for the | 287 // 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. | 288 // same URL comes in, that we drop the second request and keep the first one. |
255 TEST_F(PrerenderManagerTest, DropSecondRequestTest) { | 289 TEST_F(PrerenderTest, DropSecondRequestTest) { |
256 GURL url("http://www.google.com/"); | 290 GURL url("http://www.google.com/"); |
257 DummyPrerenderContents* prerender_contents = | 291 DummyPrerenderContents* prerender_contents = |
258 prerender_manager()->CreateNextPrerenderContents( | 292 prerender_manager()->CreateNextPrerenderContents( |
259 url, | 293 url, |
260 FINAL_STATUS_USED); | 294 FINAL_STATUS_USED); |
261 DummyPrerenderContents* null = NULL; | 295 DummyPrerenderContents* null = NULL; |
262 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 296 EXPECT_TRUE(AddSimplePrerender(url)); |
263 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 297 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
264 EXPECT_TRUE(prerender_contents->has_started()); | 298 EXPECT_TRUE(prerender_contents->has_started()); |
265 | 299 |
266 DummyPrerenderContents* prerender_contents1 = | 300 DummyPrerenderContents* prerender_contents1 = |
267 prerender_manager()->CreateNextPrerenderContents( | 301 prerender_manager()->CreateNextPrerenderContents( |
268 url, | 302 url, |
269 FINAL_STATUS_MANAGER_SHUTDOWN); | 303 FINAL_STATUS_MANAGER_SHUTDOWN); |
270 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url)); | 304 EXPECT_FALSE(AddSimplePrerender(url)); |
271 EXPECT_EQ(prerender_contents1, | 305 EXPECT_EQ(prerender_contents1, |
272 prerender_manager()->next_prerender_contents()); | 306 prerender_manager()->next_prerender_contents()); |
273 EXPECT_FALSE(prerender_contents1->has_started()); | 307 EXPECT_FALSE(prerender_contents1->has_started()); |
274 | 308 |
275 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 309 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
276 } | 310 } |
277 | 311 |
278 // Ensure that we expire a prerendered page after the max. permitted time. | 312 // Ensure that we expire a prerendered page after the max. permitted time. |
279 TEST_F(PrerenderManagerTest, ExpireTest) { | 313 TEST_F(PrerenderTest, ExpireTest) { |
280 GURL url("http://www.google.com/"); | 314 GURL url("http://www.google.com/"); |
281 DummyPrerenderContents* prerender_contents = | 315 DummyPrerenderContents* prerender_contents = |
282 prerender_manager()->CreateNextPrerenderContents( | 316 prerender_manager()->CreateNextPrerenderContents( |
283 url, | 317 url, |
284 FINAL_STATUS_TIMED_OUT); | 318 FINAL_STATUS_TIMED_OUT); |
285 DummyPrerenderContents* null = NULL; | 319 DummyPrerenderContents* null = NULL; |
286 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 320 EXPECT_TRUE(AddSimplePrerender(url)); |
287 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 321 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
288 EXPECT_TRUE(prerender_contents->has_started()); | 322 EXPECT_TRUE(prerender_contents->has_started()); |
289 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + | 323 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + |
290 base::TimeDelta::FromSeconds(1)); | 324 base::TimeDelta::FromSeconds(1)); |
291 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | 325 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
292 } | 326 } |
293 | 327 |
294 // LRU Test. Make sure that if we prerender more than one request, that | 328 // LRU Test. Make sure that if we prerender more than one request, that |
295 // the oldest one will be dropped. | 329 // the oldest one will be dropped. |
296 TEST_F(PrerenderManagerTest, DropOldestRequestTest) { | 330 TEST_F(PrerenderTest, DropOldestRequestTest) { |
297 GURL url("http://www.google.com/"); | 331 GURL url("http://www.google.com/"); |
298 DummyPrerenderContents* prerender_contents = | 332 DummyPrerenderContents* prerender_contents = |
299 prerender_manager()->CreateNextPrerenderContents( | 333 prerender_manager()->CreateNextPrerenderContents( |
300 url, | 334 url, |
301 FINAL_STATUS_EVICTED); | 335 FINAL_STATUS_EVICTED); |
302 DummyPrerenderContents* null = NULL; | 336 DummyPrerenderContents* null = NULL; |
303 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 337 EXPECT_TRUE(AddSimplePrerender(url)); |
304 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 338 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
305 EXPECT_TRUE(prerender_contents->has_started()); | 339 EXPECT_TRUE(prerender_contents->has_started()); |
306 | 340 |
307 GURL url1("http://news.google.com/"); | 341 GURL url1("http://news.google.com/"); |
308 DummyPrerenderContents* prerender_contents1 = | 342 DummyPrerenderContents* prerender_contents1 = |
309 prerender_manager()->CreateNextPrerenderContents( | 343 prerender_manager()->CreateNextPrerenderContents( |
310 url1, | 344 url1, |
311 FINAL_STATUS_USED); | 345 FINAL_STATUS_USED); |
312 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1)); | 346 EXPECT_TRUE(AddSimplePrerender(url1)); |
313 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 347 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
314 EXPECT_TRUE(prerender_contents1->has_started()); | 348 EXPECT_TRUE(prerender_contents1->has_started()); |
315 | 349 |
316 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | 350 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
317 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); | 351 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); |
318 } | 352 } |
319 | 353 |
320 // Two element prerender test. Ensure that the LRU operates correctly if we | 354 // Two element prerender test. Ensure that the LRU operates correctly if we |
321 // permit 2 elements to be kept prerendered. | 355 // permit 2 elements to be kept prerendered. |
322 TEST_F(PrerenderManagerTest, TwoElementPrerenderTest) { | 356 TEST_F(PrerenderTest, TwoElementPrerenderTest) { |
323 prerender_manager()->mutable_config().max_elements = 2; | 357 prerender_manager()->mutable_config().max_elements = 2; |
324 GURL url("http://www.google.com/"); | 358 GURL url("http://www.google.com/"); |
325 DummyPrerenderContents* prerender_contents = | 359 DummyPrerenderContents* prerender_contents = |
326 prerender_manager()->CreateNextPrerenderContents( | 360 prerender_manager()->CreateNextPrerenderContents( |
327 url, | 361 url, |
328 FINAL_STATUS_EVICTED); | 362 FINAL_STATUS_EVICTED); |
329 DummyPrerenderContents* null = NULL; | 363 DummyPrerenderContents* null = NULL; |
330 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 364 EXPECT_TRUE(AddSimplePrerender(url)); |
331 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 365 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
332 EXPECT_TRUE(prerender_contents->has_started()); | 366 EXPECT_TRUE(prerender_contents->has_started()); |
333 | 367 |
334 GURL url1("http://news.google.com/"); | 368 GURL url1("http://news.google.com/"); |
335 DummyPrerenderContents* prerender_contents1 = | 369 DummyPrerenderContents* prerender_contents1 = |
336 prerender_manager()->CreateNextPrerenderContents( | 370 prerender_manager()->CreateNextPrerenderContents( |
337 url1, | 371 url1, |
338 FINAL_STATUS_USED); | 372 FINAL_STATUS_USED); |
339 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1)); | 373 EXPECT_TRUE(AddSimplePrerender(url1)); |
340 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 374 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
341 EXPECT_TRUE(prerender_contents1->has_started()); | 375 EXPECT_TRUE(prerender_contents1->has_started()); |
342 | 376 |
343 GURL url2("http://images.google.com/"); | 377 GURL url2("http://images.google.com/"); |
344 DummyPrerenderContents* prerender_contents2 = | 378 DummyPrerenderContents* prerender_contents2 = |
345 prerender_manager()->CreateNextPrerenderContents( | 379 prerender_manager()->CreateNextPrerenderContents( |
346 url2, | 380 url2, |
347 FINAL_STATUS_USED); | 381 FINAL_STATUS_USED); |
348 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url2)); | 382 EXPECT_TRUE(AddSimplePrerender(url2)); |
349 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 383 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
350 EXPECT_TRUE(prerender_contents2->has_started()); | 384 EXPECT_TRUE(prerender_contents2->has_started()); |
351 | 385 |
352 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | 386 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
353 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); | 387 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); |
354 ASSERT_EQ(prerender_contents2, prerender_manager()->GetEntry(url2)); | 388 ASSERT_EQ(prerender_contents2, prerender_manager()->GetEntry(url2)); |
355 } | 389 } |
356 | 390 |
357 TEST_F(PrerenderManagerTest, AliasURLTest) { | 391 TEST_F(PrerenderTest, AliasURLTest) { |
358 GURL url("http://www.google.com/"); | 392 GURL url("http://www.google.com/"); |
359 GURL alias_url1("http://www.google.com/index.html"); | 393 GURL alias_url1("http://www.google.com/index.html"); |
360 GURL alias_url2("http://google.com/"); | 394 GURL alias_url2("http://google.com/"); |
361 GURL not_an_alias_url("http://google.com/index.html"); | 395 GURL not_an_alias_url("http://google.com/index.html"); |
362 std::vector<GURL> alias_urls; | 396 std::vector<GURL> alias_urls; |
363 alias_urls.push_back(alias_url1); | 397 alias_urls.push_back(alias_url1); |
364 alias_urls.push_back(alias_url2); | 398 alias_urls.push_back(alias_url2); |
365 | 399 |
366 // Test that all of the aliases work, but not_an_alias_url does not. | 400 // Test that all of the aliases work, but not_an_alias_url does not. |
367 DummyPrerenderContents* prerender_contents = | 401 DummyPrerenderContents* prerender_contents = |
368 prerender_manager()->CreateNextPrerenderContents( | 402 prerender_manager()->CreateNextPrerenderContents( |
369 url, alias_urls, FINAL_STATUS_USED); | 403 url, alias_urls, FINAL_STATUS_USED); |
370 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 404 EXPECT_TRUE(AddSimplePrerender(url)); |
371 ASSERT_EQ(NULL, prerender_manager()->GetEntry(not_an_alias_url)); | 405 ASSERT_EQ(NULL, prerender_manager()->GetEntry(not_an_alias_url)); |
372 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url1)); | 406 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url1)); |
373 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | 407 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
374 url, alias_urls, FINAL_STATUS_USED); | 408 url, alias_urls, FINAL_STATUS_USED); |
375 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 409 EXPECT_TRUE(AddSimplePrerender(url)); |
376 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url2)); | 410 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url2)); |
377 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | 411 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
378 url, alias_urls, FINAL_STATUS_USED); | 412 url, alias_urls, FINAL_STATUS_USED); |
379 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 413 EXPECT_TRUE(AddSimplePrerender(url)); |
380 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 414 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
381 | 415 |
382 // Test that alias URLs can not be added. | 416 // Test that alias URLs can not be added. |
383 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | 417 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
384 url, alias_urls, FINAL_STATUS_USED); | 418 url, alias_urls, FINAL_STATUS_USED); |
385 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 419 EXPECT_TRUE(AddSimplePrerender(url)); |
386 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url)); | 420 EXPECT_FALSE(AddSimplePrerender(url)); |
387 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(alias_url1)); | 421 EXPECT_FALSE(AddSimplePrerender(alias_url1)); |
388 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(alias_url2)); | 422 EXPECT_FALSE(AddSimplePrerender(alias_url2)); |
389 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 423 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
390 } | 424 } |
391 | 425 |
392 // Ensure that we ignore prerender requests within the rate limit. | 426 // Ensure that we ignore prerender requests within the rate limit. |
393 TEST_F(PrerenderManagerTest, RateLimitInWindowTest) { | 427 TEST_F(PrerenderTest, RateLimitInWindowTest) { |
394 GURL url("http://www.google.com/"); | 428 GURL url("http://www.google.com/"); |
395 DummyPrerenderContents* prerender_contents = | 429 DummyPrerenderContents* prerender_contents = |
396 prerender_manager()->CreateNextPrerenderContents( | 430 prerender_manager()->CreateNextPrerenderContents( |
397 url, | 431 url, |
398 FINAL_STATUS_MANAGER_SHUTDOWN); | 432 FINAL_STATUS_MANAGER_SHUTDOWN); |
399 DummyPrerenderContents* null = NULL; | 433 DummyPrerenderContents* null = NULL; |
400 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 434 EXPECT_TRUE(AddSimplePrerender(url)); |
401 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 435 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
402 EXPECT_TRUE(prerender_contents->has_started()); | 436 EXPECT_TRUE(prerender_contents->has_started()); |
403 | 437 |
404 prerender_manager()->set_rate_limit_enabled(true); | 438 prerender_manager()->set_rate_limit_enabled(true); |
405 prerender_manager()->AdvanceTimeTicks(base::TimeDelta::FromMilliseconds(1)); | 439 prerender_manager()->AdvanceTimeTicks(base::TimeDelta::FromMilliseconds(1)); |
406 | 440 |
407 GURL url1("http://news.google.com/"); | 441 GURL url1("http://news.google.com/"); |
408 prerender_manager()->CreateNextPrerenderContents( | 442 prerender_manager()->CreateNextPrerenderContents( |
409 url, | 443 url, |
410 FINAL_STATUS_MANAGER_SHUTDOWN); | 444 FINAL_STATUS_MANAGER_SHUTDOWN); |
411 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url1)); | 445 EXPECT_FALSE(AddSimplePrerender(url1)); |
412 prerender_manager()->set_rate_limit_enabled(false); | 446 prerender_manager()->set_rate_limit_enabled(false); |
413 } | 447 } |
414 | 448 |
415 // Ensure that we don't ignore prerender requests outside the rate limit. | 449 // Ensure that we don't ignore prerender requests outside the rate limit. |
416 TEST_F(PrerenderManagerTest, RateLimitOutsideWindowTest) { | 450 TEST_F(PrerenderTest, RateLimitOutsideWindowTest) { |
417 GURL url("http://www.google.com/"); | 451 GURL url("http://www.google.com/"); |
418 DummyPrerenderContents* prerender_contents = | 452 DummyPrerenderContents* prerender_contents = |
419 prerender_manager()->CreateNextPrerenderContents( | 453 prerender_manager()->CreateNextPrerenderContents( |
420 url, | 454 url, |
421 FINAL_STATUS_EVICTED); | 455 FINAL_STATUS_EVICTED); |
422 DummyPrerenderContents* null = NULL; | 456 DummyPrerenderContents* null = NULL; |
423 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 457 EXPECT_TRUE(AddSimplePrerender(url)); |
424 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 458 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
425 EXPECT_TRUE(prerender_contents->has_started()); | 459 EXPECT_TRUE(prerender_contents->has_started()); |
426 | 460 |
427 prerender_manager()->set_rate_limit_enabled(true); | 461 prerender_manager()->set_rate_limit_enabled(true); |
428 prerender_manager()->AdvanceTimeTicks( | 462 prerender_manager()->AdvanceTimeTicks( |
429 base::TimeDelta::FromMilliseconds(2000)); | 463 base::TimeDelta::FromMilliseconds(2000)); |
430 | 464 |
431 GURL url1("http://news.google.com/"); | 465 GURL url1("http://news.google.com/"); |
432 DummyPrerenderContents* rate_limit_prerender_contents = | 466 DummyPrerenderContents* rate_limit_prerender_contents = |
433 prerender_manager()->CreateNextPrerenderContents( | 467 prerender_manager()->CreateNextPrerenderContents( |
434 url1, | 468 url1, |
435 FINAL_STATUS_MANAGER_SHUTDOWN); | 469 FINAL_STATUS_MANAGER_SHUTDOWN); |
436 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1)); | 470 EXPECT_TRUE(AddSimplePrerender(url1)); |
437 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 471 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
438 EXPECT_TRUE(rate_limit_prerender_contents->has_started()); | 472 EXPECT_TRUE(rate_limit_prerender_contents->has_started()); |
439 prerender_manager()->set_rate_limit_enabled(false); | 473 prerender_manager()->set_rate_limit_enabled(false); |
440 } | 474 } |
441 | 475 |
442 TEST_F(PrerenderManagerTest, PendingPrerenderTest) { | 476 TEST_F(PrerenderTest, PendingPrerenderTest) { |
443 GURL url("http://www.google.com/"); | 477 GURL url("http://www.google.com/"); |
444 DummyPrerenderContents* prerender_contents = | 478 DummyPrerenderContents* prerender_contents = |
445 prerender_manager()->CreateNextPrerenderContents( | 479 prerender_manager()->CreateNextPrerenderContents( |
446 url, | 480 url, |
447 FINAL_STATUS_USED); | 481 FINAL_STATUS_USED); |
448 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 482 EXPECT_TRUE(AddSimplePrerender(url)); |
449 | 483 |
450 int child_id; | 484 int child_id; |
451 int route_id; | 485 int route_id; |
452 ASSERT_TRUE(prerender_contents->GetChildId(&child_id)); | 486 ASSERT_TRUE(prerender_contents->GetChildId(&child_id)); |
453 ASSERT_TRUE(prerender_contents->GetRouteId(&route_id)); | 487 ASSERT_TRUE(prerender_contents->GetRouteId(&route_id)); |
454 | 488 |
455 GURL pending_url("http://news.google.com/"); | 489 GURL pending_url("http://news.google.com/"); |
456 | 490 |
457 EXPECT_TRUE(prerender_manager()->AddPrerenderFromLinkRelPrerender( | 491 EXPECT_TRUE(prerender_manager()->AddPrerenderFromLinkRelPrerender( |
458 child_id, route_id, | 492 child_id, route_id, |
459 pending_url, content::Referrer(url, WebKit::WebReferrerPolicyDefault))); | 493 pending_url, content::Referrer(url, WebKit::WebReferrerPolicyDefault))); |
460 | 494 |
461 EXPECT_TRUE(prerender_manager()->IsPendingEntry(pending_url)); | 495 EXPECT_TRUE(prerender_manager()->IsPendingEntry(pending_url)); |
462 EXPECT_TRUE(prerender_contents->has_started()); | 496 EXPECT_TRUE(prerender_contents->has_started()); |
463 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 497 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
464 } | 498 } |
465 | 499 |
466 // Tests that a PrerenderManager created for a browser session in the control | 500 // Tests that a PrerenderManager created for a browser session in the control |
467 // group works as expected. | 501 // group works as expected. |
468 TEST_F(PrerenderManagerTest, ControlGroup) { | 502 TEST_F(PrerenderTest, ControlGroup) { |
469 RestorePrerenderMode restore_prerender_mode; | 503 RestorePrerenderMode restore_prerender_mode; |
470 PrerenderManager::SetMode( | 504 PrerenderManager::SetMode( |
471 PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP); | 505 PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP); |
472 GURL url("http://www.google.com/"); | 506 GURL url("http://www.google.com/"); |
473 DummyPrerenderContents* prerender_contents = | 507 DummyPrerenderContents* prerender_contents = |
474 prerender_manager()->CreateNextPrerenderContents( | 508 prerender_manager()->CreateNextPrerenderContents( |
475 url, | 509 url, |
476 FINAL_STATUS_MANAGER_SHUTDOWN); | 510 FINAL_STATUS_MANAGER_SHUTDOWN); |
477 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 511 EXPECT_TRUE(AddSimplePrerender(url)); |
478 EXPECT_FALSE(prerender_contents->has_started()); | 512 EXPECT_FALSE(prerender_contents->has_started()); |
479 } | 513 } |
480 | 514 |
481 // Tests that prerendering is cancelled when the source render view does not | 515 // Tests that prerendering is cancelled when the source render view does not |
482 // exist. On failure, the DCHECK in CreatePrerenderContents() above should be | 516 // exist. On failure, the DCHECK in CreatePrerenderContents() above should be |
483 // triggered. | 517 // triggered. |
484 TEST_F(PrerenderManagerTest, SourceRenderViewClosed) { | 518 TEST_F(PrerenderTest, SourceRenderViewClosed) { |
485 GURL url("http://www.google.com/"); | 519 GURL url("http://www.google.com/"); |
486 prerender_manager()->CreateNextPrerenderContents( | 520 prerender_manager()->CreateNextPrerenderContents( |
487 url, | 521 url, |
488 FINAL_STATUS_MANAGER_SHUTDOWN); | 522 FINAL_STATUS_MANAGER_SHUTDOWN); |
489 EXPECT_FALSE(prerender_manager()->AddPrerenderFromLinkRelPrerender( | 523 EXPECT_FALSE(prerender_manager()->AddPrerenderFromLinkRelPrerender( |
490 100, 100, url, content::Referrer())); | 524 100, 100, url, content::Referrer())); |
491 } | 525 } |
492 | 526 |
493 // Tests that the prerender manager ignores fragment references when matching | 527 // Tests that the prerender manager ignores fragment references when matching |
494 // prerender URLs in the case the fragment is not in the prerender URL. | 528 // prerender URLs in the case the fragment is not in the prerender URL. |
495 TEST_F(PrerenderManagerTest, PageMatchesFragmentTest) { | 529 TEST_F(PrerenderTest, PageMatchesFragmentTest) { |
496 GURL url("http://www.google.com/"); | 530 GURL url("http://www.google.com/"); |
497 GURL fragment_url("http://www.google.com/#test"); | 531 GURL fragment_url("http://www.google.com/#test"); |
498 | 532 |
499 DummyPrerenderContents* prerender_contents = | 533 DummyPrerenderContents* prerender_contents = |
500 prerender_manager()->CreateNextPrerenderContents(url, | 534 prerender_manager()->CreateNextPrerenderContents(url, |
501 FINAL_STATUS_USED); | 535 FINAL_STATUS_USED); |
502 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 536 EXPECT_TRUE(AddSimplePrerender(url)); |
503 EXPECT_TRUE(prerender_contents->has_started()); | 537 EXPECT_TRUE(prerender_contents->has_started()); |
504 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(fragment_url)); | 538 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(fragment_url)); |
505 } | 539 } |
506 | 540 |
507 // Tests that the prerender manager ignores fragment references when matching | 541 // Tests that the prerender manager ignores fragment references when matching |
508 // prerender URLs in the case the fragment is in the prerender URL. | 542 // prerender URLs in the case the fragment is in the prerender URL. |
509 TEST_F(PrerenderManagerTest, FragmentMatchesPageTest) { | 543 // TODO(gavinp): Re-enable this in the Prerender API once we're officially |
544 // fragment clean. | |
545 TEST_F(PrerenderTest, DISABLED_FragmentMatchesPageTest) { | |
510 GURL url("http://www.google.com/"); | 546 GURL url("http://www.google.com/"); |
511 GURL fragment_url("http://www.google.com/#test"); | 547 GURL fragment_url("http://www.google.com/#test"); |
512 | 548 |
513 DummyPrerenderContents* prerender_contents = | 549 DummyPrerenderContents* prerender_contents = |
514 prerender_manager()->CreateNextPrerenderContents(fragment_url, | 550 prerender_manager()->CreateNextPrerenderContents(fragment_url, |
515 FINAL_STATUS_USED); | 551 FINAL_STATUS_USED); |
516 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(fragment_url)); | 552 EXPECT_TRUE(AddSimplePrerender(fragment_url)); |
517 EXPECT_TRUE(prerender_contents->has_started()); | 553 EXPECT_TRUE(prerender_contents->has_started()); |
518 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 554 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
519 } | 555 } |
520 | 556 |
521 // Tests that the prerender manager ignores fragment references when matching | 557 // Tests that the prerender manager ignores fragment references when matching |
522 // prerender URLs in the case the fragment is in both URLs. | 558 // prerender URLs in the case the fragment is in both URLs. |
523 TEST_F(PrerenderManagerTest, FragmentMatchesFragmentTest) { | 559 // TODO(gavinp): Re-enable this in the Prerender API once we're officially |
560 // fragment clean. | |
561 TEST_F(PrerenderTest, DISABLED_FragmentMatchesFragmentTest) { | |
524 GURL fragment_url("http://www.google.com/#test"); | 562 GURL fragment_url("http://www.google.com/#test"); |
525 GURL other_fragment_url("http://www.google.com/#other_test"); | 563 GURL other_fragment_url("http://www.google.com/#other_test"); |
526 | 564 |
527 DummyPrerenderContents* prerender_contents = | 565 DummyPrerenderContents* prerender_contents = |
528 prerender_manager()->CreateNextPrerenderContents(fragment_url, | 566 prerender_manager()->CreateNextPrerenderContents(fragment_url, |
529 FINAL_STATUS_USED); | 567 FINAL_STATUS_USED); |
530 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(fragment_url)); | 568 EXPECT_TRUE(AddSimplePrerender(fragment_url)); |
531 EXPECT_TRUE(prerender_contents->has_started()); | 569 EXPECT_TRUE(prerender_contents->has_started()); |
532 ASSERT_EQ(prerender_contents, | 570 ASSERT_EQ(prerender_contents, |
533 prerender_manager()->GetEntry(other_fragment_url)); | 571 prerender_manager()->GetEntry(other_fragment_url)); |
534 } | 572 } |
535 | 573 |
536 // Make sure that clearing works as expected. | 574 // Make sure that clearing works as expected. |
537 TEST_F(PrerenderManagerTest, ClearTest) { | 575 TEST_F(PrerenderTest, ClearTest) { |
538 GURL url("http://www.google.com/"); | 576 GURL url("http://www.google.com/"); |
539 DummyPrerenderContents* prerender_contents = | 577 DummyPrerenderContents* prerender_contents = |
540 prerender_manager()->CreateNextPrerenderContents( | 578 prerender_manager()->CreateNextPrerenderContents( |
541 url, | 579 url, |
542 FINAL_STATUS_CACHE_OR_HISTORY_CLEARED); | 580 FINAL_STATUS_CACHE_OR_HISTORY_CLEARED); |
543 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 581 EXPECT_TRUE(AddSimplePrerender(url)); |
544 EXPECT_TRUE(prerender_contents->has_started()); | 582 EXPECT_TRUE(prerender_contents->has_started()); |
545 prerender_manager()->ClearData(PrerenderManager::CLEAR_PRERENDER_CONTENTS); | 583 prerender_manager()->ClearData(PrerenderManager::CLEAR_PRERENDER_CONTENTS); |
546 DummyPrerenderContents* null = NULL; | 584 DummyPrerenderContents* null = NULL; |
547 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | 585 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
548 } | 586 } |
549 | 587 |
550 // Make sure canceling works as expected. | 588 // Make sure canceling works as expected. |
551 TEST_F(PrerenderManagerTest, CancelAllTest) { | 589 TEST_F(PrerenderTest, CancelAllTest) { |
552 GURL url("http://www.google.com/"); | 590 GURL url("http://www.google.com/"); |
553 DummyPrerenderContents* prerender_contents = | 591 DummyPrerenderContents* prerender_contents = |
554 prerender_manager()->CreateNextPrerenderContents( | 592 prerender_manager()->CreateNextPrerenderContents( |
555 url, FINAL_STATUS_CANCELLED); | 593 url, FINAL_STATUS_CANCELLED); |
556 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 594 EXPECT_TRUE(AddSimplePrerender(url)); |
557 EXPECT_TRUE(prerender_contents->has_started()); | 595 EXPECT_TRUE(prerender_contents->has_started()); |
558 prerender_manager()->CancelAllPrerenders(); | 596 prerender_manager()->CancelAllPrerenders(); |
559 const DummyPrerenderContents* null = NULL; | 597 const DummyPrerenderContents* null = NULL; |
560 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | 598 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
561 } | 599 } |
562 | 600 |
563 // Make sure canceling for omnibox works as expected. | 601 // Make sure canceling for omnibox works as expected. |
564 TEST_F(PrerenderManagerTest, CancelOmniboxRemovesOmniboxTest) { | 602 TEST_F(PrerenderTest, CancelOmniboxRemovesOmniboxTest) { |
565 // Check canceling removes the Omnibox url. | 603 // Check canceling removes the Omnibox url. |
566 GURL url("http://www.google.com/"); | 604 GURL url("http://www.google.com/"); |
567 DummyPrerenderContents* prerender_contents = | 605 DummyPrerenderContents* prerender_contents = |
568 prerender_manager()->CreateNextPrerenderContents( | 606 prerender_manager()->CreateNextPrerenderContents( |
569 url, ORIGIN_OMNIBOX, FINAL_STATUS_CANCELLED); | 607 url, ORIGIN_OMNIBOX, FINAL_STATUS_CANCELLED); |
570 EXPECT_TRUE(prerender_manager()->AddPrerenderFromOmnibox(url, NULL)); | 608 EXPECT_TRUE(prerender_manager()->AddPrerenderFromOmnibox(url, NULL)); |
571 EXPECT_TRUE(prerender_contents->has_started()); | 609 EXPECT_TRUE(prerender_contents->has_started()); |
572 prerender_manager()->CancelOmniboxPrerenders(); | 610 prerender_manager()->CancelOmniboxPrerenders(); |
573 const DummyPrerenderContents* null = NULL; | 611 const DummyPrerenderContents* null = NULL; |
574 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); | 612 EXPECT_EQ(null, prerender_manager()->FindEntry(url)); |
575 } | 613 } |
576 | 614 |
577 TEST_F(PrerenderManagerTest, CancelOmniboxDoesNotRemoveLinkTest) { | 615 TEST_F(PrerenderTest, CancelOmniboxDoesNotRemoveLinkTest) { |
578 GURL url("http://www.google.com/"); | 616 GURL url("http://www.google.com/"); |
579 DummyPrerenderContents* prerender_contents = | 617 DummyPrerenderContents* prerender_contents = |
580 prerender_manager()->CreateNextPrerenderContents( | 618 prerender_manager()->CreateNextPrerenderContents( |
581 url, ORIGIN_LINK_REL_PRERENDER, FINAL_STATUS_MANAGER_SHUTDOWN); | 619 url, ORIGIN_LINK_REL_PRERENDER, FINAL_STATUS_MANAGER_SHUTDOWN); |
582 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 620 EXPECT_TRUE(AddSimplePrerender(url)); |
583 EXPECT_TRUE(prerender_contents->has_started()); | 621 EXPECT_TRUE(prerender_contents->has_started()); |
584 prerender_manager()->CancelOmniboxPrerenders(); | 622 prerender_manager()->CancelOmniboxPrerenders(); |
585 const DummyPrerenderContents* null = NULL; | 623 const DummyPrerenderContents* null = NULL; |
586 EXPECT_NE(null, prerender_manager()->FindEntry(url)); | 624 EXPECT_NE(null, prerender_manager()->FindEntry(url)); |
587 } | 625 } |
588 | 626 |
589 TEST_F(PrerenderManagerTest, OmniboxNotAllowedWhenDisabled) { | 627 TEST_F(PrerenderTest, OmniboxNotAllowedWhenDisabled) { |
590 prerender_manager()->set_enabled(false); | 628 prerender_manager()->set_enabled(false); |
591 EXPECT_FALSE(prerender_manager()->AddPrerenderFromOmnibox( | 629 EXPECT_FALSE(prerender_manager()->AddPrerenderFromOmnibox( |
592 GURL("http://www.example.com"), NULL)); | 630 GURL("http://www.example.com"), NULL)); |
593 } | 631 } |
594 | 632 |
595 TEST_F(PrerenderManagerTest, LinkRelNotAllowedWhenDisabled) { | 633 TEST_F(PrerenderTest, LinkRelNotAllowedWhenDisabled) { |
596 prerender_manager()->set_enabled(false); | 634 prerender_manager()->set_enabled(false); |
597 EXPECT_FALSE(prerender_manager()->AddSimplePrerender( | 635 EXPECT_FALSE(AddSimplePrerender( |
598 GURL("http://www.example.com"))); | 636 GURL("http://www.example.com"))); |
599 } | 637 } |
600 | 638 |
639 TEST_F(PrerenderTest, LinkManagerCancel) { | |
640 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
641 GURL url("http://www.myexample.com"); | |
642 DummyPrerenderContents* prerender_contents = | |
643 prerender_manager()->CreateNextPrerenderContents( | |
644 url, | |
645 FINAL_STATUS_CANCELLED); | |
646 EXPECT_TRUE(AddSimplePrerender(url)); | |
647 EXPECT_TRUE(prerender_contents->has_started()); | |
648 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
649 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
650 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
651 kDefaultChildId); | |
652 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | |
653 DummyPrerenderContents* null = NULL; | |
654 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
655 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
656 } | |
657 | |
658 TEST_F(PrerenderTest, LinkManagerCancelTwiceCrash) { | |
659 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
660 GURL url("http://www.myexample.com"); | |
661 DummyPrerenderContents* prerender_contents = | |
662 prerender_manager()->CreateNextPrerenderContents( | |
663 url, | |
664 FINAL_STATUS_CANCELLED); | |
665 EXPECT_TRUE(AddSimplePrerender(url)); | |
666 EXPECT_TRUE(prerender_contents->has_started()); | |
667 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
668 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
669 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
670 kDefaultChildId); | |
671 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
672 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | |
673 DummyPrerenderContents* null = NULL; | |
674 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
675 EXPECT_DEBUG_DEATH( | |
676 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
677 kDefaultChildId), | |
678 "Canceling a prerender that doesn't exist"); | |
679 } | |
680 | |
681 TEST_F(PrerenderTest, LinkManagerAddTwiceCancelTwice) { | |
682 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
683 GURL url("http://www.myexample.com"); | |
684 DummyPrerenderContents* prerender_contents = | |
685 prerender_manager()->CreateNextPrerenderContents( | |
686 url, FINAL_STATUS_CANCELLED); | |
687 EXPECT_TRUE(AddSimplePrerender(url)); | |
688 const int first_prerender_id = last_prerender_id(); | |
689 EXPECT_TRUE(prerender_contents->has_started()); | |
690 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
691 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
692 // The second prerender doesn't successfully add (it's a dupe), but | |
693 // we should still be able to use the |prerender_id| to refer to it | |
694 // after the add, and it should still prevent subsequent removal | |
695 // of the prerender when the first one is canceled. | |
696 EXPECT_FALSE(AddSimplePrerender(url)); | |
697 const int second_prerender_id = last_prerender_id(); | |
698 EXPECT_TRUE(prerender_contents->has_started()); | |
699 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
700 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
701 prerender_link_manager()->OnCancelPrerender(first_prerender_id, | |
702 kDefaultChildId); | |
703 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); | |
704 EXPECT_TRUE(prerender_contents->has_started()); | |
705 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
706 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
707 prerender_link_manager()->OnCancelPrerender(second_prerender_id, | |
708 kDefaultChildId); | |
709 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
710 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | |
711 DummyPrerenderContents* null = NULL; | |
712 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
713 } | |
714 | |
715 TEST_F(PrerenderTest, LinkManagerExpireThenCancel) { | |
716 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
717 GURL url("http://www.myexample.com"); | |
718 DummyPrerenderContents* prerender_contents = | |
719 prerender_manager()->CreateNextPrerenderContents( | |
720 url, | |
721 FINAL_STATUS_TIMED_OUT); | |
722 EXPECT_TRUE(AddSimplePrerender(url)); | |
723 EXPECT_TRUE(prerender_contents->has_started()); | |
724 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
725 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
726 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + | |
727 base::TimeDelta::FromSeconds(1)); | |
728 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); | |
729 DummyPrerenderContents* null = NULL; | |
730 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
731 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
732 kDefaultChildId); | |
733 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
734 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
735 } | |
736 | |
737 TEST_F(PrerenderTest, LinkManagerExpireThenAddAgain) { | |
738 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
739 GURL url("http://www.myexample.com"); | |
740 DummyPrerenderContents* first_prerender_contents = | |
741 prerender_manager()->CreateNextPrerenderContents( | |
742 url, | |
743 FINAL_STATUS_TIMED_OUT); | |
744 EXPECT_TRUE(AddSimplePrerender(url)); | |
745 EXPECT_TRUE(first_prerender_contents->has_started()); | |
746 EXPECT_FALSE(first_prerender_contents->prerendering_has_been_cancelled()); | |
747 ASSERT_EQ(first_prerender_contents, prerender_manager()->FindEntry(url)); | |
748 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + | |
749 base::TimeDelta::FromSeconds(1)); | |
750 DummyPrerenderContents* null = NULL; | |
751 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
752 // Unlike in LinkManagerAddTwiceCancelTwice, we expect this time adding to | |
753 // return true; the prerender has in the meantime been expired by the | |
754 // prerender manager, and so this is an add in the prerender manager sense. | |
755 DummyPrerenderContents* second_prerender_contents = | |
756 prerender_manager()->CreateNextPrerenderContents( | |
757 url, | |
758 FINAL_STATUS_USED); | |
759 EXPECT_TRUE(AddSimplePrerender(url)); | |
760 EXPECT_TRUE(second_prerender_contents->has_started()); | |
761 ASSERT_EQ(second_prerender_contents, prerender_manager()->GetEntry(url)); | |
762 // The PrerenderLinkManager is not empty since we never removed the first | |
763 // prerender. | |
764 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); | |
765 } | |
766 | |
767 TEST_F(PrerenderTest, LinkManagerCancelThenAddAgain) { | |
768 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
769 GURL url("http://www.myexample.com"); | |
770 DummyPrerenderContents* first_prerender_contents = | |
771 prerender_manager()->CreateNextPrerenderContents( | |
772 url, | |
773 FINAL_STATUS_CANCELLED); | |
774 EXPECT_TRUE(AddSimplePrerender(url)); | |
775 EXPECT_TRUE(first_prerender_contents->has_started()); | |
776 EXPECT_FALSE(first_prerender_contents->prerendering_has_been_cancelled()); | |
777 ASSERT_EQ(first_prerender_contents, prerender_manager()->FindEntry(url)); | |
778 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
779 kDefaultChildId); | |
780 EXPECT_TRUE(IsEmptyPrerenderLinkManager()); | |
781 EXPECT_TRUE(first_prerender_contents->prerendering_has_been_cancelled()); | |
782 DummyPrerenderContents* null = NULL; | |
783 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
784 DummyPrerenderContents* second_prerender_contents = | |
785 prerender_manager()->CreateNextPrerenderContents( | |
786 url, | |
787 FINAL_STATUS_USED); | |
788 EXPECT_TRUE(AddSimplePrerender(url)); | |
789 EXPECT_TRUE(second_prerender_contents->has_started()); | |
790 ASSERT_EQ(second_prerender_contents, prerender_manager()->GetEntry(url)); | |
791 EXPECT_FALSE(IsEmptyPrerenderLinkManager()); | |
792 } | |
793 | |
601 } // namespace prerender | 794 } // namespace prerender |
795 | |
OLD | NEW |