OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2012 Google Inc. All rights reserved. | 2 * Copyright (C) 2012 Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions | 5 * modification, are permitted provided that the following conditions |
6 * are met: | 6 * are met: |
7 * | 7 * |
8 * 1. Redistributions of source code must retain the above copyright | 8 * 1. Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * 2. Redistributions in binary form must reproduce the above copyright | 10 * 2. Redistributions in binary form must reproduce the above copyright |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
126 ImageFrame::Status next_frame_status_; | 126 ImageFrame::Status next_frame_status_; |
127 size_t frame_count_; | 127 size_t frame_count_; |
128 size_t requested_clear_except_frame_; | 128 size_t requested_clear_except_frame_; |
129 }; | 129 }; |
130 | 130 |
131 TEST_F(ImageFrameGeneratorTest, incompleteDecode) { | 131 TEST_F(ImageFrameGeneratorTest, incompleteDecode) { |
132 SetFrameStatus(ImageFrame::kFramePartial); | 132 SetFrameStatus(ImageFrame::kFramePartial); |
133 | 133 |
134 char buffer[100 * 100 * 4]; | 134 char buffer[100 * 100 * 4]; |
135 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), | 135 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), |
136 buffer, 100 * 4); | 136 buffer, 100 * 4, |
| 137 ImageDecoder::kAlphaPremultiplied); |
137 EXPECT_EQ(1, decode_request_count_); | 138 EXPECT_EQ(1, decode_request_count_); |
138 | 139 |
139 AddNewData(); | 140 AddNewData(); |
140 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), | 141 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), |
141 buffer, 100 * 4); | 142 buffer, 100 * 4, |
| 143 ImageDecoder::kAlphaPremultiplied); |
142 EXPECT_EQ(2, decode_request_count_); | 144 EXPECT_EQ(2, decode_request_count_); |
143 EXPECT_EQ(0, decoders_destroyed_); | 145 EXPECT_EQ(0, decoders_destroyed_); |
144 } | 146 } |
145 | 147 |
146 TEST_F(ImageFrameGeneratorTest, incompleteDecodeBecomesComplete) { | 148 TEST_F(ImageFrameGeneratorTest, incompleteDecodeBecomesComplete) { |
147 SetFrameStatus(ImageFrame::kFramePartial); | 149 SetFrameStatus(ImageFrame::kFramePartial); |
148 | 150 |
149 char buffer[100 * 100 * 4]; | 151 char buffer[100 * 100 * 4]; |
150 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), | 152 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), |
151 buffer, 100 * 4); | 153 buffer, 100 * 4, |
| 154 ImageDecoder::kAlphaPremultiplied); |
152 EXPECT_EQ(1, decode_request_count_); | 155 EXPECT_EQ(1, decode_request_count_); |
153 EXPECT_EQ(0, decoders_destroyed_); | 156 EXPECT_EQ(0, decoders_destroyed_); |
154 | 157 |
155 SetFrameStatus(ImageFrame::kFrameComplete); | 158 SetFrameStatus(ImageFrame::kFrameComplete); |
156 AddNewData(); | 159 AddNewData(); |
157 | 160 |
158 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), | 161 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), |
159 buffer, 100 * 4); | 162 buffer, 100 * 4, |
| 163 ImageDecoder::kAlphaPremultiplied); |
160 EXPECT_EQ(2, decode_request_count_); | 164 EXPECT_EQ(2, decode_request_count_); |
161 EXPECT_EQ(1, decoders_destroyed_); | 165 EXPECT_EQ(1, decoders_destroyed_); |
162 | 166 |
163 // Decoder created again. | 167 // Decoder created again. |
164 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), | 168 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), |
165 buffer, 100 * 4); | 169 buffer, 100 * 4, |
| 170 ImageDecoder::kAlphaPremultiplied); |
166 EXPECT_EQ(3, decode_request_count_); | 171 EXPECT_EQ(3, decode_request_count_); |
167 } | 172 } |
168 | 173 |
169 static void DecodeThreadMain(ImageFrameGenerator* generator, | 174 static void DecodeThreadMain(ImageFrameGenerator* generator, |
170 SegmentReader* segment_reader) { | 175 SegmentReader* segment_reader) { |
171 char buffer[100 * 100 * 4]; | 176 char buffer[100 * 100 * 4]; |
172 generator->DecodeAndScale(segment_reader, false, 0, ImageInfo(), buffer, | 177 generator->DecodeAndScale(segment_reader, false, 0, ImageInfo(), buffer, |
173 100 * 4); | 178 100 * 4, ImageDecoder::kAlphaPremultiplied); |
174 } | 179 } |
175 | 180 |
176 TEST_F(ImageFrameGeneratorTest, incompleteDecodeBecomesCompleteMultiThreaded) { | 181 TEST_F(ImageFrameGeneratorTest, incompleteDecodeBecomesCompleteMultiThreaded) { |
177 SetFrameStatus(ImageFrame::kFramePartial); | 182 SetFrameStatus(ImageFrame::kFramePartial); |
178 | 183 |
179 char buffer[100 * 100 * 4]; | 184 char buffer[100 * 100 * 4]; |
180 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), | 185 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), |
181 buffer, 100 * 4); | 186 buffer, 100 * 4, |
| 187 ImageDecoder::kAlphaPremultiplied); |
182 EXPECT_EQ(1, decode_request_count_); | 188 EXPECT_EQ(1, decode_request_count_); |
183 EXPECT_EQ(0, decoders_destroyed_); | 189 EXPECT_EQ(0, decoders_destroyed_); |
184 | 190 |
185 // LocalFrame can now be decoded completely. | 191 // LocalFrame can now be decoded completely. |
186 SetFrameStatus(ImageFrame::kFrameComplete); | 192 SetFrameStatus(ImageFrame::kFrameComplete); |
187 AddNewData(); | 193 AddNewData(); |
188 std::unique_ptr<WebThread> thread = | 194 std::unique_ptr<WebThread> thread = |
189 WTF::WrapUnique(Platform::Current()->CreateThread("DecodeThread")); | 195 WTF::WrapUnique(Platform::Current()->CreateThread("DecodeThread")); |
190 thread->GetWebTaskRunner()->PostTask( | 196 thread->GetWebTaskRunner()->PostTask( |
191 BLINK_FROM_HERE, | 197 BLINK_FROM_HERE, |
192 CrossThreadBind(&DecodeThreadMain, generator_, segment_reader_)); | 198 CrossThreadBind(&DecodeThreadMain, generator_, segment_reader_)); |
193 thread.reset(); | 199 thread.reset(); |
194 EXPECT_EQ(2, decode_request_count_); | 200 EXPECT_EQ(2, decode_request_count_); |
195 EXPECT_EQ(1, decoders_destroyed_); | 201 EXPECT_EQ(1, decoders_destroyed_); |
196 | 202 |
197 // Decoder created again. | 203 // Decoder created again. |
198 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), | 204 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), |
199 buffer, 100 * 4); | 205 buffer, 100 * 4, |
| 206 ImageDecoder::kAlphaPremultiplied); |
200 EXPECT_EQ(3, decode_request_count_); | 207 EXPECT_EQ(3, decode_request_count_); |
201 | 208 |
202 AddNewData(); | 209 AddNewData(); |
203 | 210 |
204 // Delete generator. | 211 // Delete generator. |
205 generator_ = nullptr; | 212 generator_ = nullptr; |
206 } | 213 } |
207 | 214 |
208 TEST_F(ImageFrameGeneratorTest, frameHasAlpha) { | 215 TEST_F(ImageFrameGeneratorTest, frameHasAlpha) { |
209 SetFrameStatus(ImageFrame::kFramePartial); | 216 SetFrameStatus(ImageFrame::kFramePartial); |
210 | 217 |
211 char buffer[100 * 100 * 4]; | 218 char buffer[100 * 100 * 4]; |
212 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), | 219 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), |
213 buffer, 100 * 4); | 220 buffer, 100 * 4, |
| 221 ImageDecoder::kAlphaPremultiplied); |
214 EXPECT_TRUE(generator_->HasAlpha(0)); | 222 EXPECT_TRUE(generator_->HasAlpha(0)); |
215 EXPECT_EQ(1, decode_request_count_); | 223 EXPECT_EQ(1, decode_request_count_); |
216 | 224 |
217 ImageDecoder* temp_decoder = 0; | 225 ImageDecoder* temp_decoder = 0; |
218 EXPECT_TRUE(ImageDecodingStore::Instance().LockDecoder( | 226 EXPECT_TRUE(ImageDecodingStore::Instance().LockDecoder( |
219 generator_.Get(), FullSize(), &temp_decoder)); | 227 generator_.Get(), FullSize(), ImageDecoder::kAlphaPremultiplied, |
| 228 &temp_decoder)); |
220 ASSERT_TRUE(temp_decoder); | 229 ASSERT_TRUE(temp_decoder); |
221 temp_decoder->FrameBufferAtIndex(0)->SetHasAlpha(false); | 230 temp_decoder->FrameBufferAtIndex(0)->SetHasAlpha(false); |
222 ImageDecodingStore::Instance().UnlockDecoder(generator_.Get(), temp_decoder); | 231 ImageDecodingStore::Instance().UnlockDecoder(generator_.Get(), temp_decoder); |
223 EXPECT_EQ(2, decode_request_count_); | 232 EXPECT_EQ(2, decode_request_count_); |
224 | 233 |
225 SetFrameStatus(ImageFrame::kFrameComplete); | 234 SetFrameStatus(ImageFrame::kFrameComplete); |
226 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), | 235 generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(), |
227 buffer, 100 * 4); | 236 buffer, 100 * 4, |
| 237 ImageDecoder::kAlphaPremultiplied); |
228 EXPECT_EQ(3, decode_request_count_); | 238 EXPECT_EQ(3, decode_request_count_); |
229 EXPECT_FALSE(generator_->HasAlpha(0)); | 239 EXPECT_FALSE(generator_->HasAlpha(0)); |
230 } | 240 } |
231 | 241 |
232 TEST_F(ImageFrameGeneratorTest, clearMultiFrameDecoder) { | 242 TEST_F(ImageFrameGeneratorTest, clearMultiFrameDecoder) { |
233 SetFrameCount(3); | 243 SetFrameCount(3); |
234 SetFrameStatus(ImageFrame::kFrameComplete); | 244 SetFrameStatus(ImageFrame::kFrameComplete); |
235 | 245 |
236 char buffer[100 * 100 * 4]; | 246 char buffer[100 * 100 * 4]; |
237 generator_->DecodeAndScale(segment_reader_.Get(), true, 0, ImageInfo(), | 247 generator_->DecodeAndScale(segment_reader_.Get(), true, 0, ImageInfo(), |
238 buffer, 100 * 4); | 248 buffer, 100 * 4, |
| 249 ImageDecoder::kAlphaPremultiplied); |
239 EXPECT_EQ(1, decode_request_count_); | 250 EXPECT_EQ(1, decode_request_count_); |
240 EXPECT_EQ(0, decoders_destroyed_); | 251 EXPECT_EQ(0, decoders_destroyed_); |
241 EXPECT_EQ(0U, requested_clear_except_frame_); | 252 EXPECT_EQ(0U, requested_clear_except_frame_); |
242 | 253 |
243 SetFrameStatus(ImageFrame::kFrameComplete); | 254 SetFrameStatus(ImageFrame::kFrameComplete); |
244 | 255 |
245 generator_->DecodeAndScale(segment_reader_.Get(), true, 1, ImageInfo(), | 256 generator_->DecodeAndScale(segment_reader_.Get(), true, 1, ImageInfo(), |
246 buffer, 100 * 4); | 257 buffer, 100 * 4, |
| 258 ImageDecoder::kAlphaPremultiplied); |
247 EXPECT_EQ(2, decode_request_count_); | 259 EXPECT_EQ(2, decode_request_count_); |
248 EXPECT_EQ(0, decoders_destroyed_); | 260 EXPECT_EQ(0, decoders_destroyed_); |
249 EXPECT_EQ(1U, requested_clear_except_frame_); | 261 EXPECT_EQ(1U, requested_clear_except_frame_); |
250 | 262 |
251 SetFrameStatus(ImageFrame::kFrameComplete); | 263 SetFrameStatus(ImageFrame::kFrameComplete); |
252 | 264 |
253 // Decoding the last frame of a multi-frame images should trigger clearing | 265 // Decoding the last frame of a multi-frame images should trigger clearing |
254 // all the frame data, but not destroying the decoder. See comments in | 266 // all the frame data, but not destroying the decoder. See comments in |
255 // ImageFrameGenerator::tryToResumeDecode(). | 267 // ImageFrameGenerator::tryToResumeDecode(). |
256 generator_->DecodeAndScale(segment_reader_.Get(), true, 2, ImageInfo(), | 268 generator_->DecodeAndScale(segment_reader_.Get(), true, 2, ImageInfo(), |
257 buffer, 100 * 4); | 269 buffer, 100 * 4, |
| 270 ImageDecoder::kAlphaPremultiplied); |
258 EXPECT_EQ(3, decode_request_count_); | 271 EXPECT_EQ(3, decode_request_count_); |
259 EXPECT_EQ(0, decoders_destroyed_); | 272 EXPECT_EQ(0, decoders_destroyed_); |
260 EXPECT_EQ(kNotFound, requested_clear_except_frame_); | 273 EXPECT_EQ(kNotFound, requested_clear_except_frame_); |
261 } | 274 } |
262 | 275 |
263 } // namespace blink | 276 } // namespace blink |
OLD | NEW |