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