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 { | |
68 return PrerenderContents::prerendering_has_been_cancelled(); | |
69 } | |
70 | |
64 private: | 71 private: |
65 bool has_started_; | 72 bool has_started_; |
66 FinalStatus expected_final_status_; | 73 FinalStatus expected_final_status_; |
67 }; | 74 }; |
68 | 75 |
69 class TestPrerenderManager : public PrerenderManager { | 76 class TestPrerenderManager : public PrerenderManager { |
70 public: | 77 public: |
71 explicit TestPrerenderManager(PrerenderTracker* prerender_tracker) | 78 explicit TestPrerenderManager(PrerenderTracker* prerender_tracker) |
72 : PrerenderManager(&profile_, prerender_tracker), | 79 : PrerenderManager(&profile_, prerender_tracker), |
73 time_(base::Time::Now()), | 80 time_(base::Time::Now()), |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
134 expected_final_status); | 141 expected_final_status); |
135 for (std::vector<GURL>::const_iterator it = alias_urls.begin(); | 142 for (std::vector<GURL>::const_iterator it = alias_urls.begin(); |
136 it != alias_urls.end(); | 143 it != alias_urls.end(); |
137 ++it) { | 144 ++it) { |
138 EXPECT_TRUE(prerender_contents->AddAliasURL(*it)); | 145 EXPECT_TRUE(prerender_contents->AddAliasURL(*it)); |
139 } | 146 } |
140 SetNextPrerenderContents(prerender_contents); | 147 SetNextPrerenderContents(prerender_contents); |
141 return prerender_contents; | 148 return prerender_contents; |
142 } | 149 } |
143 | 150 |
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) { | 151 void set_rate_limit_enabled(bool enabled) { |
152 mutable_config().rate_limit_enabled = enabled; | 152 mutable_config().rate_limit_enabled = enabled; |
153 } | 153 } |
154 | 154 |
155 PrerenderContents* next_prerender_contents() { | 155 PrerenderContents* next_prerender_contents() { |
156 return next_prerender_contents_.get(); | 156 return next_prerender_contents_.get(); |
157 } | 157 } |
158 | 158 |
159 private: | 159 private: |
160 void SetNextPrerenderContents(DummyPrerenderContents* prerender_contents) { | 160 void SetNextPrerenderContents(DummyPrerenderContents* prerender_contents) { |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
200 RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) { | 200 RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) { |
201 } | 201 } |
202 | 202 |
203 ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); } | 203 ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); } |
204 private: | 204 private: |
205 PrerenderManager::PrerenderManagerMode prev_mode_; | 205 PrerenderManager::PrerenderManagerMode prev_mode_; |
206 }; | 206 }; |
207 | 207 |
208 } // namespace | 208 } // namespace |
209 | 209 |
210 class PrerenderManagerTest : public testing::Test { | 210 class PrerenderTest : public testing::Test { |
211 public: | 211 public: |
212 PrerenderManagerTest() : ui_thread_(BrowserThread::UI, &message_loop_), | 212 static const int kDefaultChildId = -1; |
213 prerender_manager_( | 213 static const int kDefaultRenderViewRouteId = -1; |
214 new TestPrerenderManager(prerender_tracker())) { | 214 |
215 PrerenderTest() : ui_thread_(BrowserThread::UI, &message_loop_), | |
216 prerender_manager_( | |
217 new TestPrerenderManager(prerender_tracker())), | |
218 prerender_link_manager_( | |
219 new PrerenderLinkManager(prerender_manager_.get())), | |
220 last_prerender_id_(0) { | |
215 // Enable omnibox prerendering. | 221 // Enable omnibox prerendering. |
216 CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 222 CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
217 switches::kPrerenderFromOmnibox, | 223 switches::kPrerenderFromOmnibox, |
218 switches::kPrerenderFromOmniboxSwitchValueEnabled); | 224 switches::kPrerenderFromOmniboxSwitchValueEnabled); |
219 } | 225 } |
220 | 226 |
221 TestPrerenderManager* prerender_manager() { | 227 TestPrerenderManager* prerender_manager() { |
222 return prerender_manager_.get(); | 228 return prerender_manager_.get(); |
223 } | 229 } |
224 | 230 |
231 PrerenderLinkManager* prerender_link_manager() { | |
232 return prerender_link_manager_.get(); | |
233 } | |
234 | |
235 int last_prerender_id() const { | |
236 return last_prerender_id_; | |
237 } | |
238 | |
239 // Shorthand to add a simple preload with a reasonable source. | |
240 bool AddSimplePrerender(const GURL& url) { | |
241 prerender_link_manager()->OnAddPrerender(GetNextPrerenderID(), | |
242 kDefaultChildId, | |
243 url, | |
244 content::Referrer(), | |
245 gfx::Size(0,0), | |
246 kDefaultRenderViewRouteId); | |
247 return prerender_manager()->IsPrerendering(url); | |
248 } | |
249 | |
250 bool AddSimplePrerenderViaManager(const GURL& url) { | |
mmenke
2012/04/24 15:26:15
This is little weird. Since all link rel prerende
gavinp
2012/04/26 23:55:39
Done, with the second option.
| |
251 return prerender_manager()->AddPrerenderFromLinkRelPrerender( | |
252 kDefaultChildId, kDefaultRenderViewRouteId, url, content::Referrer()); | |
253 } | |
254 | |
225 private: | 255 private: |
256 int GetNextPrerenderID() { | |
257 ++last_prerender_id_; | |
258 return last_prerender_id_; | |
259 } | |
260 | |
226 PrerenderTracker* prerender_tracker() { | 261 PrerenderTracker* prerender_tracker() { |
227 return g_browser_process->prerender_tracker(); | 262 return g_browser_process->prerender_tracker(); |
228 } | 263 } |
229 | 264 |
230 // Needed to pass PrerenderManager's DCHECKs. | 265 // Needed to pass PrerenderManager's DCHECKs. |
231 MessageLoop message_loop_; | 266 MessageLoop message_loop_; |
232 content::TestBrowserThread ui_thread_; | 267 content::TestBrowserThread ui_thread_; |
233 scoped_ptr<TestPrerenderManager> prerender_manager_; | 268 scoped_ptr<TestPrerenderManager> prerender_manager_; |
269 scoped_ptr<PrerenderLinkManager> prerender_link_manager_; | |
270 int last_prerender_id_; | |
234 }; | 271 }; |
235 | 272 |
236 TEST_F(PrerenderManagerTest, EmptyTest) { | 273 TEST_F(PrerenderTest, EmptyTest) { |
237 EXPECT_FALSE(prerender_manager()->MaybeUsePrerenderedPage( | 274 EXPECT_FALSE(prerender_manager()->MaybeUsePrerenderedPage( |
238 NULL, | 275 NULL, |
239 GURL("http://www.google.com/"))); | 276 GURL("http://www.google.com/"))); |
240 } | 277 } |
241 | 278 |
242 TEST_F(PrerenderManagerTest, FoundTest) { | 279 TEST_F(PrerenderTest, FoundTest) { |
243 GURL url("http://www.google.com/"); | 280 GURL url("http://www.google.com/"); |
244 DummyPrerenderContents* prerender_contents = | 281 DummyPrerenderContents* prerender_contents = |
245 prerender_manager()->CreateNextPrerenderContents( | 282 prerender_manager()->CreateNextPrerenderContents( |
246 url, | 283 url, |
247 FINAL_STATUS_USED); | 284 FINAL_STATUS_USED); |
248 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 285 EXPECT_TRUE(AddSimplePrerender(url)); |
249 EXPECT_TRUE(prerender_contents->has_started()); | 286 EXPECT_TRUE(prerender_contents->has_started()); |
250 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 287 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
251 } | 288 } |
252 | 289 |
253 // Make sure that if queue a request, and a second prerender request for the | 290 // 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. | 291 // same URL comes in, that we drop the second request and keep the first one. |
255 TEST_F(PrerenderManagerTest, DropSecondRequestTest) { | 292 TEST_F(PrerenderTest, DropSecondRequestTest) { |
256 GURL url("http://www.google.com/"); | 293 GURL url("http://www.google.com/"); |
257 DummyPrerenderContents* prerender_contents = | 294 DummyPrerenderContents* prerender_contents = |
258 prerender_manager()->CreateNextPrerenderContents( | 295 prerender_manager()->CreateNextPrerenderContents( |
259 url, | 296 url, |
260 FINAL_STATUS_USED); | 297 FINAL_STATUS_USED); |
261 DummyPrerenderContents* null = NULL; | 298 DummyPrerenderContents* null = NULL; |
262 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 299 EXPECT_TRUE(AddSimplePrerender(url)); |
263 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 300 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
264 EXPECT_TRUE(prerender_contents->has_started()); | 301 EXPECT_TRUE(prerender_contents->has_started()); |
265 | 302 |
266 DummyPrerenderContents* prerender_contents1 = | 303 DummyPrerenderContents* prerender_contents1 = |
267 prerender_manager()->CreateNextPrerenderContents( | 304 prerender_manager()->CreateNextPrerenderContents( |
268 url, | 305 url, |
269 FINAL_STATUS_MANAGER_SHUTDOWN); | 306 FINAL_STATUS_MANAGER_SHUTDOWN); |
270 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url)); | 307 EXPECT_FALSE(AddSimplePrerenderViaManager(url)); |
271 EXPECT_EQ(prerender_contents1, | 308 EXPECT_EQ(prerender_contents1, |
272 prerender_manager()->next_prerender_contents()); | 309 prerender_manager()->next_prerender_contents()); |
273 EXPECT_FALSE(prerender_contents1->has_started()); | 310 EXPECT_FALSE(prerender_contents1->has_started()); |
274 | 311 |
275 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 312 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
276 } | 313 } |
277 | 314 |
278 // Ensure that we expire a prerendered page after the max. permitted time. | 315 // Ensure that we expire a prerendered page after the max. permitted time. |
279 TEST_F(PrerenderManagerTest, ExpireTest) { | 316 TEST_F(PrerenderTest, ExpireTest) { |
280 GURL url("http://www.google.com/"); | 317 GURL url("http://www.google.com/"); |
281 DummyPrerenderContents* prerender_contents = | 318 DummyPrerenderContents* prerender_contents = |
282 prerender_manager()->CreateNextPrerenderContents( | 319 prerender_manager()->CreateNextPrerenderContents( |
283 url, | 320 url, |
284 FINAL_STATUS_TIMED_OUT); | 321 FINAL_STATUS_TIMED_OUT); |
285 DummyPrerenderContents* null = NULL; | 322 DummyPrerenderContents* null = NULL; |
286 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 323 EXPECT_TRUE(AddSimplePrerender(url)); |
287 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 324 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
288 EXPECT_TRUE(prerender_contents->has_started()); | 325 EXPECT_TRUE(prerender_contents->has_started()); |
289 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + | 326 prerender_manager()->AdvanceTime(prerender_manager()->GetMaxAge() + |
290 base::TimeDelta::FromSeconds(1)); | 327 base::TimeDelta::FromSeconds(1)); |
291 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | 328 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
292 } | 329 } |
293 | 330 |
294 // LRU Test. Make sure that if we prerender more than one request, that | 331 // LRU Test. Make sure that if we prerender more than one request, that |
295 // the oldest one will be dropped. | 332 // the oldest one will be dropped. |
296 TEST_F(PrerenderManagerTest, DropOldestRequestTest) { | 333 TEST_F(PrerenderTest, DropOldestRequestTest) { |
297 GURL url("http://www.google.com/"); | 334 GURL url("http://www.google.com/"); |
298 DummyPrerenderContents* prerender_contents = | 335 DummyPrerenderContents* prerender_contents = |
299 prerender_manager()->CreateNextPrerenderContents( | 336 prerender_manager()->CreateNextPrerenderContents( |
300 url, | 337 url, |
301 FINAL_STATUS_EVICTED); | 338 FINAL_STATUS_EVICTED); |
302 DummyPrerenderContents* null = NULL; | 339 DummyPrerenderContents* null = NULL; |
303 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 340 EXPECT_TRUE(AddSimplePrerender(url)); |
304 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 341 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
305 EXPECT_TRUE(prerender_contents->has_started()); | 342 EXPECT_TRUE(prerender_contents->has_started()); |
306 | 343 |
307 GURL url1("http://news.google.com/"); | 344 GURL url1("http://news.google.com/"); |
308 DummyPrerenderContents* prerender_contents1 = | 345 DummyPrerenderContents* prerender_contents1 = |
309 prerender_manager()->CreateNextPrerenderContents( | 346 prerender_manager()->CreateNextPrerenderContents( |
310 url1, | 347 url1, |
311 FINAL_STATUS_USED); | 348 FINAL_STATUS_USED); |
312 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1)); | 349 EXPECT_TRUE(AddSimplePrerender(url1)); |
313 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 350 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
314 EXPECT_TRUE(prerender_contents1->has_started()); | 351 EXPECT_TRUE(prerender_contents1->has_started()); |
315 | 352 |
316 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | 353 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
317 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); | 354 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); |
318 } | 355 } |
319 | 356 |
320 // Two element prerender test. Ensure that the LRU operates correctly if we | 357 // Two element prerender test. Ensure that the LRU operates correctly if we |
321 // permit 2 elements to be kept prerendered. | 358 // permit 2 elements to be kept prerendered. |
322 TEST_F(PrerenderManagerTest, TwoElementPrerenderTest) { | 359 TEST_F(PrerenderTest, TwoElementPrerenderTest) { |
323 prerender_manager()->mutable_config().max_elements = 2; | 360 prerender_manager()->mutable_config().max_elements = 2; |
324 GURL url("http://www.google.com/"); | 361 GURL url("http://www.google.com/"); |
325 DummyPrerenderContents* prerender_contents = | 362 DummyPrerenderContents* prerender_contents = |
326 prerender_manager()->CreateNextPrerenderContents( | 363 prerender_manager()->CreateNextPrerenderContents( |
327 url, | 364 url, |
328 FINAL_STATUS_EVICTED); | 365 FINAL_STATUS_EVICTED); |
329 DummyPrerenderContents* null = NULL; | 366 DummyPrerenderContents* null = NULL; |
330 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 367 EXPECT_TRUE(AddSimplePrerender(url)); |
331 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 368 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
332 EXPECT_TRUE(prerender_contents->has_started()); | 369 EXPECT_TRUE(prerender_contents->has_started()); |
333 | 370 |
334 GURL url1("http://news.google.com/"); | 371 GURL url1("http://news.google.com/"); |
335 DummyPrerenderContents* prerender_contents1 = | 372 DummyPrerenderContents* prerender_contents1 = |
336 prerender_manager()->CreateNextPrerenderContents( | 373 prerender_manager()->CreateNextPrerenderContents( |
337 url1, | 374 url1, |
338 FINAL_STATUS_USED); | 375 FINAL_STATUS_USED); |
339 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1)); | 376 EXPECT_TRUE(AddSimplePrerender(url1)); |
340 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 377 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
341 EXPECT_TRUE(prerender_contents1->has_started()); | 378 EXPECT_TRUE(prerender_contents1->has_started()); |
342 | 379 |
343 GURL url2("http://images.google.com/"); | 380 GURL url2("http://images.google.com/"); |
344 DummyPrerenderContents* prerender_contents2 = | 381 DummyPrerenderContents* prerender_contents2 = |
345 prerender_manager()->CreateNextPrerenderContents( | 382 prerender_manager()->CreateNextPrerenderContents( |
346 url2, | 383 url2, |
347 FINAL_STATUS_USED); | 384 FINAL_STATUS_USED); |
348 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url2)); | 385 EXPECT_TRUE(AddSimplePrerender(url2)); |
349 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 386 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
350 EXPECT_TRUE(prerender_contents2->has_started()); | 387 EXPECT_TRUE(prerender_contents2->has_started()); |
351 | 388 |
352 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | 389 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); |
353 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); | 390 ASSERT_EQ(prerender_contents1, prerender_manager()->GetEntry(url1)); |
354 ASSERT_EQ(prerender_contents2, prerender_manager()->GetEntry(url2)); | 391 ASSERT_EQ(prerender_contents2, prerender_manager()->GetEntry(url2)); |
355 } | 392 } |
356 | 393 |
357 TEST_F(PrerenderManagerTest, AliasURLTest) { | 394 TEST_F(PrerenderTest, AliasURLTest) { |
358 GURL url("http://www.google.com/"); | 395 GURL url("http://www.google.com/"); |
359 GURL alias_url1("http://www.google.com/index.html"); | 396 GURL alias_url1("http://www.google.com/index.html"); |
360 GURL alias_url2("http://google.com/"); | 397 GURL alias_url2("http://google.com/"); |
361 GURL not_an_alias_url("http://google.com/index.html"); | 398 GURL not_an_alias_url("http://google.com/index.html"); |
362 std::vector<GURL> alias_urls; | 399 std::vector<GURL> alias_urls; |
363 alias_urls.push_back(alias_url1); | 400 alias_urls.push_back(alias_url1); |
364 alias_urls.push_back(alias_url2); | 401 alias_urls.push_back(alias_url2); |
365 | 402 |
366 // Test that all of the aliases work, but not_an_alias_url does not. | 403 // Test that all of the aliases work, but not_an_alias_url does not. |
367 DummyPrerenderContents* prerender_contents = | 404 DummyPrerenderContents* prerender_contents = |
368 prerender_manager()->CreateNextPrerenderContents( | 405 prerender_manager()->CreateNextPrerenderContents( |
369 url, alias_urls, FINAL_STATUS_USED); | 406 url, alias_urls, FINAL_STATUS_USED); |
370 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 407 EXPECT_TRUE(AddSimplePrerender(url)); |
371 ASSERT_EQ(NULL, prerender_manager()->GetEntry(not_an_alias_url)); | 408 ASSERT_EQ(NULL, prerender_manager()->GetEntry(not_an_alias_url)); |
372 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url1)); | 409 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url1)); |
373 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | 410 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
374 url, alias_urls, FINAL_STATUS_USED); | 411 url, alias_urls, FINAL_STATUS_USED); |
375 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 412 EXPECT_TRUE(AddSimplePrerender(url)); |
376 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url2)); | 413 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(alias_url2)); |
377 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | 414 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
378 url, alias_urls, FINAL_STATUS_USED); | 415 url, alias_urls, FINAL_STATUS_USED); |
379 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 416 EXPECT_TRUE(AddSimplePrerender(url)); |
380 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 417 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
381 | 418 |
382 // Test that alias URLs can not be added. | 419 // Test that alias URLs can not be added. |
383 prerender_contents = prerender_manager()->CreateNextPrerenderContents( | 420 prerender_contents = prerender_manager()->CreateNextPrerenderContents( |
384 url, alias_urls, FINAL_STATUS_USED); | 421 url, alias_urls, FINAL_STATUS_USED); |
385 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 422 EXPECT_TRUE(AddSimplePrerender(url)); |
386 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url)); | 423 EXPECT_FALSE(AddSimplePrerenderViaManager(url)); |
387 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(alias_url1)); | 424 EXPECT_FALSE(AddSimplePrerenderViaManager(alias_url1)); |
388 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(alias_url2)); | 425 EXPECT_FALSE(AddSimplePrerenderViaManager(alias_url2)); |
389 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 426 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
390 } | 427 } |
391 | 428 |
392 // Ensure that we ignore prerender requests within the rate limit. | 429 // Ensure that we ignore prerender requests within the rate limit. |
393 TEST_F(PrerenderManagerTest, RateLimitInWindowTest) { | 430 TEST_F(PrerenderTest, RateLimitInWindowTest) { |
394 GURL url("http://www.google.com/"); | 431 GURL url("http://www.google.com/"); |
395 DummyPrerenderContents* prerender_contents = | 432 DummyPrerenderContents* prerender_contents = |
396 prerender_manager()->CreateNextPrerenderContents( | 433 prerender_manager()->CreateNextPrerenderContents( |
397 url, | 434 url, |
398 FINAL_STATUS_MANAGER_SHUTDOWN); | 435 FINAL_STATUS_MANAGER_SHUTDOWN); |
399 DummyPrerenderContents* null = NULL; | 436 DummyPrerenderContents* null = NULL; |
400 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 437 EXPECT_TRUE(AddSimplePrerender(url)); |
401 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 438 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
402 EXPECT_TRUE(prerender_contents->has_started()); | 439 EXPECT_TRUE(prerender_contents->has_started()); |
403 | 440 |
404 prerender_manager()->set_rate_limit_enabled(true); | 441 prerender_manager()->set_rate_limit_enabled(true); |
405 prerender_manager()->AdvanceTimeTicks(base::TimeDelta::FromMilliseconds(1)); | 442 prerender_manager()->AdvanceTimeTicks(base::TimeDelta::FromMilliseconds(1)); |
406 | 443 |
407 GURL url1("http://news.google.com/"); | 444 GURL url1("http://news.google.com/"); |
408 prerender_manager()->CreateNextPrerenderContents( | 445 prerender_manager()->CreateNextPrerenderContents( |
409 url, | 446 url, |
410 FINAL_STATUS_MANAGER_SHUTDOWN); | 447 FINAL_STATUS_MANAGER_SHUTDOWN); |
411 EXPECT_FALSE(prerender_manager()->AddSimplePrerender(url1)); | 448 EXPECT_FALSE(AddSimplePrerender(url1)); |
412 prerender_manager()->set_rate_limit_enabled(false); | 449 prerender_manager()->set_rate_limit_enabled(false); |
413 } | 450 } |
414 | 451 |
415 // Ensure that we don't ignore prerender requests outside the rate limit. | 452 // Ensure that we don't ignore prerender requests outside the rate limit. |
416 TEST_F(PrerenderManagerTest, RateLimitOutsideWindowTest) { | 453 TEST_F(PrerenderTest, RateLimitOutsideWindowTest) { |
417 GURL url("http://www.google.com/"); | 454 GURL url("http://www.google.com/"); |
418 DummyPrerenderContents* prerender_contents = | 455 DummyPrerenderContents* prerender_contents = |
419 prerender_manager()->CreateNextPrerenderContents( | 456 prerender_manager()->CreateNextPrerenderContents( |
420 url, | 457 url, |
421 FINAL_STATUS_EVICTED); | 458 FINAL_STATUS_EVICTED); |
422 DummyPrerenderContents* null = NULL; | 459 DummyPrerenderContents* null = NULL; |
423 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 460 EXPECT_TRUE(AddSimplePrerender(url)); |
424 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 461 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
425 EXPECT_TRUE(prerender_contents->has_started()); | 462 EXPECT_TRUE(prerender_contents->has_started()); |
426 | 463 |
427 prerender_manager()->set_rate_limit_enabled(true); | 464 prerender_manager()->set_rate_limit_enabled(true); |
428 prerender_manager()->AdvanceTimeTicks( | 465 prerender_manager()->AdvanceTimeTicks( |
429 base::TimeDelta::FromMilliseconds(2000)); | 466 base::TimeDelta::FromMilliseconds(2000)); |
430 | 467 |
431 GURL url1("http://news.google.com/"); | 468 GURL url1("http://news.google.com/"); |
432 DummyPrerenderContents* rate_limit_prerender_contents = | 469 DummyPrerenderContents* rate_limit_prerender_contents = |
433 prerender_manager()->CreateNextPrerenderContents( | 470 prerender_manager()->CreateNextPrerenderContents( |
434 url1, | 471 url1, |
435 FINAL_STATUS_MANAGER_SHUTDOWN); | 472 FINAL_STATUS_MANAGER_SHUTDOWN); |
436 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url1)); | 473 EXPECT_TRUE(AddSimplePrerender(url1)); |
437 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); | 474 EXPECT_EQ(null, prerender_manager()->next_prerender_contents()); |
438 EXPECT_TRUE(rate_limit_prerender_contents->has_started()); | 475 EXPECT_TRUE(rate_limit_prerender_contents->has_started()); |
439 prerender_manager()->set_rate_limit_enabled(false); | 476 prerender_manager()->set_rate_limit_enabled(false); |
440 } | 477 } |
441 | 478 |
442 TEST_F(PrerenderManagerTest, PendingPrerenderTest) { | 479 TEST_F(PrerenderTest, PendingPrerenderTest) { |
443 GURL url("http://www.google.com/"); | 480 GURL url("http://www.google.com/"); |
444 DummyPrerenderContents* prerender_contents = | 481 DummyPrerenderContents* prerender_contents = |
445 prerender_manager()->CreateNextPrerenderContents( | 482 prerender_manager()->CreateNextPrerenderContents( |
446 url, | 483 url, |
447 FINAL_STATUS_USED); | 484 FINAL_STATUS_USED); |
448 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 485 EXPECT_TRUE(AddSimplePrerender(url)); |
449 | 486 |
450 int child_id; | 487 int child_id; |
451 int route_id; | 488 int route_id; |
452 ASSERT_TRUE(prerender_contents->GetChildId(&child_id)); | 489 ASSERT_TRUE(prerender_contents->GetChildId(&child_id)); |
453 ASSERT_TRUE(prerender_contents->GetRouteId(&route_id)); | 490 ASSERT_TRUE(prerender_contents->GetRouteId(&route_id)); |
454 | 491 |
455 GURL pending_url("http://news.google.com/"); | 492 GURL pending_url("http://news.google.com/"); |
456 | 493 |
457 EXPECT_TRUE(prerender_manager()->AddPrerenderFromLinkRelPrerender( | 494 EXPECT_TRUE(prerender_manager()->AddPrerenderFromLinkRelPrerender( |
458 child_id, route_id, | 495 child_id, route_id, |
459 pending_url, content::Referrer(url, WebKit::WebReferrerPolicyDefault))); | 496 pending_url, content::Referrer(url, WebKit::WebReferrerPolicyDefault))); |
460 | 497 |
461 EXPECT_TRUE(prerender_manager()->IsPendingEntry(pending_url)); | 498 EXPECT_TRUE(prerender_manager()->IsPendingEntry(pending_url)); |
462 EXPECT_TRUE(prerender_contents->has_started()); | 499 EXPECT_TRUE(prerender_contents->has_started()); |
463 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 500 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
464 } | 501 } |
465 | 502 |
466 // Tests that a PrerenderManager created for a browser session in the control | 503 // Tests that a PrerenderManager created for a browser session in the control |
467 // group works as expected. | 504 // group works as expected. |
468 TEST_F(PrerenderManagerTest, ControlGroup) { | 505 TEST_F(PrerenderTest, ControlGroup) { |
469 RestorePrerenderMode restore_prerender_mode; | 506 RestorePrerenderMode restore_prerender_mode; |
470 PrerenderManager::SetMode( | 507 PrerenderManager::SetMode( |
471 PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP); | 508 PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP); |
472 GURL url("http://www.google.com/"); | 509 GURL url("http://www.google.com/"); |
473 DummyPrerenderContents* prerender_contents = | 510 DummyPrerenderContents* prerender_contents = |
474 prerender_manager()->CreateNextPrerenderContents( | 511 prerender_manager()->CreateNextPrerenderContents( |
475 url, | 512 url, |
476 FINAL_STATUS_MANAGER_SHUTDOWN); | 513 FINAL_STATUS_MANAGER_SHUTDOWN); |
477 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 514 EXPECT_TRUE(AddSimplePrerender(url)); |
478 EXPECT_FALSE(prerender_contents->has_started()); | 515 EXPECT_FALSE(prerender_contents->has_started()); |
479 } | 516 } |
480 | 517 |
481 // Tests that prerendering is cancelled when the source render view does not | 518 // Tests that prerendering is cancelled when the source render view does not |
482 // exist. On failure, the DCHECK in CreatePrerenderContents() above should be | 519 // exist. On failure, the DCHECK in CreatePrerenderContents() above should be |
483 // triggered. | 520 // triggered. |
484 TEST_F(PrerenderManagerTest, SourceRenderViewClosed) { | 521 TEST_F(PrerenderTest, SourceRenderViewClosed) { |
485 GURL url("http://www.google.com/"); | 522 GURL url("http://www.google.com/"); |
486 prerender_manager()->CreateNextPrerenderContents( | 523 prerender_manager()->CreateNextPrerenderContents( |
487 url, | 524 url, |
488 FINAL_STATUS_MANAGER_SHUTDOWN); | 525 FINAL_STATUS_MANAGER_SHUTDOWN); |
489 EXPECT_FALSE(prerender_manager()->AddPrerenderFromLinkRelPrerender( | 526 EXPECT_FALSE(prerender_manager()->AddPrerenderFromLinkRelPrerender( |
490 100, 100, url, content::Referrer())); | 527 100, 100, url, content::Referrer())); |
491 } | 528 } |
492 | 529 |
493 // Tests that the prerender manager ignores fragment references when matching | 530 // Tests that the prerender manager ignores fragment references when matching |
494 // prerender URLs in the case the fragment is not in the prerender URL. | 531 // prerender URLs in the case the fragment is not in the prerender URL. |
495 TEST_F(PrerenderManagerTest, PageMatchesFragmentTest) { | 532 TEST_F(PrerenderTest, PageMatchesFragmentTest) { |
496 GURL url("http://www.google.com/"); | 533 GURL url("http://www.google.com/"); |
497 GURL fragment_url("http://www.google.com/#test"); | 534 GURL fragment_url("http://www.google.com/#test"); |
498 | 535 |
499 DummyPrerenderContents* prerender_contents = | 536 DummyPrerenderContents* prerender_contents = |
500 prerender_manager()->CreateNextPrerenderContents(url, | 537 prerender_manager()->CreateNextPrerenderContents(url, |
501 FINAL_STATUS_USED); | 538 FINAL_STATUS_USED); |
502 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(url)); | 539 EXPECT_TRUE(AddSimplePrerender(url)); |
503 EXPECT_TRUE(prerender_contents->has_started()); | 540 EXPECT_TRUE(prerender_contents->has_started()); |
504 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(fragment_url)); | 541 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(fragment_url)); |
505 } | 542 } |
506 | 543 |
507 // Tests that the prerender manager ignores fragment references when matching | 544 // Tests that the prerender manager ignores fragment references when matching |
508 // prerender URLs in the case the fragment is in the prerender URL. | 545 // prerender URLs in the case the fragment is in the prerender URL. |
509 TEST_F(PrerenderManagerTest, FragmentMatchesPageTest) { | 546 TEST_F(PrerenderTest, FragmentMatchesPageTest) { |
510 GURL url("http://www.google.com/"); | 547 GURL url("http://www.google.com/"); |
511 GURL fragment_url("http://www.google.com/#test"); | 548 GURL fragment_url("http://www.google.com/#test"); |
512 | 549 |
513 DummyPrerenderContents* prerender_contents = | 550 DummyPrerenderContents* prerender_contents = |
514 prerender_manager()->CreateNextPrerenderContents(fragment_url, | 551 prerender_manager()->CreateNextPrerenderContents(fragment_url, |
515 FINAL_STATUS_USED); | 552 FINAL_STATUS_USED); |
516 EXPECT_TRUE(prerender_manager()->AddSimplePrerender(fragment_url)); | 553 EXPECT_TRUE(AddSimplePrerenderViaManager(fragment_url)); |
517 EXPECT_TRUE(prerender_contents->has_started()); | 554 EXPECT_TRUE(prerender_contents->has_started()); |
518 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); | 555 ASSERT_EQ(prerender_contents, prerender_manager()->GetEntry(url)); |
519 } | 556 } |
520 | 557 |
521 // Tests that the prerender manager ignores fragment references when matching | 558 // Tests that the prerender manager ignores fragment references when matching |
522 // prerender URLs in the case the fragment is in both URLs. | 559 // prerender URLs in the case the fragment is in both URLs. |
523 TEST_F(PrerenderManagerTest, FragmentMatchesFragmentTest) { | 560 TEST_F(PrerenderTest, 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(AddSimplePrerenderViaManager(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) { | |
mmenke
2012/04/24 15:26:15
Other test suggestions:
Cancel a prerender that's
gavinp
2012/04/26 23:55:39
Yes, but expired instead of cancelled.
| |
639 GURL url("http://www.myexample.com"); | |
640 DummyPrerenderContents* prerender_contents = | |
641 prerender_manager()->CreateNextPrerenderContents( | |
642 url, | |
643 FINAL_STATUS_CANCELLED); | |
644 EXPECT_TRUE(AddSimplePrerender(url)); | |
645 EXPECT_TRUE(prerender_contents->has_started()); | |
646 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
647 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
648 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
649 kDefaultChildId); | |
650 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | |
651 DummyPrerenderContents* null = NULL; | |
652 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
653 | |
654 } | |
655 | |
656 TEST_F(PrerenderTest, LinkManagerCancelTwiceCrash) { | |
657 GURL url("http://www.myexample.com"); | |
658 DummyPrerenderContents* prerender_contents = | |
659 prerender_manager()->CreateNextPrerenderContents( | |
660 url, | |
661 FINAL_STATUS_CANCELLED); | |
662 EXPECT_TRUE(AddSimplePrerender(url)); | |
663 EXPECT_TRUE(prerender_contents->has_started()); | |
664 EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled()); | |
665 ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url)); | |
666 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
667 kDefaultChildId); | |
668 EXPECT_TRUE(prerender_contents->prerendering_has_been_cancelled()); | |
669 DummyPrerenderContents* null = NULL; | |
670 ASSERT_EQ(null, prerender_manager()->GetEntry(url)); | |
671 EXPECT_DEBUG_DEATH( | |
672 prerender_link_manager()->OnCancelPrerender(last_prerender_id(), | |
673 kDefaultChildId), | |
674 "Canceling a prerender that doesn't exist"); | |
675 | |
676 } | |
677 | |
601 } // namespace prerender | 678 } // namespace prerender |
OLD | NEW |