OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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 "chrome/browser/android/offline_pages/offline_page_utils.h" | 5 #include "chrome/browser/android/offline_pages/offline_page_utils.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/callback.h" | 10 #include "base/callback.h" |
11 #include "base/command_line.h" | 11 #include "base/command_line.h" |
12 #include "base/files/file.h" | 12 #include "base/files/file.h" |
13 #include "base/files/file_path.h" | 13 #include "base/files/file_path.h" |
14 #include "base/files/file_util.h" | 14 #include "base/files/file_util.h" |
15 #include "base/memory/ptr_util.h" | 15 #include "base/memory/ptr_util.h" |
16 #include "base/run_loop.h" | 16 #include "base/run_loop.h" |
17 #include "base/strings/string16.h" | 17 #include "base/strings/string16.h" |
18 #include "base/test/scoped_feature_list.h" | 18 #include "base/test/scoped_feature_list.h" |
| 19 #include "base/test/simple_test_clock.h" |
19 #include "base/threading/thread_task_runner_handle.h" | 20 #include "base/threading/thread_task_runner_handle.h" |
20 #include "base/time/time.h" | 21 #include "base/time/time.h" |
21 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h" | 22 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h" |
22 #include "chrome/browser/android/offline_pages/offline_page_tab_helper.h" | 23 #include "chrome/browser/android/offline_pages/offline_page_tab_helper.h" |
23 #include "chrome/browser/android/offline_pages/request_coordinator_factory.h" | 24 #include "chrome/browser/android/offline_pages/request_coordinator_factory.h" |
24 #include "chrome/browser/android/offline_pages/test_offline_page_model_builder.h
" | 25 #include "chrome/browser/android/offline_pages/test_offline_page_model_builder.h
" |
25 #include "chrome/browser/android/offline_pages/test_request_coordinator_builder.
h" | 26 #include "chrome/browser/android/offline_pages/test_request_coordinator_builder.
h" |
26 #include "chrome/common/chrome_constants.h" | 27 #include "chrome/common/chrome_constants.h" |
27 #include "chrome/test/base/testing_profile.h" | 28 #include "chrome/test/base/testing_profile.h" |
28 #include "components/offline_pages/core/background/network_quality_provider_stub
.h" | 29 #include "components/offline_pages/core/background/network_quality_provider_stub
.h" |
29 #include "components/offline_pages/core/background/request_coordinator.h" | 30 #include "components/offline_pages/core/background/request_coordinator.h" |
30 #include "components/offline_pages/core/client_namespace_constants.h" | 31 #include "components/offline_pages/core/client_namespace_constants.h" |
31 #include "components/offline_pages/core/offline_page_feature.h" | 32 #include "components/offline_pages/core/offline_page_feature.h" |
32 #include "components/offline_pages/core/offline_page_model.h" | 33 #include "components/offline_pages/core/offline_page_model.h" |
| 34 #include "components/offline_pages/core/offline_page_model_impl.h" |
33 #include "components/offline_pages/core/offline_page_test_archiver.h" | 35 #include "components/offline_pages/core/offline_page_test_archiver.h" |
34 #include "components/offline_pages/core/offline_page_test_store.h" | 36 #include "components/offline_pages/core/offline_page_test_store.h" |
35 #include "components/offline_pages/core/offline_page_types.h" | 37 #include "components/offline_pages/core/offline_page_types.h" |
36 #include "content/public/browser/web_contents.h" | 38 #include "content/public/browser/web_contents.h" |
37 #include "content/public/test/test_browser_thread_bundle.h" | 39 #include "content/public/test/test_browser_thread_bundle.h" |
38 #include "net/base/filename_util.h" | 40 #include "net/base/filename_util.h" |
39 #include "testing/gtest/include/gtest/gtest.h" | 41 #include "testing/gtest/include/gtest/gtest.h" |
40 #include "url/gurl.h" | 42 #include "url/gurl.h" |
41 | 43 |
42 namespace offline_pages { | 44 namespace offline_pages { |
43 namespace { | 45 namespace { |
44 | 46 |
45 const GURL kTestPage1Url("http://test.org/page1"); | 47 const GURL kTestPage1Url("http://test.org/page1"); |
46 const GURL kTestPage2Url("http://test.org/page2"); | 48 const GURL kTestPage2Url("http://test.org/page2"); |
47 const GURL kTestPage3Url("http://test.org/page3"); | 49 const GURL kTestPage3Url("http://test.org/page3"); |
48 const GURL kTestPage4Url("http://test.org/page4"); | 50 const GURL kTestPage4Url("http://test.org/page4"); |
49 const int64_t kTestFileSize = 876543LL; | 51 const int64_t kTestFileSize = 876543LL; |
50 const char* kTestPage1ClientId = "1234"; | 52 const char* kTestPage1ClientId = "1234"; |
51 const char* kTestPage2ClientId = "5678"; | 53 const char* kTestPage2ClientId = "5678"; |
52 const char* kTestPage3ClientId = "7890"; | 54 const char* kTestPage3ClientId = "7890"; |
| 55 const char* kTestPage4ClientId = "42"; |
53 | 56 |
54 void CheckDuplicateDownloadsCallback( | 57 void CheckDuplicateDownloadsCallback( |
55 OfflinePageUtils::DuplicateCheckResult* out_result, | 58 OfflinePageUtils::DuplicateCheckResult* out_result, |
56 OfflinePageUtils::DuplicateCheckResult result) { | 59 OfflinePageUtils::DuplicateCheckResult result) { |
57 DCHECK(out_result); | 60 DCHECK(out_result); |
58 *out_result = result; | 61 *out_result = result; |
59 } | 62 } |
60 | 63 |
61 void GetAllRequestsCallback( | 64 void GetAllRequestsCallback( |
62 std::vector<std::unique_ptr<SavePageRequest>>* out_requests, | 65 std::vector<std::unique_ptr<SavePageRequest>>* out_requests, |
(...skipping 20 matching lines...) Expand all Loading... |
83 | 86 |
84 // Return number of matches found. | 87 // Return number of matches found. |
85 int FindRequestByNamespaceAndURL(const std::string& name_space, | 88 int FindRequestByNamespaceAndURL(const std::string& name_space, |
86 const GURL& url); | 89 const GURL& url); |
87 | 90 |
88 // Necessary callbacks for the offline page model. | 91 // Necessary callbacks for the offline page model. |
89 void OnSavePageDone(SavePageResult result, int64_t offlineId); | 92 void OnSavePageDone(SavePageResult result, int64_t offlineId); |
90 void OnClearAllDone(); | 93 void OnClearAllDone(); |
91 void OnExpirePageDone(bool success); | 94 void OnExpirePageDone(bool success); |
92 void OnGetURLDone(const GURL& url); | 95 void OnGetURLDone(const GURL& url); |
| 96 void OnSizeInBytesCalculated(int64_t size); |
93 | 97 |
94 // OfflinePageTestArchiver::Observer implementation: | 98 // OfflinePageTestArchiver::Observer implementation: |
95 void SetLastPathCreatedByArchiver(const base::FilePath& file_path) override; | 99 void SetLastPathCreatedByArchiver(const base::FilePath& file_path) override; |
96 | 100 |
97 TestingProfile* profile() { return &profile_; } | 101 TestingProfile* profile() { return &profile_; } |
98 content::WebContents* web_contents() const { return web_contents_.get(); } | 102 content::WebContents* web_contents() const { return web_contents_.get(); } |
99 | 103 |
100 int64_t offline_id() const { return offline_id_; } | 104 int64_t offline_id() const { return offline_id_; } |
| 105 int64_t last_cache_size() { return last_cache_size_; } |
| 106 |
| 107 void CreateCachedOfflinePages(base::SimpleTestClock* clock); |
101 | 108 |
102 private: | 109 private: |
103 void CreateOfflinePages(); | 110 void CreateOfflinePages(); |
104 void CreateRequests(); | 111 void CreateRequests(); |
105 std::unique_ptr<OfflinePageTestArchiver> BuildArchiver( | 112 std::unique_ptr<OfflinePageTestArchiver> BuildArchiver( |
106 const GURL& url, | 113 const GURL& url, |
107 const base::FilePath& file_name); | 114 const base::FilePath& file_name); |
108 | 115 |
109 content::TestBrowserThreadBundle browser_thread_bundle_; | 116 content::TestBrowserThreadBundle browser_thread_bundle_; |
110 int64_t offline_id_; | 117 int64_t offline_id_; |
111 GURL url_; | 118 GURL url_; |
112 TestingProfile profile_; | 119 TestingProfile profile_; |
113 std::unique_ptr<content::WebContents> web_contents_; | 120 std::unique_ptr<content::WebContents> web_contents_; |
114 base::test::ScopedFeatureList scoped_feature_list_; | 121 base::test::ScopedFeatureList scoped_feature_list_; |
| 122 int64_t last_cache_size_; |
115 }; | 123 }; |
116 | 124 |
117 OfflinePageUtilsTest::OfflinePageUtilsTest() = default; | 125 OfflinePageUtilsTest::OfflinePageUtilsTest() = default; |
118 | 126 |
119 OfflinePageUtilsTest::~OfflinePageUtilsTest() {} | 127 OfflinePageUtilsTest::~OfflinePageUtilsTest() {} |
120 | 128 |
121 void OfflinePageUtilsTest::SetUp() { | 129 void OfflinePageUtilsTest::SetUp() { |
122 // Enables offline pages feature. | 130 // Enables offline pages feature. |
123 // TODO(jianli): Remove this once the feature is completely enabled. | 131 // TODO(jianli): Remove this once the feature is completely enabled. |
124 scoped_feature_list_.InitAndEnableFeature( | 132 scoped_feature_list_.InitAndEnableFeature( |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
173 } | 181 } |
174 | 182 |
175 void OfflinePageUtilsTest::OnClearAllDone() { | 183 void OfflinePageUtilsTest::OnClearAllDone() { |
176 // Result ignored here. | 184 // Result ignored here. |
177 } | 185 } |
178 | 186 |
179 void OfflinePageUtilsTest::OnGetURLDone(const GURL& url) { | 187 void OfflinePageUtilsTest::OnGetURLDone(const GURL& url) { |
180 url_ = url; | 188 url_ = url; |
181 } | 189 } |
182 | 190 |
| 191 void OfflinePageUtilsTest::OnSizeInBytesCalculated(int64_t size) { |
| 192 last_cache_size_ = size; |
| 193 } |
| 194 |
183 void OfflinePageUtilsTest::SetLastPathCreatedByArchiver( | 195 void OfflinePageUtilsTest::SetLastPathCreatedByArchiver( |
184 const base::FilePath& file_path) {} | 196 const base::FilePath& file_path) {} |
185 | 197 |
186 void OfflinePageUtilsTest::CreateOfflinePages() { | 198 void OfflinePageUtilsTest::CreateOfflinePages() { |
187 // Create page 1. | 199 // Create page 1. |
188 std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver( | 200 std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver( |
189 kTestPage1Url, base::FilePath(FILE_PATH_LITERAL("page1.mhtml")))); | 201 kTestPage1Url, base::FilePath(FILE_PATH_LITERAL("page1.mhtml")))); |
190 offline_pages::ClientId client_id; | 202 offline_pages::ClientId client_id; |
191 client_id.name_space = kDownloadNamespace; | 203 client_id.name_space = kDownloadNamespace; |
192 client_id.id = kTestPage1ClientId; | 204 client_id.id = kTestPage1ClientId; |
(...skipping 11 matching lines...) Expand all Loading... |
204 RequestCoordinatorFactory::GetForBrowserContext(profile()); | 216 RequestCoordinatorFactory::GetForBrowserContext(profile()); |
205 | 217 |
206 RequestCoordinator::SavePageLaterParams params; | 218 RequestCoordinator::SavePageLaterParams params; |
207 params.url = kTestPage3Url; | 219 params.url = kTestPage3Url; |
208 params.client_id = | 220 params.client_id = |
209 offline_pages::ClientId(kDownloadNamespace, kTestPage3ClientId); | 221 offline_pages::ClientId(kDownloadNamespace, kTestPage3ClientId); |
210 request_coordinator->SavePageLater(params); | 222 request_coordinator->SavePageLater(params); |
211 RunUntilIdle(); | 223 RunUntilIdle(); |
212 } | 224 } |
213 | 225 |
| 226 void OfflinePageUtilsTest::CreateCachedOfflinePages( |
| 227 base::SimpleTestClock* clock) { |
| 228 // Add 4 temporary pages to the model used for test cases. And setting current |
| 229 // time as the 00:00:00 time anchor. |
| 230 offline_pages::ClientId client_id; |
| 231 client_id.name_space = kBookmarkNamespace; |
| 232 |
| 233 clock->SetNow(base::Time::Now()); |
| 234 // Time 01:00:00. |
| 235 clock->Advance(base::TimeDelta::FromHours(1)); |
| 236 std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver( |
| 237 kTestPage1Url, base::FilePath(FILE_PATH_LITERAL("page1.mhtml")))); |
| 238 client_id.id = kTestPage1ClientId; |
| 239 SavePage(kTestPage1Url, client_id, std::move(archiver)); |
| 240 // time 02:00:00. |
| 241 clock->Advance(base::TimeDelta::FromHours(1)); |
| 242 archiver = BuildArchiver(kTestPage2Url, |
| 243 base::FilePath(FILE_PATH_LITERAL("page2.mhtml"))); |
| 244 client_id.id = kTestPage2ClientId; |
| 245 SavePage(kTestPage2Url, client_id, std::move(archiver)); |
| 246 // time 03:00:00. |
| 247 clock->Advance(base::TimeDelta::FromHours(1)); |
| 248 archiver = BuildArchiver(kTestPage3Url, |
| 249 base::FilePath(FILE_PATH_LITERAL("page3.mhtml"))); |
| 250 client_id.id = kTestPage3ClientId; |
| 251 SavePage(kTestPage3Url, client_id, std::move(archiver)); |
| 252 // Add a temporary page to test boundary at 10:00:00. |
| 253 clock->Advance(base::TimeDelta::FromHours(7)); |
| 254 archiver = BuildArchiver(kTestPage4Url, |
| 255 base::FilePath(FILE_PATH_LITERAL("page4.mhtml"))); |
| 256 client_id.id = kTestPage4ClientId; |
| 257 SavePage(kTestPage4Url, client_id, std::move(archiver)); |
| 258 // Reset clock->to 03:00:00. |
| 259 clock->SetNow(clock->Now() - base::TimeDelta::FromHours(7)); |
| 260 } |
| 261 |
214 std::unique_ptr<OfflinePageTestArchiver> OfflinePageUtilsTest::BuildArchiver( | 262 std::unique_ptr<OfflinePageTestArchiver> OfflinePageUtilsTest::BuildArchiver( |
215 const GURL& url, | 263 const GURL& url, |
216 const base::FilePath& file_name) { | 264 const base::FilePath& file_name) { |
217 std::unique_ptr<OfflinePageTestArchiver> archiver(new OfflinePageTestArchiver( | 265 std::unique_ptr<OfflinePageTestArchiver> archiver(new OfflinePageTestArchiver( |
218 this, url, OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED, | 266 this, url, OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED, |
219 base::string16(), kTestFileSize, base::ThreadTaskRunnerHandle::Get())); | 267 base::string16(), kTestFileSize, base::ThreadTaskRunnerHandle::Get())); |
220 archiver->set_filename(file_name); | 268 archiver->set_filename(file_name); |
221 return archiver; | 269 return archiver; |
222 } | 270 } |
223 | 271 |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
303 EXPECT_TRUE(OfflinePageUtils::EqualsIgnoringFragment( | 351 EXPECT_TRUE(OfflinePageUtils::EqualsIgnoringFragment( |
304 GURL("http://example.com/"), GURL("http://example.com/#test"))); | 352 GURL("http://example.com/"), GURL("http://example.com/#test"))); |
305 EXPECT_TRUE(OfflinePageUtils::EqualsIgnoringFragment( | 353 EXPECT_TRUE(OfflinePageUtils::EqualsIgnoringFragment( |
306 GURL("http://example.com/#test"), GURL("http://example.com/"))); | 354 GURL("http://example.com/#test"), GURL("http://example.com/"))); |
307 EXPECT_TRUE(OfflinePageUtils::EqualsIgnoringFragment( | 355 EXPECT_TRUE(OfflinePageUtils::EqualsIgnoringFragment( |
308 GURL("http://example.com/#test"), GURL("http://example.com/#test2"))); | 356 GURL("http://example.com/#test"), GURL("http://example.com/#test2"))); |
309 EXPECT_FALSE(OfflinePageUtils::EqualsIgnoringFragment( | 357 EXPECT_FALSE(OfflinePageUtils::EqualsIgnoringFragment( |
310 GURL("http://example.com/"), GURL("http://test.com/#test"))); | 358 GURL("http://example.com/"), GURL("http://test.com/#test"))); |
311 } | 359 } |
312 | 360 |
| 361 TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeBetween) { |
| 362 // Set a test clock before adding cached offline pages. |
| 363 // The clock will be at 03:00:00 after adding pages. |
| 364 OfflinePageModel* model = |
| 365 OfflinePageModelFactory::GetForBrowserContext(profile()); |
| 366 base::SimpleTestClock clock; |
| 367 static_cast<OfflinePageModelImpl*>(model)->set_testing_clock(&clock); |
| 368 CreateCachedOfflinePages(&clock); |
| 369 |
| 370 // Advance the clock so that we don't hit the time check boundary. |
| 371 clock.Advance(base::TimeDelta::FromMinutes(5)); |
| 372 |
| 373 // Get the size of cached offline pages between 01:05:00 and 03:05:00. |
| 374 bool ret = OfflinePageUtils::GetCachedOfflinePageSizeBetween( |
| 375 profile(), |
| 376 base::Bind(&OfflinePageUtilsTest::OnSizeInBytesCalculated, AsWeakPtr()), |
| 377 clock.Now() - base::TimeDelta::FromHours(2), clock.Now()); |
| 378 RunUntilIdle(); |
| 379 EXPECT_TRUE(ret); |
| 380 EXPECT_EQ(kTestFileSize * 2, last_cache_size()); |
| 381 } |
| 382 |
| 383 TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeNoPageInModel) { |
| 384 // Set a test clock. |
| 385 OfflinePageModel* model = |
| 386 OfflinePageModelFactory::GetForBrowserContext(profile()); |
| 387 base::SimpleTestClock clock; |
| 388 static_cast<OfflinePageModelImpl*>(model)->set_testing_clock(&clock); |
| 389 |
| 390 clock.Advance(base::TimeDelta::FromHours(3)); |
| 391 |
| 392 // Get the size of cached offline pages between 01:00:00 and 03:00:00. |
| 393 // Since no temporary pages were added to the model, the cache size should be |
| 394 // 0. |
| 395 bool ret = OfflinePageUtils::GetCachedOfflinePageSizeBetween( |
| 396 profile(), |
| 397 base::Bind(&OfflinePageUtilsTest::OnSizeInBytesCalculated, AsWeakPtr()), |
| 398 clock.Now() - base::TimeDelta::FromHours(2), clock.Now()); |
| 399 RunUntilIdle(); |
| 400 EXPECT_TRUE(ret); |
| 401 EXPECT_EQ(0, last_cache_size()); |
| 402 } |
| 403 |
| 404 TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeNoPageInRange) { |
| 405 // Set a test clock before adding cached offline pages. |
| 406 // The clock will be at 03:00:00 after adding pages. |
| 407 OfflinePageModel* model = |
| 408 OfflinePageModelFactory::GetForBrowserContext(profile()); |
| 409 base::SimpleTestClock clock; |
| 410 static_cast<OfflinePageModelImpl*>(model)->set_testing_clock(&clock); |
| 411 CreateCachedOfflinePages(&clock); |
| 412 |
| 413 // Advance the clock so that we don't hit the time check boundary. |
| 414 clock.Advance(base::TimeDelta::FromMinutes(5)); |
| 415 |
| 416 // Get the size of cached offline pages between 03:04:00 and 03:05:00. |
| 417 bool ret = OfflinePageUtils::GetCachedOfflinePageSizeBetween( |
| 418 profile(), |
| 419 base::Bind(&OfflinePageUtilsTest::OnSizeInBytesCalculated, AsWeakPtr()), |
| 420 clock.Now() - base::TimeDelta::FromMinutes(1), clock.Now()); |
| 421 RunUntilIdle(); |
| 422 EXPECT_TRUE(ret); |
| 423 EXPECT_EQ(0, last_cache_size()); |
| 424 } |
| 425 |
| 426 TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeAllPagesInRange) { |
| 427 // Set a test clock before adding cached offline pages. |
| 428 // The clock will be at 03:00:00 after adding pages. |
| 429 OfflinePageModel* model = |
| 430 OfflinePageModelFactory::GetForBrowserContext(profile()); |
| 431 base::SimpleTestClock clock; |
| 432 static_cast<OfflinePageModelImpl*>(model)->set_testing_clock(&clock); |
| 433 CreateCachedOfflinePages(&clock); |
| 434 |
| 435 // Advance the clock to 23:00:00. |
| 436 clock.Advance(base::TimeDelta::FromHours(20)); |
| 437 |
| 438 // Get the size of cached offline pages between -01:00:00 and 23:00:00. |
| 439 bool ret = OfflinePageUtils::GetCachedOfflinePageSizeBetween( |
| 440 profile(), |
| 441 base::Bind(&OfflinePageUtilsTest::OnSizeInBytesCalculated, AsWeakPtr()), |
| 442 clock.Now() - base::TimeDelta::FromHours(24), clock.Now()); |
| 443 RunUntilIdle(); |
| 444 EXPECT_TRUE(ret); |
| 445 EXPECT_EQ(kTestFileSize * 4, last_cache_size()); |
| 446 } |
| 447 |
| 448 TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeAllPagesInvalidRange) { |
| 449 // Set a test clock before adding cached offline pages. |
| 450 // The clock will be at 03:00:00 after adding pages. |
| 451 OfflinePageModel* model = |
| 452 OfflinePageModelFactory::GetForBrowserContext(profile()); |
| 453 base::SimpleTestClock clock; |
| 454 static_cast<OfflinePageModelImpl*>(model)->set_testing_clock(&clock); |
| 455 CreateCachedOfflinePages(&clock); |
| 456 |
| 457 // Advance the clock to 23:00:00. |
| 458 clock.Advance(base::TimeDelta::FromHours(20)); |
| 459 |
| 460 // Get the size of cached offline pages between 23:00:00 and -01:00:00, which |
| 461 // is an invalid range, the return value will be false and there will be no |
| 462 // callback. |
| 463 bool ret = OfflinePageUtils::GetCachedOfflinePageSizeBetween( |
| 464 profile(), |
| 465 base::Bind(&OfflinePageUtilsTest::OnSizeInBytesCalculated, AsWeakPtr()), |
| 466 clock.Now(), clock.Now() - base::TimeDelta::FromHours(24)); |
| 467 RunUntilIdle(); |
| 468 EXPECT_FALSE(ret); |
| 469 } |
| 470 |
| 471 TEST_F(OfflinePageUtilsTest, TestGetCachedOfflinePageSizeEdgeCase) { |
| 472 // Set a test clock before adding cached offline pages. |
| 473 // The clock will be at 03:00:00 after adding pages. |
| 474 OfflinePageModel* model = |
| 475 OfflinePageModelFactory::GetForBrowserContext(profile()); |
| 476 base::SimpleTestClock clock; |
| 477 static_cast<OfflinePageModelImpl*>(model)->set_testing_clock(&clock); |
| 478 CreateCachedOfflinePages(&clock); |
| 479 |
| 480 // Get the size of cached offline pages between 02:00:00 and 03:00:00, since |
| 481 // we are using a [begin_time, end_time) range so there will be only 1 page |
| 482 // when query for this time range. |
| 483 bool ret = OfflinePageUtils::GetCachedOfflinePageSizeBetween( |
| 484 profile(), |
| 485 base::Bind(&OfflinePageUtilsTest::OnSizeInBytesCalculated, AsWeakPtr()), |
| 486 clock.Now() - base::TimeDelta::FromHours(1), clock.Now()); |
| 487 RunUntilIdle(); |
| 488 EXPECT_TRUE(ret); |
| 489 EXPECT_EQ(kTestFileSize * 1, last_cache_size()); |
| 490 } |
| 491 |
313 } // namespace offline_pages | 492 } // namespace offline_pages |
OLD | NEW |