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 "core/html/canvas/CanvasAsyncBlobCreator.h" | 5 #include "core/html/canvas/CanvasAsyncBlobCreator.h" |
6 | 6 |
7 #include "core/fileapi/Blob.h" | 7 #include "core/fileapi/Blob.h" |
8 #include "platform/Histogram.h" | |
8 #include "platform/ThreadSafeFunctional.h" | 9 #include "platform/ThreadSafeFunctional.h" |
9 #include "platform/graphics/ImageBuffer.h" | 10 #include "platform/graphics/ImageBuffer.h" |
10 #include "platform/image-encoders/JPEGImageEncoder.h" | 11 #include "platform/image-encoders/JPEGImageEncoder.h" |
11 #include "platform/image-encoders/PNGImageEncoder.h" | 12 #include "platform/image-encoders/PNGImageEncoder.h" |
12 #include "platform/threading/BackgroundTaskRunner.h" | 13 #include "platform/threading/BackgroundTaskRunner.h" |
13 #include "public/platform/Platform.h" | 14 #include "public/platform/Platform.h" |
14 #include "public/platform/WebScheduler.h" | 15 #include "public/platform/WebScheduler.h" |
15 #include "public/platform/WebTaskRunner.h" | 16 #include "public/platform/WebTaskRunner.h" |
16 #include "public/platform/WebThread.h" | 17 #include "public/platform/WebThread.h" |
17 #include "public/platform/WebTraceLocation.h" | 18 #include "public/platform/WebTraceLocation.h" |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
72 } else if (mimeType == "image/webp") { | 73 } else if (mimeType == "image/webp") { |
73 mimeTypeEnum = CanvasAsyncBlobCreator::MimeTypeWebp; | 74 mimeTypeEnum = CanvasAsyncBlobCreator::MimeTypeWebp; |
74 } else { | 75 } else { |
75 mimeTypeEnum = CanvasAsyncBlobCreator::NumberOfMimeTypeSupported; | 76 mimeTypeEnum = CanvasAsyncBlobCreator::NumberOfMimeTypeSupported; |
76 } | 77 } |
77 return mimeTypeEnum; | 78 return mimeTypeEnum; |
78 } | 79 } |
79 | 80 |
80 } // anonymous namespace | 81 } // anonymous namespace |
81 | 82 |
82 CanvasAsyncBlobCreator* CanvasAsyncBlobCreator::create(DOMUint8ClampedArray* unp remultipliedRGBAImageData, const String& mimeType, const IntSize& size, BlobCall back* callback) | 83 CanvasAsyncBlobCreator* CanvasAsyncBlobCreator::create(DOMUint8ClampedArray* unp remultipliedRGBAImageData, const String& mimeType, const IntSize& size, BlobCall back* callback, double startTime) |
83 { | 84 { |
84 return new CanvasAsyncBlobCreator(unpremultipliedRGBAImageData, convertMimeT ypeStringToEnum(mimeType), size, callback); | 85 return new CanvasAsyncBlobCreator(unpremultipliedRGBAImageData, convertMimeT ypeStringToEnum(mimeType), size, callback, startTime); |
85 } | 86 } |
86 | 87 |
87 CanvasAsyncBlobCreator::CanvasAsyncBlobCreator(DOMUint8ClampedArray* data, MimeT ype mimeType, const IntSize& size, BlobCallback* callback) | 88 CanvasAsyncBlobCreator::CanvasAsyncBlobCreator(DOMUint8ClampedArray* data, MimeT ype mimeType, const IntSize& size, BlobCallback* callback, double startTime) |
88 : m_data(data) | 89 : m_data(data) |
89 , m_size(size) | 90 , m_size(size) |
90 , m_mimeType(mimeType) | 91 , m_mimeType(mimeType) |
91 , m_callback(callback) | 92 , m_callback(callback) |
93 , m_startTime(startTime) | |
94 , m_elapsedTime(0) | |
92 { | 95 { |
93 ASSERT(m_data->length() == (unsigned) (size.height() * size.width() * 4)); | 96 ASSERT(m_data->length() == (unsigned) (size.height() * size.width() * 4)); |
94 m_encodedImage = wrapUnique(new Vector<unsigned char>()); | 97 m_encodedImage = wrapUnique(new Vector<unsigned char>()); |
95 m_pixelRowStride = size.width() * NumChannelsPng; | 98 m_pixelRowStride = size.width() * NumChannelsPng; |
96 m_idleTaskStatus = IdleTaskNotSupported; | 99 m_idleTaskStatus = IdleTaskNotSupported; |
97 m_numRowsCompleted = 0; | 100 m_numRowsCompleted = 0; |
98 } | 101 } |
99 | 102 |
100 CanvasAsyncBlobCreator::~CanvasAsyncBlobCreator() | 103 CanvasAsyncBlobCreator::~CanvasAsyncBlobCreator() |
101 { | 104 { |
(...skipping 27 matching lines...) Expand all Loading... | |
129 // There's no risk of concurrency as both tasks are on main thread. | 132 // There's no risk of concurrency as both tasks are on main thread. |
130 this->postDelayedTaskToMainThread(BLINK_FROM_HERE, bind(&CanvasAsyncBlob Creator::idleTaskStartTimeoutEvent, wrapPersistent(this), quality), IdleTaskStar tTimeoutDelay); | 133 this->postDelayedTaskToMainThread(BLINK_FROM_HERE, bind(&CanvasAsyncBlob Creator::idleTaskStartTimeoutEvent, wrapPersistent(this), quality), IdleTaskStar tTimeoutDelay); |
131 } else if (m_mimeType == MimeTypeWebp) { | 134 } else if (m_mimeType == MimeTypeWebp) { |
132 BackgroundTaskRunner::TaskSize taskSize = (m_size.height() * m_size.widt h() >= LongTaskImageSizeThreshold) ? BackgroundTaskRunner::TaskSizeLongRunningTa sk : BackgroundTaskRunner::TaskSizeShortRunningTask; | 135 BackgroundTaskRunner::TaskSize taskSize = (m_size.height() * m_size.widt h() >= LongTaskImageSizeThreshold) ? BackgroundTaskRunner::TaskSizeLongRunningTa sk : BackgroundTaskRunner::TaskSizeShortRunningTask; |
133 BackgroundTaskRunner::postOnBackgroundThread(BLINK_FROM_HERE, threadSafe Bind(&CanvasAsyncBlobCreator::encodeImageOnEncoderThread, wrapCrossThreadPersist ent(this), quality), taskSize); | 136 BackgroundTaskRunner::postOnBackgroundThread(BLINK_FROM_HERE, threadSafe Bind(&CanvasAsyncBlobCreator::encodeImageOnEncoderThread, wrapCrossThreadPersist ent(this), quality), taskSize); |
134 } | 137 } |
135 } | 138 } |
136 | 139 |
137 void CanvasAsyncBlobCreator::scheduleInitiateJpegEncoding(const double& quality) | 140 void CanvasAsyncBlobCreator::scheduleInitiateJpegEncoding(const double& quality) |
138 { | 141 { |
142 m_scheduleInitiateStartTime = WTF::monotonicallyIncreasingTime(); | |
139 Platform::current()->mainThread()->scheduler()->postIdleTask(BLINK_FROM_HERE , bind(&CanvasAsyncBlobCreator::initiateJpegEncoding, wrapPersistent(this), qual ity)); | 143 Platform::current()->mainThread()->scheduler()->postIdleTask(BLINK_FROM_HERE , bind(&CanvasAsyncBlobCreator::initiateJpegEncoding, wrapPersistent(this), qual ity)); |
140 } | 144 } |
141 | 145 |
142 void CanvasAsyncBlobCreator::initiateJpegEncoding(const double& quality, double deadlineSeconds) | 146 void CanvasAsyncBlobCreator::initiateJpegEncoding(const double& quality, double deadlineSeconds) |
143 { | 147 { |
144 ASSERT(isMainThread()); | 148 ASSERT(isMainThread()); |
149 DEFINE_STATIC_LOCAL(CustomCountHistogram, toBlobJPEGInitiateEncodingCounter, ("Blink.Canvas.ToBlob.InitiateEncodingDelay.JPEG", 0, 10000000, 50)); | |
150 toBlobJPEGInitiateEncodingCounter.count((WTF::monotonicallyIncreasingTime() - m_scheduleInitiateStartTime) * 1000000.0); | |
145 if (m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask) { | 151 if (m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask) { |
146 return; | 152 return; |
147 } | 153 } |
148 | 154 |
149 ASSERT(m_idleTaskStatus == IdleTaskNotStarted); | 155 ASSERT(m_idleTaskStatus == IdleTaskNotStarted); |
150 m_idleTaskStatus = IdleTaskStarted; | 156 m_idleTaskStatus = IdleTaskStarted; |
151 | 157 |
152 if (!initializeJpegStruct(quality)) { | 158 if (!initializeJpegStruct(quality)) { |
153 m_idleTaskStatus = IdleTaskFailed; | 159 m_idleTaskStatus = IdleTaskFailed; |
154 return; | 160 return; |
155 } | 161 } |
156 this->idleEncodeRowsJpeg(deadlineSeconds); | 162 this->idleEncodeRowsJpeg(deadlineSeconds); |
157 } | 163 } |
158 | 164 |
159 void CanvasAsyncBlobCreator::scheduleInitiatePngEncoding() | 165 void CanvasAsyncBlobCreator::scheduleInitiatePngEncoding() |
160 { | 166 { |
167 m_scheduleInitiateStartTime = WTF::monotonicallyIncreasingTime(); | |
161 Platform::current()->mainThread()->scheduler()->postIdleTask(BLINK_FROM_HERE , bind(&CanvasAsyncBlobCreator::initiatePngEncoding, wrapPersistent(this))); | 168 Platform::current()->mainThread()->scheduler()->postIdleTask(BLINK_FROM_HERE , bind(&CanvasAsyncBlobCreator::initiatePngEncoding, wrapPersistent(this))); |
162 } | 169 } |
163 | 170 |
164 void CanvasAsyncBlobCreator::initiatePngEncoding(double deadlineSeconds) | 171 void CanvasAsyncBlobCreator::initiatePngEncoding(double deadlineSeconds) |
165 { | 172 { |
166 ASSERT(isMainThread()); | 173 ASSERT(isMainThread()); |
174 DEFINE_STATIC_LOCAL(CustomCountHistogram, toBlobPNGInitiateEncodingCounter, ("Blink.Canvas.ToBlob.InitiateEncodingDelay.PNG", 0, 10000000, 50)); | |
175 toBlobPNGInitiateEncodingCounter.count((WTF::monotonicallyIncreasingTime() - m_scheduleInitiateStartTime) * 1000000.0); | |
167 if (m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask) { | 176 if (m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask) { |
168 return; | 177 return; |
169 } | 178 } |
170 | 179 |
171 ASSERT(m_idleTaskStatus == IdleTaskNotStarted); | 180 ASSERT(m_idleTaskStatus == IdleTaskNotStarted); |
172 m_idleTaskStatus = IdleTaskStarted; | 181 m_idleTaskStatus = IdleTaskStarted; |
173 | 182 |
174 if (!initializePngStruct()) { | 183 if (!initializePngStruct()) { |
175 m_idleTaskStatus = IdleTaskFailed; | 184 m_idleTaskStatus = IdleTaskFailed; |
176 return; | 185 return; |
177 } | 186 } |
178 this->idleEncodeRowsPng(deadlineSeconds); | 187 this->idleEncodeRowsPng(deadlineSeconds); |
179 } | 188 } |
180 | 189 |
181 void CanvasAsyncBlobCreator::idleEncodeRowsPng(double deadlineSeconds) | 190 void CanvasAsyncBlobCreator::idleEncodeRowsPng(double deadlineSeconds) |
182 { | 191 { |
183 ASSERT(isMainThread()); | 192 ASSERT(isMainThread()); |
184 if (m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask) { | 193 if (m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask) { |
185 return; | 194 return; |
186 } | 195 } |
187 | 196 |
188 unsigned char* inputPixels = m_data->data() + m_pixelRowStride * m_numRowsCo mpleted; | 197 unsigned char* inputPixels = m_data->data() + m_pixelRowStride * m_numRowsCo mpleted; |
189 for (int y = m_numRowsCompleted; y < m_size.height(); ++y) { | 198 for (int y = m_numRowsCompleted; y < m_size.height(); ++y) { |
199 double startTime = WTF::monotonicallyIncreasingTime(); | |
xlai (Olivia)
2016/06/24 14:56:09
This solution does not look great. Recording the t
xidachen
2016/06/24 15:27:55
Thanks. Fixed in the new patch.
| |
190 if (isDeadlineNearOrPassed(deadlineSeconds)) { | 200 if (isDeadlineNearOrPassed(deadlineSeconds)) { |
191 m_numRowsCompleted = y; | 201 m_numRowsCompleted = y; |
192 Platform::current()->currentThread()->scheduler()->postIdleTask(BLIN K_FROM_HERE, bind(&CanvasAsyncBlobCreator::idleEncodeRowsPng, wrapPersistent(thi s))); | 202 Platform::current()->currentThread()->scheduler()->postIdleTask(BLIN K_FROM_HERE, bind(&CanvasAsyncBlobCreator::idleEncodeRowsPng, wrapPersistent(thi s))); |
193 return; | 203 return; |
194 } | 204 } |
195 PNGImageEncoder::writeOneRowToPng(inputPixels, m_pngEncoderState.get()); | 205 PNGImageEncoder::writeOneRowToPng(inputPixels, m_pngEncoderState.get()); |
196 inputPixels += m_pixelRowStride; | 206 inputPixels += m_pixelRowStride; |
207 m_elapsedTime += (WTF::monotonicallyIncreasingTime() - startTime); | |
xlai (Olivia)
2016/06/24 14:56:09
Remove this.
| |
197 } | 208 } |
198 m_numRowsCompleted = m_size.height(); | 209 m_numRowsCompleted = m_size.height(); |
199 PNGImageEncoder::finalizePng(m_pngEncoderState.get()); | 210 PNGImageEncoder::finalizePng(m_pngEncoderState.get()); |
200 | 211 |
201 m_idleTaskStatus = IdleTaskCompleted; | 212 m_idleTaskStatus = IdleTaskCompleted; |
xlai (Olivia)
2016/06/24 14:56:09
Here, add m_elpaseTime += (WTF::monotonicallyIncre
| |
213 DEFINE_STATIC_LOCAL(CustomCountHistogram, toBlobPNGIdleEncodeCounter, ("Blin k.Canvas.ToBlob.IdleEncodeDuration.PNG", 0, 10000000, 50)); | |
214 toBlobPNGIdleEncodeCounter.count(m_elapsedTime * 1000000.0); | |
202 | 215 |
203 if (isDeadlineNearOrPassed(deadlineSeconds)) { | 216 if (isDeadlineNearOrPassed(deadlineSeconds)) { |
204 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FR OM_HERE, bind(&CanvasAsyncBlobCreator::createBlobAndInvokeCallback, wrapPersiste nt(this))); | 217 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FR OM_HERE, bind(&CanvasAsyncBlobCreator::createBlobAndInvokeCallback, wrapPersiste nt(this))); |
205 } else { | 218 } else { |
206 this->createBlobAndInvokeCallback(); | 219 this->createBlobAndInvokeCallback(); |
207 } | 220 } |
208 } | 221 } |
209 | 222 |
210 void CanvasAsyncBlobCreator::idleEncodeRowsJpeg(double deadlineSeconds) | 223 void CanvasAsyncBlobCreator::idleEncodeRowsJpeg(double deadlineSeconds) |
211 { | 224 { |
212 ASSERT(isMainThread()); | 225 ASSERT(isMainThread()); |
213 if (m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask) { | 226 if (m_idleTaskStatus == IdleTaskSwitchedToMainThreadTask) { |
214 return; | 227 return; |
215 } | 228 } |
216 | 229 |
230 double startTime = WTF::monotonicallyIncreasingTime(); | |
217 m_numRowsCompleted = JPEGImageEncoder::progressiveEncodeRowsJpegHelper(m_jpe gEncoderState.get(), m_data->data(), m_numRowsCompleted, SlackBeforeDeadline, de adlineSeconds); | 231 m_numRowsCompleted = JPEGImageEncoder::progressiveEncodeRowsJpegHelper(m_jpe gEncoderState.get(), m_data->data(), m_numRowsCompleted, SlackBeforeDeadline, de adlineSeconds); |
232 m_elapsedTime += (WTF::monotonicallyIncreasingTime() - startTime); | |
218 if (m_numRowsCompleted == m_size.height()) { | 233 if (m_numRowsCompleted == m_size.height()) { |
219 m_idleTaskStatus = IdleTaskCompleted; | 234 m_idleTaskStatus = IdleTaskCompleted; |
235 DEFINE_STATIC_LOCAL(CustomCountHistogram, toBlobJPEGIdleEncodeCounter, ( "Blink.Canvas.ToBlob.IdleEncodeDuration.JPEG", 0, 10000000, 50)); | |
236 toBlobJPEGIdleEncodeCounter.count(m_elapsedTime * 1000000.0); | |
220 if (isDeadlineNearOrPassed(deadlineSeconds)) { | 237 if (isDeadlineNearOrPassed(deadlineSeconds)) { |
221 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLIN K_FROM_HERE, bind(&CanvasAsyncBlobCreator::createBlobAndInvokeCallback, wrapPers istent(this))); | 238 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLIN K_FROM_HERE, bind(&CanvasAsyncBlobCreator::createBlobAndInvokeCallback, wrapPers istent(this))); |
222 } else { | 239 } else { |
223 this->createBlobAndInvokeCallback(); | 240 this->createBlobAndInvokeCallback(); |
224 } | 241 } |
225 } else if (m_numRowsCompleted == JPEGImageEncoder::ProgressiveEncodeFailed) { | 242 } else if (m_numRowsCompleted == JPEGImageEncoder::ProgressiveEncodeFailed) { |
226 m_idleTaskStatus = IdleTaskFailed; | 243 m_idleTaskStatus = IdleTaskFailed; |
227 this->createNullAndInvokeCallback(); | 244 this->createNullAndInvokeCallback(); |
228 } else { | 245 } else { |
229 Platform::current()->currentThread()->scheduler()->postIdleTask(BLINK_FR OM_HERE, bind(&CanvasAsyncBlobCreator::idleEncodeRowsJpeg, wrapPersistent(this)) ); | 246 Platform::current()->currentThread()->scheduler()->postIdleTask(BLINK_FR OM_HERE, bind(&CanvasAsyncBlobCreator::idleEncodeRowsJpeg, wrapPersistent(this)) ); |
(...skipping 23 matching lines...) Expand all Loading... | |
253 // Continue encoding from the last completed row | 270 // Continue encoding from the last completed row |
254 if (JPEGImageEncoder::encodeWithPreInitializedState(std::move(m_jpegEncoderS tate), m_data->data(), m_numRowsCompleted)) { | 271 if (JPEGImageEncoder::encodeWithPreInitializedState(std::move(m_jpegEncoderS tate), m_data->data(), m_numRowsCompleted)) { |
255 this->createBlobAndInvokeCallback(); | 272 this->createBlobAndInvokeCallback(); |
256 } else { | 273 } else { |
257 this->createNullAndInvokeCallback(); | 274 this->createNullAndInvokeCallback(); |
258 } | 275 } |
259 | 276 |
260 this->signalAlternativeCodePathFinishedForTesting(); | 277 this->signalAlternativeCodePathFinishedForTesting(); |
261 } | 278 } |
262 | 279 |
280 void CanvasAsyncBlobCreator::recordIdleTaskStatusHistogram() | |
281 { | |
282 DEFINE_STATIC_LOCAL(EnumerationHistogram, toBlobIdleTaskStatus, ("Blink.Canv as.ToBlob.IdleTaskStatus", IdleTaskNotSupported)); | |
283 toBlobIdleTaskStatus.count(m_idleTaskStatus); | |
284 } | |
285 | |
263 void CanvasAsyncBlobCreator::createBlobAndInvokeCallback() | 286 void CanvasAsyncBlobCreator::createBlobAndInvokeCallback() |
264 { | 287 { |
265 ASSERT(isMainThread()); | 288 ASSERT(isMainThread()); |
289 recordIdleTaskStatusHistogram(); | |
290 | |
291 double elapsedTime = WTF::monotonicallyIncreasingTime() - m_startTime; | |
292 if (m_mimeType == MimeTypePng) { | |
293 DEFINE_STATIC_LOCAL(CustomCountHistogram, toBlobPNGCounter, ("Blink.Canv as.ToBlobDuration.PNG", 0, 10000000, 50)); | |
294 toBlobPNGCounter.count(elapsedTime * 1000000.0); | |
295 } else if (m_mimeType == MimeTypeJpeg) { | |
296 DEFINE_STATIC_LOCAL(CustomCountHistogram, toBlobJPEGCounter, ("Blink.Can vas.ToBlobDuration.JPEG", 0, 10000000, 50)); | |
297 toBlobJPEGCounter.count(elapsedTime * 1000000.0); | |
298 } else { | |
299 DEFINE_STATIC_LOCAL(CustomCountHistogram, toBlobWEBPCounter, ("Blink.Can vas.ToBlobDuration.WEBP", 0, 10000000, 50)); | |
300 toBlobWEBPCounter.count(elapsedTime * 1000000.0); | |
301 } | |
266 Blob* resultBlob = Blob::create(m_encodedImage->data(), m_encodedImage->size (), convertMimeTypeEnumToString(m_mimeType)); | 302 Blob* resultBlob = Blob::create(m_encodedImage->data(), m_encodedImage->size (), convertMimeTypeEnumToString(m_mimeType)); |
267 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_H ERE, bind(&BlobCallback::handleEvent, wrapPersistent(m_callback.get()), wrapPers istent(resultBlob))); | 303 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_H ERE, bind(&BlobCallback::handleEvent, wrapPersistent(m_callback.get()), wrapPers istent(resultBlob))); |
268 // Avoid unwanted retention, see dispose(). | 304 // Avoid unwanted retention, see dispose(). |
269 dispose(); | 305 dispose(); |
270 } | 306 } |
271 | 307 |
272 void CanvasAsyncBlobCreator::createNullAndInvokeCallback() | 308 void CanvasAsyncBlobCreator::createNullAndInvokeCallback() |
273 { | 309 { |
274 ASSERT(isMainThread()); | 310 ASSERT(isMainThread()); |
311 recordIdleTaskStatusHistogram(); | |
275 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_H ERE, bind(&BlobCallback::handleEvent, wrapPersistent(m_callback.get()), nullptr) ); | 312 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_H ERE, bind(&BlobCallback::handleEvent, wrapPersistent(m_callback.get()), nullptr) ); |
276 // Avoid unwanted retention, see dispose(). | 313 // Avoid unwanted retention, see dispose(). |
277 dispose(); | 314 dispose(); |
278 } | 315 } |
279 | 316 |
280 void CanvasAsyncBlobCreator::encodeImageOnEncoderThread(double quality) | 317 void CanvasAsyncBlobCreator::encodeImageOnEncoderThread(double quality) |
281 { | 318 { |
282 ASSERT(!isMainThread()); | 319 ASSERT(!isMainThread()); |
283 ASSERT(m_mimeType == MimeTypeWebp); | 320 ASSERT(m_mimeType == MimeTypeWebp); |
284 | 321 |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
335 Platform::current()->mainThread()->getWebTaskRunner()->postTask( BLINK_FROM_HERE, bind(&CanvasAsyncBlobCreator::encodeRowsJpegOnMainThread, wrapP ersistent(this))); | 372 Platform::current()->mainThread()->getWebTaskRunner()->postTask( BLINK_FROM_HERE, bind(&CanvasAsyncBlobCreator::encodeRowsJpegOnMainThread, wrapP ersistent(this))); |
336 } else { | 373 } else { |
337 // Failing in initialization of jpeg struct | 374 // Failing in initialization of jpeg struct |
338 this->signalAlternativeCodePathFinishedForTesting(); | 375 this->signalAlternativeCodePathFinishedForTesting(); |
339 } | 376 } |
340 } | 377 } |
341 } else { | 378 } else { |
342 ASSERT(m_idleTaskStatus == IdleTaskFailed || m_idleTaskStatus == IdleTas kCompleted); | 379 ASSERT(m_idleTaskStatus == IdleTaskFailed || m_idleTaskStatus == IdleTas kCompleted); |
343 this->signalAlternativeCodePathFinishedForTesting(); | 380 this->signalAlternativeCodePathFinishedForTesting(); |
344 } | 381 } |
345 | |
346 } | 382 } |
347 | 383 |
348 void CanvasAsyncBlobCreator::idleTaskCompleteTimeoutEvent() | 384 void CanvasAsyncBlobCreator::idleTaskCompleteTimeoutEvent() |
349 { | 385 { |
350 ASSERT(m_idleTaskStatus != IdleTaskNotStarted); | 386 ASSERT(m_idleTaskStatus != IdleTaskNotStarted); |
351 | 387 |
352 if (m_idleTaskStatus == IdleTaskStarted) { | 388 if (m_idleTaskStatus == IdleTaskStarted) { |
353 // It has taken too long to complete for the idle task. | 389 // It has taken too long to complete for the idle task. |
354 m_idleTaskStatus = IdleTaskSwitchedToMainThreadTask; | 390 m_idleTaskStatus = IdleTaskSwitchedToMainThreadTask; |
355 signalTaskSwitchInCompleteTimeoutEventForTesting(); | 391 signalTaskSwitchInCompleteTimeoutEventForTesting(); |
(...skipping 10 matching lines...) Expand all Loading... | |
366 } | 402 } |
367 } | 403 } |
368 | 404 |
369 void CanvasAsyncBlobCreator::postDelayedTaskToMainThread(const WebTraceLocation& location, std::unique_ptr<SameThreadClosure> task, double delayMs) | 405 void CanvasAsyncBlobCreator::postDelayedTaskToMainThread(const WebTraceLocation& location, std::unique_ptr<SameThreadClosure> task, double delayMs) |
370 { | 406 { |
371 DCHECK(isMainThread()); | 407 DCHECK(isMainThread()); |
372 Platform::current()->mainThread()->getWebTaskRunner()->postDelayedTask(locat ion, std::move(task), delayMs); | 408 Platform::current()->mainThread()->getWebTaskRunner()->postDelayedTask(locat ion, std::move(task), delayMs); |
373 } | 409 } |
374 | 410 |
375 } // namespace blink | 411 } // namespace blink |
OLD | NEW |