OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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 "components/ntp_tiles/icon_cacher_impl.h" | 5 #include "components/ntp_tiles/icon_cacher_impl.h" |
6 | 6 |
7 #include <set> | 7 #include <set> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/files/scoped_temp_dir.h" | 10 #include "base/files/scoped_temp_dir.h" |
11 #include "base/memory/ptr_util.h" | 11 #include "base/memory/ptr_util.h" |
12 #include "base/path_service.h" | 12 #include "base/path_service.h" |
13 #include "base/run_loop.h" | 13 #include "base/run_loop.h" |
14 #include "base/test/mock_callback.h" | 14 #include "base/test/mock_callback.h" |
15 #include "base/test/scoped_task_environment.h" | 15 #include "base/test/scoped_task_environment.h" |
16 #include "base/test/test_simple_task_runner.h" | 16 #include "base/test/test_simple_task_runner.h" |
17 #include "base/threading/thread_task_runner_handle.h" | 17 #include "base/threading/thread_task_runner_handle.h" |
18 #include "components/favicon/core/favicon_client.h" | 18 #include "components/favicon/core/favicon_client.h" |
19 #include "components/favicon/core/favicon_service_impl.h" | 19 #include "components/favicon/core/favicon_service_impl.h" |
20 #include "components/favicon/core/favicon_util.h" | 20 #include "components/favicon/core/favicon_util.h" |
| 21 #include "components/favicon/core/large_icon_service.h" |
21 #include "components/history/core/browser/history_database_params.h" | 22 #include "components/history/core/browser/history_database_params.h" |
22 #include "components/history/core/browser/history_service.h" | 23 #include "components/history/core/browser/history_service.h" |
23 #include "components/image_fetcher/core/image_decoder.h" | 24 #include "components/image_fetcher/core/image_decoder.h" |
24 #include "components/image_fetcher/core/image_fetcher.h" | 25 #include "components/image_fetcher/core/image_fetcher.h" |
25 #include "components/image_fetcher/core/request_metadata.h" | 26 #include "components/image_fetcher/core/request_metadata.h" |
26 #include "testing/gmock/include/gmock/gmock.h" | 27 #include "testing/gmock/include/gmock/gmock.h" |
27 #include "testing/gtest/include/gtest/gtest.h" | 28 #include "testing/gtest/include/gtest/gtest.h" |
28 #include "ui/base/resource/resource_bundle.h" | 29 #include "ui/base/resource/resource_bundle.h" |
29 #include "ui/base/ui_base_paths.h" | 30 #include "ui/base/ui_base_paths.h" |
30 #include "ui/gfx/image/image_unittest_util.h" | 31 #include "ui/gfx/image/image_unittest_util.h" |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
87 ui::ScaleFactor scale_factor)); | 88 ui::ScaleFactor scale_factor)); |
88 | 89 |
89 MOCK_METHOD3(GetRawDataResource, | 90 MOCK_METHOD3(GetRawDataResource, |
90 bool(int resource_id, | 91 bool(int resource_id, |
91 ui::ScaleFactor scale_factor, | 92 ui::ScaleFactor scale_factor, |
92 base::StringPiece* value)); | 93 base::StringPiece* value)); |
93 | 94 |
94 MOCK_METHOD2(GetLocalizedString, bool(int message_id, base::string16* value)); | 95 MOCK_METHOD2(GetLocalizedString, bool(int message_id, base::string16* value)); |
95 }; | 96 }; |
96 | 97 |
97 class IconCacherTest : public ::testing::Test { | 98 ACTION(FailFetch) { |
| 99 base::ThreadTaskRunnerHandle::Get()->PostTask( |
| 100 FROM_HERE, |
| 101 base::Bind(arg2, arg0, gfx::Image(), image_fetcher::RequestMetadata())); |
| 102 } |
| 103 |
| 104 ACTION_P2(DecodeSuccessfully, width, height) { |
| 105 base::ThreadTaskRunnerHandle::Get()->PostTask( |
| 106 FROM_HERE, base::Bind(arg2, gfx::test::CreateImage(width, height))); |
| 107 } |
| 108 |
| 109 ACTION_P2(PassFetch, width, height) { |
| 110 base::ThreadTaskRunnerHandle::Get()->PostTask( |
| 111 FROM_HERE, base::Bind(arg2, arg0, gfx::test::CreateImage(width, height), |
| 112 image_fetcher::RequestMetadata())); |
| 113 } |
| 114 |
| 115 ACTION_P(Quit, run_loop) { |
| 116 run_loop->Quit(); |
| 117 } |
| 118 |
| 119 // TODO(jkrcal): Split off large_icon_service.h and large_icon_service_impl.h. |
| 120 // Use then mocks of FaviconService and LargeIconService instead of the real |
| 121 // things. |
| 122 class IconCacherTestBase : public ::testing::Test { |
98 protected: | 123 protected: |
99 IconCacherTest() | 124 IconCacherTestBase() |
100 : site_(base::string16(), // title, unused | 125 : favicon_service_(/*favicon_client=*/nullptr, &history_service_) { |
101 GURL("http://url.google/"), | |
102 GURL("http://url.google/icon.png"), | |
103 GURL("http://url.google/favicon.ico"), | |
104 GURL()), // thumbnail, unused | |
105 image_fetcher_(new ::testing::StrictMock<MockImageFetcher>), | |
106 image_decoder_(new ::testing::StrictMock<MockImageDecoder>), | |
107 favicon_service_(/*favicon_client=*/nullptr, &history_service_), | |
108 task_runner_(new base::TestSimpleTaskRunner()) { | |
109 CHECK(history_dir_.CreateUniqueTempDir()); | 126 CHECK(history_dir_.CreateUniqueTempDir()); |
110 CHECK(history_service_.Init( | 127 CHECK(history_service_.Init( |
111 history::HistoryDatabaseParams(history_dir_.GetPath(), 0, 0))); | 128 history::HistoryDatabaseParams(history_dir_.GetPath(), 0, 0))); |
112 } | 129 } |
113 | 130 |
114 void SetUp() override { | |
115 if (ui::ResourceBundle::HasSharedInstance()) { | |
116 ui::ResourceBundle::CleanupSharedInstance(); | |
117 } | |
118 ON_CALL(mock_resource_delegate_, GetPathForResourcePack(_, _)) | |
119 .WillByDefault(ReturnArg<0>()); | |
120 ON_CALL(mock_resource_delegate_, GetPathForLocalePack(_, _)) | |
121 .WillByDefault(ReturnArg<0>()); | |
122 ui::ResourceBundle::InitSharedInstanceWithLocale( | |
123 "en-US", &mock_resource_delegate_, | |
124 ui::ResourceBundle::LOAD_COMMON_RESOURCES); | |
125 } | |
126 | |
127 void TearDown() override { | |
128 if (ui::ResourceBundle::HasSharedInstance()) { | |
129 ui::ResourceBundle::CleanupSharedInstance(); | |
130 } | |
131 base::FilePath pak_path; | |
132 #if defined(OS_ANDROID) | |
133 PathService::Get(ui::DIR_RESOURCE_PAKS_ANDROID, &pak_path); | |
134 #else | |
135 PathService::Get(base::DIR_MODULE, &pak_path); | |
136 #endif | |
137 | |
138 base::FilePath ui_test_pak_path; | |
139 ASSERT_TRUE(PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path)); | |
140 ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path); | |
141 | |
142 ui::ResourceBundle::GetSharedInstance().AddDataPackFromPath( | |
143 pak_path.AppendASCII("components_tests_resources.pak"), | |
144 ui::SCALE_FACTOR_NONE); | |
145 } | |
146 | |
147 void PreloadIcon(const GURL& url, | 131 void PreloadIcon(const GURL& url, |
148 const GURL& icon_url, | 132 const GURL& icon_url, |
149 favicon_base::IconType icon_type, | 133 favicon_base::IconType icon_type, |
150 int width, | 134 int width, |
151 int height) { | 135 int height) { |
152 favicon_service_.SetFavicons(url, icon_url, icon_type, | 136 favicon_service_.SetFavicons(url, icon_url, icon_type, |
153 gfx::test::CreateImage(width, height)); | 137 gfx::test::CreateImage(width, height)); |
154 } | 138 } |
155 | 139 |
156 bool IconIsCachedFor(const GURL& url, favicon_base::IconType icon_type) { | 140 bool IconIsCachedFor(const GURL& url, favicon_base::IconType icon_type) { |
(...skipping 12 matching lines...) Expand all Loading... |
169 const favicon_base::FaviconImageResult& result) { | 153 const favicon_base::FaviconImageResult& result) { |
170 *image = result.image; | 154 *image = result.image; |
171 loop->Quit(); | 155 loop->Quit(); |
172 }, | 156 }, |
173 &image, &loop), | 157 &image, &loop), |
174 &tracker); | 158 &tracker); |
175 loop.Run(); | 159 loop.Run(); |
176 return image; | 160 return image; |
177 } | 161 } |
178 | 162 |
179 void WaitForTasksToFinish() { task_runner_->RunUntilIdle(); } | 163 void WaitForHistoryThreadTasksToFinish() { |
| 164 base::RunLoop loop; |
| 165 base::MockCallback<base::Closure> done; |
| 166 EXPECT_CALL(done, Run()).WillOnce(Quit(&loop)); |
| 167 history_service_.FlushForTest(done.Get()); |
| 168 loop.Run(); |
| 169 } |
| 170 |
| 171 void WaitForMainThreadTasksToFinish() { |
| 172 base::RunLoop loop; |
| 173 loop.RunUntilIdle(); |
| 174 } |
180 | 175 |
181 base::test::ScopedTaskEnvironment scoped_task_environment_; | 176 base::test::ScopedTaskEnvironment scoped_task_environment_; |
| 177 base::ScopedTempDir history_dir_; |
| 178 history::HistoryService history_service_; |
| 179 favicon::FaviconServiceImpl favicon_service_; |
| 180 }; |
| 181 |
| 182 class IconCacherTestPopularSites : public IconCacherTestBase { |
| 183 protected: |
| 184 IconCacherTestPopularSites() |
| 185 : site_(base::string16(), // title, unused |
| 186 GURL("http://url.google/"), |
| 187 GURL("http://url.google/icon.png"), |
| 188 GURL("http://url.google/favicon.ico"), |
| 189 GURL()), // thumbnail, unused |
| 190 image_fetcher_(new ::testing::StrictMock<MockImageFetcher>), |
| 191 image_decoder_(new ::testing::StrictMock<MockImageDecoder>) {} |
| 192 |
| 193 void SetUp() override { |
| 194 if (ui::ResourceBundle::HasSharedInstance()) { |
| 195 ui::ResourceBundle::CleanupSharedInstance(); |
| 196 } |
| 197 ON_CALL(mock_resource_delegate_, GetPathForResourcePack(_, _)) |
| 198 .WillByDefault(ReturnArg<0>()); |
| 199 ON_CALL(mock_resource_delegate_, GetPathForLocalePack(_, _)) |
| 200 .WillByDefault(ReturnArg<0>()); |
| 201 ui::ResourceBundle::InitSharedInstanceWithLocale( |
| 202 "en-US", &mock_resource_delegate_, |
| 203 ui::ResourceBundle::LOAD_COMMON_RESOURCES); |
| 204 } |
| 205 |
| 206 void TearDown() override { |
| 207 if (ui::ResourceBundle::HasSharedInstance()) { |
| 208 ui::ResourceBundle::CleanupSharedInstance(); |
| 209 } |
| 210 base::FilePath pak_path; |
| 211 #if defined(OS_ANDROID) |
| 212 PathService::Get(ui::DIR_RESOURCE_PAKS_ANDROID, &pak_path); |
| 213 #else |
| 214 PathService::Get(base::DIR_MODULE, &pak_path); |
| 215 #endif |
| 216 |
| 217 base::FilePath ui_test_pak_path; |
| 218 ASSERT_TRUE(PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path)); |
| 219 ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path); |
| 220 |
| 221 ui::ResourceBundle::GetSharedInstance().AddDataPackFromPath( |
| 222 pak_path.AppendASCII("components_tests_resources.pak"), |
| 223 ui::SCALE_FACTOR_NONE); |
| 224 } |
| 225 |
182 PopularSites::Site site_; | 226 PopularSites::Site site_; |
183 std::unique_ptr<MockImageFetcher> image_fetcher_; | 227 std::unique_ptr<MockImageFetcher> image_fetcher_; |
184 std::unique_ptr<MockImageDecoder> image_decoder_; | 228 std::unique_ptr<MockImageDecoder> image_decoder_; |
185 base::ScopedTempDir history_dir_; | |
186 history::HistoryService history_service_; | |
187 favicon::FaviconServiceImpl favicon_service_; | |
188 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; | |
189 NiceMock<MockResourceDelegate> mock_resource_delegate_; | 229 NiceMock<MockResourceDelegate> mock_resource_delegate_; |
190 }; | 230 }; |
191 | 231 |
192 ACTION(FailFetch) { | 232 TEST_F(IconCacherTestPopularSites, LargeCached) { |
193 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
194 FROM_HERE, | |
195 base::Bind(arg2, arg0, gfx::Image(), image_fetcher::RequestMetadata())); | |
196 } | |
197 | |
198 ACTION_P2(DecodeSuccessfully, width, height) { | |
199 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
200 FROM_HERE, base::Bind(arg2, gfx::test::CreateImage(width, height))); | |
201 } | |
202 | |
203 ACTION_P2(PassFetch, width, height) { | |
204 base::ThreadTaskRunnerHandle::Get()->PostTask( | |
205 FROM_HERE, base::Bind(arg2, arg0, gfx::test::CreateImage(width, height), | |
206 image_fetcher::RequestMetadata())); | |
207 } | |
208 | |
209 ACTION_P(Quit, run_loop) { | |
210 run_loop->Quit(); | |
211 } | |
212 | |
213 TEST_F(IconCacherTest, LargeCached) { | |
214 base::MockCallback<base::Closure> done; | 233 base::MockCallback<base::Closure> done; |
215 EXPECT_CALL(done, Run()).Times(0); | 234 EXPECT_CALL(done, Run()).Times(0); |
216 base::RunLoop loop; | 235 base::RunLoop loop; |
217 { | 236 { |
218 InSequence s; | 237 InSequence s; |
219 EXPECT_CALL(*image_fetcher_, | 238 EXPECT_CALL(*image_fetcher_, |
220 SetDataUseServiceName( | 239 SetDataUseServiceName( |
221 data_use_measurement::DataUseUserData::NTP_TILES)); | 240 data_use_measurement::DataUseUserData::NTP_TILES)); |
222 EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(gfx::Size(128, 128))); | 241 EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(gfx::Size(128, 128))); |
223 } | 242 } |
224 PreloadIcon(site_.url, site_.large_icon_url, favicon_base::TOUCH_ICON, 128, | 243 PreloadIcon(site_.url, site_.large_icon_url, favicon_base::TOUCH_ICON, 128, |
225 128); | 244 128); |
226 IconCacherImpl cacher(&favicon_service_, std::move(image_fetcher_)); | 245 IconCacherImpl cacher(&favicon_service_, nullptr, std::move(image_fetcher_)); |
227 cacher.StartFetch(site_, done.Get(), done.Get()); | 246 cacher.StartFetchPopularSites(site_, done.Get(), done.Get()); |
228 WaitForTasksToFinish(); | 247 WaitForMainThreadTasksToFinish(); |
229 EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON)); | 248 EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON)); |
230 EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON)); | 249 EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON)); |
231 } | 250 } |
232 | 251 |
233 TEST_F(IconCacherTest, LargeNotCachedAndFetchSucceeded) { | 252 TEST_F(IconCacherTestPopularSites, LargeNotCachedAndFetchSucceeded) { |
234 base::MockCallback<base::Closure> done; | 253 base::MockCallback<base::Closure> done; |
235 base::RunLoop loop; | 254 base::RunLoop loop; |
236 { | 255 { |
237 InSequence s; | 256 InSequence s; |
238 EXPECT_CALL(*image_fetcher_, | 257 EXPECT_CALL(*image_fetcher_, |
239 SetDataUseServiceName( | 258 SetDataUseServiceName( |
240 data_use_measurement::DataUseUserData::NTP_TILES)); | 259 data_use_measurement::DataUseUserData::NTP_TILES)); |
241 EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(gfx::Size(128, 128))); | 260 EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(gfx::Size(128, 128))); |
242 EXPECT_CALL(*image_fetcher_, | 261 EXPECT_CALL(*image_fetcher_, |
243 StartOrQueueNetworkRequest(_, site_.large_icon_url, _)) | 262 StartOrQueueNetworkRequest(_, site_.large_icon_url, _)) |
244 .WillOnce(PassFetch(128, 128)); | 263 .WillOnce(PassFetch(128, 128)); |
245 EXPECT_CALL(done, Run()).WillOnce(Quit(&loop)); | 264 EXPECT_CALL(done, Run()).WillOnce(Quit(&loop)); |
246 } | 265 } |
247 | 266 |
248 IconCacherImpl cacher(&favicon_service_, std::move(image_fetcher_)); | 267 IconCacherImpl cacher(&favicon_service_, nullptr, std::move(image_fetcher_)); |
249 cacher.StartFetch(site_, done.Get(), done.Get()); | 268 cacher.StartFetchPopularSites(site_, done.Get(), done.Get()); |
250 loop.Run(); | 269 loop.Run(); |
251 EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON)); | 270 EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON)); |
252 EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON)); | 271 EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON)); |
253 } | 272 } |
254 | 273 |
255 TEST_F(IconCacherTest, SmallNotCachedAndFetchSucceeded) { | 274 TEST_F(IconCacherTestPopularSites, SmallNotCachedAndFetchSucceeded) { |
256 site_.large_icon_url = GURL(); | 275 site_.large_icon_url = GURL(); |
257 | 276 |
258 base::MockCallback<base::Closure> done; | 277 base::MockCallback<base::Closure> done; |
259 base::RunLoop loop; | 278 base::RunLoop loop; |
260 { | 279 { |
261 InSequence s; | 280 InSequence s; |
262 EXPECT_CALL(*image_fetcher_, | 281 EXPECT_CALL(*image_fetcher_, |
263 SetDataUseServiceName( | 282 SetDataUseServiceName( |
264 data_use_measurement::DataUseUserData::NTP_TILES)); | 283 data_use_measurement::DataUseUserData::NTP_TILES)); |
265 EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(gfx::Size(128, 128))); | 284 EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(gfx::Size(128, 128))); |
266 EXPECT_CALL(*image_fetcher_, | 285 EXPECT_CALL(*image_fetcher_, |
267 StartOrQueueNetworkRequest(_, site_.favicon_url, _)) | 286 StartOrQueueNetworkRequest(_, site_.favicon_url, _)) |
268 .WillOnce(PassFetch(128, 128)); | 287 .WillOnce(PassFetch(128, 128)); |
269 EXPECT_CALL(done, Run()).WillOnce(Quit(&loop)); | 288 EXPECT_CALL(done, Run()).WillOnce(Quit(&loop)); |
270 } | 289 } |
271 | 290 |
272 IconCacherImpl cacher(&favicon_service_, std::move(image_fetcher_)); | 291 IconCacherImpl cacher(&favicon_service_, nullptr, std::move(image_fetcher_)); |
273 cacher.StartFetch(site_, done.Get(), done.Get()); | 292 cacher.StartFetchPopularSites(site_, done.Get(), done.Get()); |
274 loop.Run(); | 293 loop.Run(); |
275 EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::FAVICON)); | 294 EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::FAVICON)); |
276 EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON)); | 295 EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON)); |
277 } | 296 } |
278 | 297 |
279 TEST_F(IconCacherTest, LargeNotCachedAndFetchFailed) { | 298 TEST_F(IconCacherTestPopularSites, LargeNotCachedAndFetchFailed) { |
280 base::MockCallback<base::Closure> done; | 299 base::MockCallback<base::Closure> done; |
281 EXPECT_CALL(done, Run()).Times(0); | 300 EXPECT_CALL(done, Run()).Times(0); |
282 { | 301 { |
283 InSequence s; | 302 InSequence s; |
284 EXPECT_CALL(*image_fetcher_, | 303 EXPECT_CALL(*image_fetcher_, |
285 SetDataUseServiceName( | 304 SetDataUseServiceName( |
286 data_use_measurement::DataUseUserData::NTP_TILES)); | 305 data_use_measurement::DataUseUserData::NTP_TILES)); |
287 EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(gfx::Size(128, 128))); | 306 EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(gfx::Size(128, 128))); |
288 EXPECT_CALL(*image_fetcher_, | 307 EXPECT_CALL(*image_fetcher_, |
289 StartOrQueueNetworkRequest(_, site_.large_icon_url, _)) | 308 StartOrQueueNetworkRequest(_, site_.large_icon_url, _)) |
290 .WillOnce(FailFetch()); | 309 .WillOnce(FailFetch()); |
291 } | 310 } |
292 | 311 |
293 IconCacherImpl cacher(&favicon_service_, std::move(image_fetcher_)); | 312 IconCacherImpl cacher(&favicon_service_, nullptr, std::move(image_fetcher_)); |
294 cacher.StartFetch(site_, done.Get(), done.Get()); | 313 cacher.StartFetchPopularSites(site_, done.Get(), done.Get()); |
295 WaitForTasksToFinish(); | 314 WaitForMainThreadTasksToFinish(); |
296 EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON)); | 315 EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON)); |
297 EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON)); | 316 EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON)); |
298 } | 317 } |
299 | 318 |
300 TEST_F(IconCacherTest, HandlesEmptyCallbacksNicely) { | 319 TEST_F(IconCacherTestPopularSites, HandlesEmptyCallbacksNicely) { |
301 EXPECT_CALL(*image_fetcher_, SetDataUseServiceName(_)); | 320 EXPECT_CALL(*image_fetcher_, SetDataUseServiceName(_)); |
302 EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(_)); | 321 EXPECT_CALL(*image_fetcher_, SetDesiredImageFrameSize(_)); |
303 ON_CALL(*image_fetcher_, StartOrQueueNetworkRequest(_, _, _)) | 322 EXPECT_CALL(*image_fetcher_, StartOrQueueNetworkRequest(_, _, _)) |
304 .WillByDefault(PassFetch(128, 128)); | 323 .WillOnce(PassFetch(128, 128)); |
305 IconCacherImpl cacher(&favicon_service_, std::move(image_fetcher_)); | 324 IconCacherImpl cacher(&favicon_service_, nullptr, std::move(image_fetcher_)); |
306 cacher.StartFetch(site_, base::Closure(), base::Closure()); | 325 cacher.StartFetchPopularSites(site_, base::Closure(), base::Closure()); |
307 WaitForTasksToFinish(); | 326 WaitForHistoryThreadTasksToFinish(); // Writing the icon into the DB. |
| 327 WaitForMainThreadTasksToFinish(); // Finishing tasks after the DB write. |
| 328 // Even though the callbacks are not called, the icon gets written out. |
| 329 EXPECT_FALSE(IconIsCachedFor(site_.url, favicon_base::FAVICON)); |
| 330 EXPECT_TRUE(IconIsCachedFor(site_.url, favicon_base::TOUCH_ICON)); |
308 } | 331 } |
309 | 332 |
310 TEST_F(IconCacherTest, ProvidesDefaultIconAndSucceedsWithFetching) { | 333 TEST_F(IconCacherTestPopularSites, ProvidesDefaultIconAndSucceedsWithFetching) { |
311 // The returned data string is not used by the mocked decoder. | 334 // The returned data string is not used by the mocked decoder. |
312 ON_CALL(mock_resource_delegate_, GetRawDataResource(12345, _, _)) | 335 ON_CALL(mock_resource_delegate_, GetRawDataResource(12345, _, _)) |
313 .WillByDefault(Return("")); | 336 .WillByDefault(Return("")); |
314 // It's not important when the image_fetcher's decoder is used to decode the | 337 // It's not important when the image_fetcher's decoder is used to decode the |
315 // image but it must happen at some point. | 338 // image but it must happen at some point. |
316 EXPECT_CALL(*image_fetcher_, GetImageDecoder()) | 339 EXPECT_CALL(*image_fetcher_, GetImageDecoder()) |
317 .WillOnce(Return(image_decoder_.get())); | 340 .WillOnce(Return(image_decoder_.get())); |
318 EXPECT_CALL(*image_decoder_, DecodeImage(_, gfx::Size(128, 128), _)) | 341 EXPECT_CALL(*image_decoder_, DecodeImage(_, gfx::Size(128, 128), _)) |
319 .WillOnce(DecodeSuccessfully(64, 64)); | 342 .WillOnce(DecodeSuccessfully(64, 64)); |
320 base::MockCallback<base::Closure> preliminary_icon_available; | 343 base::MockCallback<base::Closure> preliminary_icon_available; |
(...skipping 10 matching lines...) Expand all Loading... |
331 StartOrQueueNetworkRequest(_, site_.large_icon_url, _)) | 354 StartOrQueueNetworkRequest(_, site_.large_icon_url, _)) |
332 .WillOnce(PassFetch(128, 128)); | 355 .WillOnce(PassFetch(128, 128)); |
333 | 356 |
334 // Both callback are called async after the request but preliminary has to | 357 // Both callback are called async after the request but preliminary has to |
335 // preceed icon_available. | 358 // preceed icon_available. |
336 EXPECT_CALL(preliminary_icon_available, Run()) | 359 EXPECT_CALL(preliminary_icon_available, Run()) |
337 .WillOnce(Quit(&default_loop)); | 360 .WillOnce(Quit(&default_loop)); |
338 EXPECT_CALL(icon_available, Run()).WillOnce(Quit(&fetch_loop)); | 361 EXPECT_CALL(icon_available, Run()).WillOnce(Quit(&fetch_loop)); |
339 } | 362 } |
340 | 363 |
341 IconCacherImpl cacher(&favicon_service_, std::move(image_fetcher_)); | 364 IconCacherImpl cacher(&favicon_service_, nullptr, std::move(image_fetcher_)); |
342 site_.default_icon_resource = 12345; | 365 site_.default_icon_resource = 12345; |
343 cacher.StartFetch(site_, icon_available.Get(), | 366 cacher.StartFetchPopularSites(site_, icon_available.Get(), |
344 preliminary_icon_available.Get()); | 367 preliminary_icon_available.Get()); |
345 | 368 |
346 default_loop.Run(); // Wait for the default image. | 369 default_loop.Run(); // Wait for the default image. |
347 EXPECT_THAT(GetCachedIconFor(site_.url, favicon_base::TOUCH_ICON).Size(), | 370 EXPECT_THAT(GetCachedIconFor(site_.url, favicon_base::TOUCH_ICON).Size(), |
348 Eq(gfx::Size(64, 64))); // Compares dimensions, not objects. | 371 Eq(gfx::Size(64, 64))); // Compares dimensions, not objects. |
349 | 372 |
350 // Let the fetcher continue and wait for the second call of the callback. | 373 // Let the fetcher continue and wait for the second call of the callback. |
351 fetch_loop.Run(); // Wait for the updated image. | 374 fetch_loop.Run(); // Wait for the updated image. |
352 EXPECT_THAT(GetCachedIconFor(site_.url, favicon_base::TOUCH_ICON).Size(), | 375 EXPECT_THAT(GetCachedIconFor(site_.url, favicon_base::TOUCH_ICON).Size(), |
353 Eq(gfx::Size(128, 128))); // Compares dimensions, not objects. | 376 Eq(gfx::Size(128, 128))); // Compares dimensions, not objects. |
354 } | 377 } |
355 | 378 |
| 379 class IconCacherTestMostLikely : public IconCacherTestBase { |
| 380 protected: |
| 381 IconCacherTestMostLikely() |
| 382 : large_icon_service_background_task_runner_( |
| 383 new base::TestSimpleTaskRunner()), |
| 384 fetcher_for_large_icon_service_( |
| 385 base::MakeUnique<::testing::StrictMock<MockImageFetcher>>()), |
| 386 fetcher_for_icon_cacher_( |
| 387 base::MakeUnique<::testing::StrictMock<MockImageFetcher>>()) { |
| 388 // Expect uninteresting calls here, |fetcher_for_icon_cacher_| is not |
| 389 // related to these tests. Keep it strict to make sure we do not use it in |
| 390 // any other way. |
| 391 EXPECT_CALL(*fetcher_for_icon_cacher_, |
| 392 SetDataUseServiceName( |
| 393 data_use_measurement::DataUseUserData::NTP_TILES)); |
| 394 EXPECT_CALL(*fetcher_for_icon_cacher_, |
| 395 SetDesiredImageFrameSize(gfx::Size(128, 128))); |
| 396 } |
| 397 |
| 398 scoped_refptr<base::TestSimpleTaskRunner> |
| 399 large_icon_service_background_task_runner_; |
| 400 std::unique_ptr<MockImageFetcher> fetcher_for_large_icon_service_; |
| 401 std::unique_ptr<MockImageFetcher> fetcher_for_icon_cacher_; |
| 402 }; |
| 403 |
| 404 TEST_F(IconCacherTestMostLikely, Cached) { |
| 405 GURL page_url("http://www.site.com"); |
| 406 GURL icon_url("http://www.site.com/favicon.png"); |
| 407 PreloadIcon(page_url, icon_url, favicon_base::TOUCH_ICON, 128, 128); |
| 408 |
| 409 favicon::LargeIconService large_icon_service( |
| 410 &favicon_service_, large_icon_service_background_task_runner_, |
| 411 std::move(fetcher_for_large_icon_service_)); |
| 412 IconCacherImpl cacher(&favicon_service_, &large_icon_service, |
| 413 std::move(fetcher_for_icon_cacher_)); |
| 414 |
| 415 base::MockCallback<base::Closure> done; |
| 416 EXPECT_CALL(done, Run()).Times(0); |
| 417 cacher.StartFetchMostLikely(page_url, done.Get()); |
| 418 WaitForMainThreadTasksToFinish(); |
| 419 |
| 420 EXPECT_FALSE(IconIsCachedFor(page_url, favicon_base::FAVICON)); |
| 421 EXPECT_TRUE(IconIsCachedFor(page_url, favicon_base::TOUCH_ICON)); |
| 422 } |
| 423 |
| 424 TEST_F(IconCacherTestMostLikely, NotCachedAndFetchSucceeded) { |
| 425 GURL page_url("http://www.site.com"); |
| 426 |
| 427 base::MockCallback<base::Closure> done; |
| 428 base::RunLoop loop; |
| 429 { |
| 430 InSequence s; |
| 431 EXPECT_CALL(*fetcher_for_large_icon_service_, |
| 432 SetDataUseServiceName( |
| 433 data_use_measurement::DataUseUserData::LARGE_ICON_SERVICE)); |
| 434 EXPECT_CALL(*fetcher_for_large_icon_service_, |
| 435 StartOrQueueNetworkRequest(_, _, _)) |
| 436 .WillOnce(PassFetch(128, 128)); |
| 437 EXPECT_CALL(done, Run()).WillOnce(Quit(&loop)); |
| 438 } |
| 439 |
| 440 favicon::LargeIconService large_icon_service( |
| 441 &favicon_service_, large_icon_service_background_task_runner_, |
| 442 std::move(fetcher_for_large_icon_service_)); |
| 443 IconCacherImpl cacher(&favicon_service_, &large_icon_service, |
| 444 std::move(fetcher_for_icon_cacher_)); |
| 445 |
| 446 cacher.StartFetchMostLikely(page_url, done.Get()); |
| 447 // Both these task runners need to be flushed in order to get |done| called by |
| 448 // running the main loop. |
| 449 WaitForHistoryThreadTasksToFinish(); |
| 450 large_icon_service_background_task_runner_->RunUntilIdle(); |
| 451 |
| 452 loop.Run(); |
| 453 EXPECT_FALSE(IconIsCachedFor(page_url, favicon_base::FAVICON)); |
| 454 EXPECT_TRUE(IconIsCachedFor(page_url, favicon_base::TOUCH_ICON)); |
| 455 } |
| 456 |
| 457 TEST_F(IconCacherTestMostLikely, NotCachedAndFetchFailed) { |
| 458 GURL page_url("http://www.site.com"); |
| 459 |
| 460 base::MockCallback<base::Closure> done; |
| 461 { |
| 462 InSequence s; |
| 463 EXPECT_CALL(*fetcher_for_large_icon_service_, |
| 464 SetDataUseServiceName( |
| 465 data_use_measurement::DataUseUserData::LARGE_ICON_SERVICE)); |
| 466 EXPECT_CALL(*fetcher_for_large_icon_service_, |
| 467 StartOrQueueNetworkRequest(_, _, _)) |
| 468 .WillOnce(FailFetch()); |
| 469 EXPECT_CALL(done, Run()).Times(0); |
| 470 } |
| 471 |
| 472 favicon::LargeIconService large_icon_service( |
| 473 &favicon_service_, large_icon_service_background_task_runner_, |
| 474 std::move(fetcher_for_large_icon_service_)); |
| 475 IconCacherImpl cacher(&favicon_service_, &large_icon_service, |
| 476 std::move(fetcher_for_icon_cacher_)); |
| 477 |
| 478 cacher.StartFetchMostLikely(page_url, done.Get()); |
| 479 // Both these task runners need to be flushed before flushing the main thread |
| 480 // queue in order to finish the work. |
| 481 WaitForHistoryThreadTasksToFinish(); |
| 482 large_icon_service_background_task_runner_->RunUntilIdle(); |
| 483 WaitForMainThreadTasksToFinish(); |
| 484 |
| 485 EXPECT_FALSE(IconIsCachedFor(page_url, favicon_base::FAVICON)); |
| 486 EXPECT_FALSE(IconIsCachedFor(page_url, favicon_base::TOUCH_ICON)); |
| 487 } |
| 488 |
| 489 TEST_F(IconCacherTestMostLikely, HandlesEmptyCallbacksNicely) { |
| 490 GURL page_url("http://www.site.com"); |
| 491 |
| 492 EXPECT_CALL(*fetcher_for_large_icon_service_, SetDataUseServiceName(_)); |
| 493 EXPECT_CALL(*fetcher_for_large_icon_service_, |
| 494 StartOrQueueNetworkRequest(_, _, _)) |
| 495 .WillOnce(PassFetch(128, 128)); |
| 496 |
| 497 favicon::LargeIconService large_icon_service( |
| 498 &favicon_service_, large_icon_service_background_task_runner_, |
| 499 std::move(fetcher_for_large_icon_service_)); |
| 500 IconCacherImpl cacher(&favicon_service_, &large_icon_service, |
| 501 std::move(fetcher_for_icon_cacher_)); |
| 502 |
| 503 cacher.StartFetchMostLikely(page_url, base::Closure()); |
| 504 // Both these task runners need to be flushed before flushing the main thread |
| 505 // queue in order to finish the work. |
| 506 WaitForHistoryThreadTasksToFinish(); |
| 507 large_icon_service_background_task_runner_->RunUntilIdle(); |
| 508 WaitForMainThreadTasksToFinish(); |
| 509 |
| 510 // Even though the callbacks are not called, the icon gets written out. |
| 511 EXPECT_FALSE(IconIsCachedFor(page_url, favicon_base::FAVICON)); |
| 512 EXPECT_TRUE(IconIsCachedFor(page_url, favicon_base::TOUCH_ICON)); |
| 513 } |
| 514 |
356 } // namespace | 515 } // namespace |
357 } // namespace ntp_tiles | 516 } // namespace ntp_tiles |
OLD | NEW |