OLD | NEW |
| (Empty) |
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 | |
3 // found in the LICENSE file. | |
4 | |
5 #include "content/child/notifications/pending_notifications_tracker.h" | |
6 | |
7 #include <memory> | |
8 #include <vector> | |
9 | |
10 #include "base/base_paths.h" | |
11 #include "base/bind.h" | |
12 #include "base/bind_helpers.h" | |
13 #include "base/files/file_path.h" | |
14 #include "base/files/file_util.h" | |
15 #include "base/location.h" | |
16 #include "base/macros.h" | |
17 #include "base/message_loop/message_loop.h" | |
18 #include "base/path_service.h" | |
19 #include "base/run_loop.h" | |
20 #include "base/thread_task_runner_handle.h" | |
21 #include "content/common/notification_constants.h" | |
22 #include "content/public/common/notification_resources.h" | |
23 #include "testing/gtest/include/gtest/gtest.h" | |
24 #include "third_party/WebKit/public/platform/Platform.h" | |
25 #include "third_party/WebKit/public/platform/WebString.h" | |
26 #include "third_party/WebKit/public/platform/WebURL.h" | |
27 #include "third_party/WebKit/public/platform/WebURLError.h" | |
28 #include "third_party/WebKit/public/platform/WebURLLoaderMockFactory.h" | |
29 #include "third_party/WebKit/public/platform/WebURLResponse.h" | |
30 #include "third_party/WebKit/public/platform/modules/notifications/WebNotificati
onData.h" | |
31 #include "third_party/WebKit/public/platform/modules/notifications/WebNotificati
onDelegate.h" | |
32 #include "third_party/skia/include/core/SkBitmap.h" | |
33 #include "url/gurl.h" | |
34 | |
35 namespace content { | |
36 | |
37 namespace { | |
38 | |
39 const char kBaseUrl[] = "http://test.com/"; | |
40 const char kIcon48x48[] = "48x48.png"; | |
41 const char kIcon100x100[] = "100x100.png"; | |
42 const char kIcon110x110[] = "110x110.png"; | |
43 const char kIcon120x120[] = "120x120.png"; | |
44 const char kIcon500x500[] = "500x500.png"; | |
45 | |
46 class FakeNotificationDelegate : public blink::WebNotificationDelegate { | |
47 public: | |
48 void dispatchClickEvent() override {} | |
49 void dispatchShowEvent() override {} | |
50 void dispatchErrorEvent() override {} | |
51 void dispatchCloseEvent() override {} | |
52 }; | |
53 | |
54 } // namespace | |
55 | |
56 class PendingNotificationsTrackerTest : public testing::Test { | |
57 public: | |
58 PendingNotificationsTrackerTest() | |
59 : tracker_(new PendingNotificationsTracker( | |
60 base::ThreadTaskRunnerHandle::Get())) {} | |
61 | |
62 ~PendingNotificationsTrackerTest() override { | |
63 GetURLLoaderMockFactory()->unregisterAllURLs(); | |
64 } | |
65 | |
66 void DidFetchResources(size_t index, const NotificationResources& resources) { | |
67 if (resources_.size() < index + 1) | |
68 resources_.resize(index + 1); | |
69 resources_[index] = resources; | |
70 } | |
71 | |
72 protected: | |
73 PendingNotificationsTracker* tracker() { return tracker_.get(); } | |
74 | |
75 size_t CountResources() { return resources_.size(); } | |
76 | |
77 NotificationResources* GetResources(size_t index) { | |
78 DCHECK_LT(index, resources_.size()); | |
79 return &resources_[index]; | |
80 } | |
81 | |
82 size_t CountPendingNotifications() { | |
83 return tracker_->pending_notifications_.size(); | |
84 } | |
85 | |
86 size_t CountDelegates() { | |
87 return tracker_->delegate_to_pending_id_map_.size(); | |
88 } | |
89 | |
90 blink::WebURLLoaderMockFactory* GetURLLoaderMockFactory() { | |
91 return blink::Platform::current()->getURLLoaderMockFactory(); | |
92 } | |
93 | |
94 // Registers a mocked url. When fetched, |file_name| will be loaded from the | |
95 // test data directory. | |
96 blink::WebURL RegisterMockedURL(const std::string& file_name) { | |
97 blink::WebURL url(GURL(kBaseUrl + file_name)); | |
98 | |
99 blink::WebURLResponse response(url); | |
100 response.setMIMEType("image/png"); | |
101 response.setHTTPStatusCode(200); | |
102 | |
103 base::FilePath file_path; | |
104 base::PathService::Get(base::DIR_SOURCE_ROOT, &file_path); | |
105 file_path = file_path.Append(FILE_PATH_LITERAL("content")) | |
106 .Append(FILE_PATH_LITERAL("test")) | |
107 .Append(FILE_PATH_LITERAL("data")) | |
108 .Append(FILE_PATH_LITERAL("notifications")) | |
109 .AppendASCII(file_name); | |
110 file_path = base::MakeAbsoluteFilePath(file_path); | |
111 blink::WebString string_file_path = | |
112 blink::WebString::fromUTF8(file_path.MaybeAsASCII()); | |
113 | |
114 GetURLLoaderMockFactory()->registerURL(url, response, string_file_path); | |
115 | |
116 return url; | |
117 } | |
118 | |
119 // Registers a mocked url that will fail to be fetched, with a 404 error. | |
120 blink::WebURL RegisterMockedErrorURL(const std::string& file_name) { | |
121 blink::WebURL url(GURL(kBaseUrl + file_name)); | |
122 | |
123 blink::WebURLResponse response(url); | |
124 response.setMIMEType("image/png"); | |
125 response.setHTTPStatusCode(404); | |
126 | |
127 blink::WebURLError error; | |
128 error.reason = 404; | |
129 | |
130 GetURLLoaderMockFactory()->registerErrorURL(url, response, error); | |
131 return url; | |
132 } | |
133 | |
134 private: | |
135 base::MessageLoop message_loop_; | |
136 std::unique_ptr<PendingNotificationsTracker> tracker_; | |
137 std::vector<NotificationResources> resources_; | |
138 | |
139 DISALLOW_COPY_AND_ASSIGN(PendingNotificationsTrackerTest); | |
140 }; | |
141 | |
142 TEST_F(PendingNotificationsTrackerTest, OneNotificationMultipleResources) { | |
143 blink::WebNotificationData notification_data; | |
144 notification_data.icon = RegisterMockedURL(kIcon100x100); | |
145 notification_data.badge = RegisterMockedURL(kIcon48x48); | |
146 notification_data.actions = | |
147 blink::WebVector<blink::WebNotificationAction>(static_cast<size_t>(2)); | |
148 notification_data.actions[0].icon = RegisterMockedURL(kIcon110x110); | |
149 notification_data.actions[1].icon = RegisterMockedURL(kIcon120x120); | |
150 | |
151 tracker()->FetchResources( | |
152 notification_data, nullptr /* delegate */, | |
153 base::Bind(&PendingNotificationsTrackerTest::DidFetchResources, | |
154 base::Unretained(this), 0 /* index */)); | |
155 | |
156 ASSERT_EQ(1u, CountPendingNotifications()); | |
157 ASSERT_EQ(0u, CountResources()); | |
158 | |
159 base::RunLoop().RunUntilIdle(); | |
160 GetURLLoaderMockFactory()->serveAsynchronousRequests(); | |
161 | |
162 ASSERT_EQ(0u, CountPendingNotifications()); | |
163 ASSERT_EQ(1u, CountResources()); | |
164 | |
165 NotificationResources* resources = GetResources(0u); | |
166 | |
167 ASSERT_FALSE(resources->notification_icon.drawsNothing()); | |
168 ASSERT_EQ(100, resources->notification_icon.width()); | |
169 | |
170 ASSERT_FALSE(resources->badge.drawsNothing()); | |
171 ASSERT_EQ(48, resources->badge.width()); | |
172 | |
173 ASSERT_EQ(2u, resources->action_icons.size()); | |
174 ASSERT_FALSE(resources->action_icons[0].drawsNothing()); | |
175 ASSERT_EQ(110, resources->action_icons[0].width()); | |
176 ASSERT_FALSE(resources->action_icons[1].drawsNothing()); | |
177 ASSERT_EQ(120, resources->action_icons[1].width()); | |
178 } | |
179 | |
180 TEST_F(PendingNotificationsTrackerTest, LargeIconsAreScaledDown) { | |
181 blink::WebNotificationData notification_data; | |
182 notification_data.icon = RegisterMockedURL(kIcon500x500); | |
183 notification_data.badge = notification_data.icon; | |
184 notification_data.actions = | |
185 blink::WebVector<blink::WebNotificationAction>(static_cast<size_t>(1)); | |
186 notification_data.actions[0].icon = notification_data.icon; | |
187 | |
188 tracker()->FetchResources( | |
189 notification_data, nullptr /* delegate */, | |
190 base::Bind(&PendingNotificationsTrackerTest::DidFetchResources, | |
191 base::Unretained(this), 0 /* index */)); | |
192 | |
193 ASSERT_EQ(1u, CountPendingNotifications()); | |
194 ASSERT_EQ(0u, CountResources()); | |
195 | |
196 base::RunLoop().RunUntilIdle(); | |
197 GetURLLoaderMockFactory()->serveAsynchronousRequests(); | |
198 | |
199 ASSERT_EQ(0u, CountPendingNotifications()); | |
200 ASSERT_EQ(1u, CountResources()); | |
201 | |
202 NotificationResources* resources = GetResources(0u); | |
203 | |
204 ASSERT_FALSE(resources->notification_icon.drawsNothing()); | |
205 ASSERT_EQ(kPlatformNotificationMaxIconSizePx, | |
206 resources->notification_icon.width()); | |
207 ASSERT_EQ(kPlatformNotificationMaxIconSizePx, | |
208 resources->notification_icon.height()); | |
209 | |
210 ASSERT_FALSE(resources->badge.drawsNothing()); | |
211 ASSERT_EQ(kPlatformNotificationMaxBadgeSizePx, resources->badge.width()); | |
212 ASSERT_EQ(kPlatformNotificationMaxBadgeSizePx, resources->badge.height()); | |
213 | |
214 ASSERT_EQ(1u, resources->action_icons.size()); | |
215 ASSERT_FALSE(resources->action_icons[0].drawsNothing()); | |
216 ASSERT_EQ(kPlatformNotificationMaxActionIconSizePx, | |
217 resources->action_icons[0].width()); | |
218 ASSERT_EQ(kPlatformNotificationMaxActionIconSizePx, | |
219 resources->action_icons[0].height()); | |
220 } | |
221 | |
222 TEST_F(PendingNotificationsTrackerTest, TwoNotifications) { | |
223 blink::WebNotificationData notification_data; | |
224 notification_data.icon = RegisterMockedURL(kIcon100x100); | |
225 | |
226 blink::WebNotificationData notification_data_2; | |
227 notification_data_2.icon = RegisterMockedURL(kIcon110x110); | |
228 | |
229 tracker()->FetchResources( | |
230 notification_data, nullptr /* delegate */, | |
231 base::Bind(&PendingNotificationsTrackerTest::DidFetchResources, | |
232 base::Unretained(this), 0 /* index */)); | |
233 | |
234 tracker()->FetchResources( | |
235 notification_data_2, nullptr /* delegate */, | |
236 base::Bind(&PendingNotificationsTrackerTest::DidFetchResources, | |
237 base::Unretained(this), 1 /* index */)); | |
238 | |
239 ASSERT_EQ(2u, CountPendingNotifications()); | |
240 ASSERT_EQ(0u, CountResources()); | |
241 | |
242 base::RunLoop().RunUntilIdle(); | |
243 GetURLLoaderMockFactory()->serveAsynchronousRequests(); | |
244 | |
245 ASSERT_EQ(0u, CountPendingNotifications()); | |
246 ASSERT_EQ(2u, CountResources()); | |
247 | |
248 ASSERT_FALSE(GetResources(0u)->notification_icon.drawsNothing()); | |
249 ASSERT_EQ(100, GetResources(0u)->notification_icon.width()); | |
250 | |
251 ASSERT_FALSE(GetResources(1u)->notification_icon.drawsNothing()); | |
252 ASSERT_EQ(110, GetResources(1u)->notification_icon.width()); | |
253 } | |
254 | |
255 TEST_F(PendingNotificationsTrackerTest, FetchError) { | |
256 blink::WebNotificationData notification_data; | |
257 notification_data.icon = RegisterMockedErrorURL(kIcon100x100); | |
258 | |
259 tracker()->FetchResources( | |
260 notification_data, nullptr /* delegate */, | |
261 base::Bind(&PendingNotificationsTrackerTest::DidFetchResources, | |
262 base::Unretained(this), 0 /* index */)); | |
263 | |
264 ASSERT_EQ(1u, CountPendingNotifications()); | |
265 ASSERT_EQ(0u, CountResources()); | |
266 | |
267 base::RunLoop().RunUntilIdle(); | |
268 GetURLLoaderMockFactory()->serveAsynchronousRequests(); | |
269 | |
270 ASSERT_EQ(0u, CountPendingNotifications()); | |
271 ASSERT_EQ(1u, CountResources()); | |
272 | |
273 ASSERT_TRUE(GetResources(0u)->notification_icon.drawsNothing()); | |
274 } | |
275 | |
276 TEST_F(PendingNotificationsTrackerTest, CancelFetches) { | |
277 blink::WebNotificationData notification_data; | |
278 notification_data.icon = RegisterMockedURL(kIcon100x100); | |
279 | |
280 FakeNotificationDelegate delegate; | |
281 | |
282 tracker()->FetchResources( | |
283 notification_data, &delegate, | |
284 base::Bind(&PendingNotificationsTrackerTest::DidFetchResources, | |
285 base::Unretained(this), 0 /* index */)); | |
286 | |
287 ASSERT_EQ(1u, CountPendingNotifications()); | |
288 ASSERT_EQ(1u, CountDelegates()); | |
289 ASSERT_EQ(0u, CountResources()); | |
290 | |
291 base::RunLoop().RunUntilIdle(); | |
292 tracker()->CancelResourceFetches(&delegate); | |
293 | |
294 ASSERT_EQ(0u, CountPendingNotifications()); | |
295 ASSERT_EQ(0u, CountDelegates()); | |
296 ASSERT_EQ(0u, CountResources()); | |
297 } | |
298 | |
299 } // namespace content | |
OLD | NEW |