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 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
87 : m_data(data) | 88 : m_data(data) |
88 , m_size(size) | 89 , m_size(size) |
89 , m_mimeType(mimeType) | 90 , m_mimeType(mimeType) |
90 , m_callback(callback) | 91 , m_callback(callback) |
91 { | 92 { |
92 ASSERT(m_data->length() == (unsigned) (size.height() * size.width() * 4)); | 93 ASSERT(m_data->length() == (unsigned) (size.height() * size.width() * 4)); |
93 m_encodedImage = adoptPtr(new Vector<unsigned char>()); | 94 m_encodedImage = adoptPtr(new Vector<unsigned char>()); |
94 m_pixelRowStride = size.width() * NumChannelsPng; | 95 m_pixelRowStride = size.width() * NumChannelsPng; |
95 m_idleTaskStatus = IdleTaskNotSupported; | 96 m_idleTaskStatus = IdleTaskNotSupported; |
96 m_numRowsCompleted = 0; | 97 m_numRowsCompleted = 0; |
98 m_startTime = WTF::monotonicallyIncreasingTime(); | |
xlai (Olivia)
2016/06/07 16:08:14
To measure the total elapsed time of toBlob API ca
xidachen
2016/06/07 20:46:29
Yes, that makes total sense. I place the start aft
| |
97 } | 99 } |
98 | 100 |
99 CanvasAsyncBlobCreator::~CanvasAsyncBlobCreator() | 101 CanvasAsyncBlobCreator::~CanvasAsyncBlobCreator() |
100 { | 102 { |
101 } | 103 } |
102 | 104 |
103 void CanvasAsyncBlobCreator::scheduleAsyncBlobCreation(bool canUseIdlePeriodSche duling, const double& quality) | 105 void CanvasAsyncBlobCreator::scheduleAsyncBlobCreation(bool canUseIdlePeriodSche duling, const double& quality) |
104 { | 106 { |
105 ASSERT(isMainThread()); | 107 ASSERT(isMainThread()); |
106 | 108 |
107 if (canUseIdlePeriodScheduling) { | 109 if (canUseIdlePeriodScheduling) { |
108 m_idleTaskStatus = IdleTaskNotStarted; | 110 m_idleTaskStatus = IdleTaskNotStarted; |
109 if (m_mimeType == MimeTypePng) { | 111 if (m_mimeType == MimeTypePng) { |
110 this->scheduleInitiatePngEncoding(); | 112 this->scheduleInitiatePngEncoding(); |
111 } else if (m_mimeType == MimeTypeJpeg) { | 113 } else if (m_mimeType == MimeTypeJpeg) { |
112 this->scheduleInitiateJpegEncoding(quality); | 114 this->scheduleInitiateJpegEncoding(quality); |
113 } else { | 115 } else { |
114 // Progressive encoding is only applicable to png and jpeg image for mat, | 116 // Progressive encoding is only applicable to png and jpeg image for mat, |
115 // and thus idle tasks scheduling can only be applied to these image formats. | 117 // and thus idle tasks scheduling can only be applied to these image formats. |
116 // TODO(xlai): Progressive encoding on webp image formats (crbug.com /571399) | 118 // TODO(xlai): Progressive encoding on webp image formats (crbug.com /571399) |
117 ASSERT_NOT_REACHED(); | 119 ASSERT_NOT_REACHED(); |
118 } | 120 } |
119 // We post the below task to check if the above idle task isn't late. | 121 // We post the below task to check if the above idle task isn't late. |
120 // There's no risk of concurrency as both tasks are on main thread. | 122 // There's no risk of concurrency as both tasks are on main thread. |
121 this->postDelayedTaskToMainThread(BLINK_FROM_HERE, bind(&CanvasAsyncBlob Creator::idleTaskStartTimeoutEvent, this, quality), IdleTaskStartTimeoutDelay); | 123 double startTime = WTF::monotonicallyIncreasingTime(); |
124 this->postDelayedTaskToMainThread(BLINK_FROM_HERE, bind(&CanvasAsyncBlob Creator::idleTaskStartTimeoutEvent, this, quality, startTime), IdleTaskStartTime outDelay); | |
122 } else if (m_mimeType == MimeTypeWebp) { | 125 } else if (m_mimeType == MimeTypeWebp) { |
123 BackgroundTaskRunner::TaskSize taskSize = (m_size.height() * m_size.widt h() >= LongTaskImageSizeThreshold) ? BackgroundTaskRunner::TaskSizeLongRunningTa sk : BackgroundTaskRunner::TaskSizeShortRunningTask; | 126 BackgroundTaskRunner::TaskSize taskSize = (m_size.height() * m_size.widt h() >= LongTaskImageSizeThreshold) ? BackgroundTaskRunner::TaskSizeLongRunningTa sk : BackgroundTaskRunner::TaskSizeShortRunningTask; |
124 BackgroundTaskRunner::postOnBackgroundThread(BLINK_FROM_HERE, threadSafe Bind(&CanvasAsyncBlobCreator::encodeImageOnEncoderThread, wrapCrossThreadPersist ent(this), quality), taskSize); | 127 BackgroundTaskRunner::postOnBackgroundThread(BLINK_FROM_HERE, threadSafe Bind(&CanvasAsyncBlobCreator::encodeImageOnEncoderThread, wrapCrossThreadPersist ent(this), quality), taskSize); |
125 } | 128 } |
126 } | 129 } |
127 | 130 |
128 void CanvasAsyncBlobCreator::scheduleInitiateJpegEncoding(const double& quality) | 131 void CanvasAsyncBlobCreator::scheduleInitiateJpegEncoding(const double& quality) |
129 { | 132 { |
130 Platform::current()->mainThread()->scheduler()->postIdleTask(BLINK_FROM_HERE , bind<double>(&CanvasAsyncBlobCreator::initiateJpegEncoding, this, quality)); | 133 Platform::current()->mainThread()->scheduler()->postIdleTask(BLINK_FROM_HERE , bind<double>(&CanvasAsyncBlobCreator::initiateJpegEncoding, this, quality)); |
131 } | 134 } |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
253 | 256 |
254 void CanvasAsyncBlobCreator::createBlobAndInvokeCallback() | 257 void CanvasAsyncBlobCreator::createBlobAndInvokeCallback() |
255 { | 258 { |
256 ASSERT(isMainThread()); | 259 ASSERT(isMainThread()); |
257 Blob* resultBlob = Blob::create(m_encodedImage->data(), m_encodedImage->size (), convertMimeTypeEnumToString(m_mimeType)); | 260 Blob* resultBlob = Blob::create(m_encodedImage->data(), m_encodedImage->size (), convertMimeTypeEnumToString(m_mimeType)); |
258 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_H ERE, bind(&BlobCallback::handleEvent, m_callback, resultBlob)); | 261 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_H ERE, bind(&BlobCallback::handleEvent, m_callback, resultBlob)); |
259 // Since toBlob is done, timeout events are no longer needed. So we clear | 262 // Since toBlob is done, timeout events are no longer needed. So we clear |
260 // non-GC members to allow teardown of CanvasAsyncBlobCreator. | 263 // non-GC members to allow teardown of CanvasAsyncBlobCreator. |
261 m_data.clear(); | 264 m_data.clear(); |
262 m_callback.clear(); | 265 m_callback.clear(); |
266 double elapsedTime = WTF::monotonicallyIncreasingTime() - m_startTime; | |
267 if (m_mimeType == MimeTypePng) { | |
268 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobPNGCounter, new CustomCountHistogram("Blink.Canvas.ToBlob.PNG.Succeed", 0, 10000000, 50)); | |
269 toBlobPNGCounter.count(elapsedTime * 1000000.0); | |
270 } else if (m_mimeType == MimeTypeJpeg) { | |
271 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobJPEGCounter, new CustomCountHistogram("Blink.Canvas.ToBlob.JPEG.Succeed", 0, 10000000, 50)); | |
272 toBlobJPEGCounter.count(elapsedTime * 1000000.0); | |
273 } else if (m_mimeType == MimeTypeWebp) { | |
274 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobWEBPCounter, new CustomCountHistogram("Blink.Canvas.ToBlob.WEBP.Succeed", 0, 10000000, 50)); | |
275 toBlobWEBPCounter.count(elapsedTime * 1000000.0); | |
276 } else { | |
277 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobUnknownCount er, new CustomCountHistogram("Blink.Canvas.ToBlob.Unknown.Succeed", 0, 10000000, 50)); | |
xlai (Olivia)
2016/06/07 16:08:14
"Unknown" type is impossible to reach here. See "A
xidachen
2016/06/07 20:46:28
Done.
| |
278 toBlobUnknownCounter.count(elapsedTime * 1000000.0); | |
279 } | |
263 } | 280 } |
264 | 281 |
265 void CanvasAsyncBlobCreator::createNullAndInvokeCallback() | 282 void CanvasAsyncBlobCreator::createNullAndInvokeCallback() |
266 { | 283 { |
267 ASSERT(isMainThread()); | 284 ASSERT(isMainThread()); |
268 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_H ERE, bind(&BlobCallback::handleEvent, m_callback, nullptr)); | 285 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_H ERE, bind(&BlobCallback::handleEvent, m_callback, nullptr)); |
269 // Since toBlob is done (failed), timeout events are no longer needed. So we | 286 // Since toBlob is done (failed), timeout events are no longer needed. So we |
270 // clear non-GC members to allow teardown of CanvasAsyncBlobCreator. | 287 // clear non-GC members to allow teardown of CanvasAsyncBlobCreator. |
271 m_data.clear(); | 288 m_data.clear(); |
272 m_callback.clear(); | 289 m_callback.clear(); |
290 double elapsedTime = WTF::monotonicallyIncreasingTime() - m_startTime; | |
291 if (m_mimeType == MimeTypePng) { | |
292 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobPNGCounter, new CustomCountHistogram("Blink.Canvas.ToBlob.PNG.Failed", 0, 10000000, 50)); | |
xlai (Olivia)
2016/06/07 16:08:14
I sincerely feels that such a detailed histogram f
xidachen
2016/06/07 20:46:28
Done.
| |
293 toBlobPNGCounter.count(elapsedTime * 1000000.0); | |
294 } else if (m_mimeType == MimeTypeJpeg) { | |
295 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobJPEGCounter, new CustomCountHistogram("Blink.Canvas.ToBlob.JPEG.Failed", 0, 10000000, 50)); | |
296 toBlobJPEGCounter.count(elapsedTime * 1000000.0); | |
297 } else if (m_mimeType == MimeTypeWebp) { | |
298 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobWEBPCounter, new CustomCountHistogram("Blink.Canvas.ToBlob.WEBP.Failed", 0, 10000000, 50)); | |
299 toBlobWEBPCounter.count(elapsedTime * 1000000.0); | |
300 } else { | |
301 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobUnknownCount er, new CustomCountHistogram("Blink.Canvas.ToBlob.Unknown.Failed", 0, 10000000, 50)); | |
302 toBlobUnknownCounter.count(elapsedTime * 1000000.0); | |
303 } | |
273 } | 304 } |
274 | 305 |
275 void CanvasAsyncBlobCreator::encodeImageOnEncoderThread(double quality) | 306 void CanvasAsyncBlobCreator::encodeImageOnEncoderThread(double quality) |
276 { | 307 { |
277 ASSERT(!isMainThread()); | 308 ASSERT(!isMainThread()); |
278 ASSERT(m_mimeType == MimeTypeWebp); | 309 ASSERT(m_mimeType == MimeTypeWebp); |
279 | 310 |
280 if (!ImageDataBuffer(m_size, m_data->data()).encodeImage("image/webp", quali ty, m_encodedImage.get())) { | 311 if (!ImageDataBuffer(m_size, m_data->data()).encodeImage("image/webp", quali ty, m_encodedImage.get())) { |
281 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FR OM_HERE, threadSafeBind(&BlobCallback::handleEvent, wrapCrossThreadPersistent(m_ callback.get()), nullptr)); | 312 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FR OM_HERE, threadSafeBind(&BlobCallback::handleEvent, wrapCrossThreadPersistent(m_ callback.get()), nullptr)); |
282 return; | 313 return; |
(...skipping 15 matching lines...) Expand all Loading... | |
298 bool CanvasAsyncBlobCreator::initializeJpegStruct(double quality) | 329 bool CanvasAsyncBlobCreator::initializeJpegStruct(double quality) |
299 { | 330 { |
300 m_jpegEncoderState = JPEGImageEncoderState::create(m_size, quality, m_encode dImage.get()); | 331 m_jpegEncoderState = JPEGImageEncoderState::create(m_size, quality, m_encode dImage.get()); |
301 if (!m_jpegEncoderState) { | 332 if (!m_jpegEncoderState) { |
302 this->createNullAndInvokeCallback(); | 333 this->createNullAndInvokeCallback(); |
303 return false; | 334 return false; |
304 } | 335 } |
305 return true; | 336 return true; |
306 } | 337 } |
307 | 338 |
308 void CanvasAsyncBlobCreator::idleTaskStartTimeoutEvent(double quality) | 339 void CanvasAsyncBlobCreator::recordTimeoutEvent(IdleTaskTimeoutType type) |
309 { | 340 { |
341 if (m_mimeType == MimeTypePng) { | |
342 DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, idleTaskTimeoutEve ntPNG, new EnumerationHistogram("Canvas.ToBlob.IdleTaskTimeout.PNG", IdleTaskTim eoutSupported)); | |
xlai (Olivia)
2016/06/07 16:08:14
What is the purpose of this histogram?
xidachen
2016/06/07 20:46:29
Change this to record the occurrence of switch fro
| |
343 idleTaskTimeoutEventPNG.count(type); | |
344 } else if (m_mimeType == MimeTypeJpeg) { | |
345 DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, idleTaskTimeoutEve ntJPEG, new EnumerationHistogram("Canvas.ToBlob.IdleTaskTimeout.JPEG", IdleTaskT imeoutSupported)); | |
346 idleTaskTimeoutEventJPEG.count(type); | |
347 } else if (m_mimeType == MimeTypeWebp) { | |
348 DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, idleTaskTimeoutEve ntWEBP, new EnumerationHistogram("Canvas.ToBlob.IdleTaskTimeout.WEBP", IdleTaskT imeoutSupported)); | |
349 idleTaskTimeoutEventWEBP.count(type); | |
350 } else { | |
351 DEFINE_THREAD_SAFE_STATIC_LOCAL(EnumerationHistogram, idleTaskTimeoutEve ntUnknown, new EnumerationHistogram("Canvas.ToBlob.IdleTaskTimeout.Unknown", Idl eTaskTimeoutSupported)); | |
352 idleTaskTimeoutEventUnknown.count(type); | |
353 } | |
354 } | |
355 | |
356 void CanvasAsyncBlobCreator::idleTaskStartTimeoutEvent(double quality, double st artTime) | |
357 { | |
358 recordTimeoutEvent(IdleTaskStartTimeout); | |
359 double elapsedTime = WTF::monotonicallyIncreasingTime() - startTime; | |
360 if (m_mimeType == MimeTypePng) { | |
361 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobPNGStartTime outCounter, new CustomCountHistogram("Blink.Canvas.ToBlobTimeoutDuration.PNG.Sta rt", 0, 10000000, 50)); | |
362 toBlobPNGStartTimeoutCounter.count(elapsedTime * 1000000.0); | |
363 } else if (m_mimeType == MimeTypeJpeg) { | |
364 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobJPEGStartTim eoutCounter, new CustomCountHistogram("Blink.Canvas.ToBlobTimeoutDuration.JPEG.S tart", 0, 10000000, 50)); | |
365 toBlobJPEGStartTimeoutCounter.count(elapsedTime * 1000000.0); | |
366 } else if (m_mimeType == MimeTypeWebp) { | |
367 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobWEBPStartTim eoutCounter, new CustomCountHistogram("Blink.Canvas.ToBlobTimeoutDuration.WEBP.S tart", 0, 10000000, 50)); | |
368 toBlobWEBPStartTimeoutCounter.count(elapsedTime * 1000000.0); | |
369 } else { | |
370 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobUnknownStart TimeoutCounter, new CustomCountHistogram("Blink.Canvas.ToBlobTimeoutDuration.Unk nown.Start", 0, 10000000, 50)); | |
xlai (Olivia)
2016/06/07 16:08:14
Same comment for "unknown".
xidachen
2016/06/07 20:46:28
Done.
| |
371 toBlobUnknownStartTimeoutCounter.count(elapsedTime * 1000000.0); | |
372 } | |
373 | |
310 if (m_idleTaskStatus == IdleTaskStarted) { | 374 if (m_idleTaskStatus == IdleTaskStarted) { |
311 // Even if the task started quickly, we still want to ensure completion | 375 // Even if the task started quickly, we still want to ensure completion |
312 this->postDelayedTaskToMainThread(BLINK_FROM_HERE, bind(&CanvasAsyncBlob Creator::idleTaskCompleteTimeoutEvent, this), IdleTaskCompleteTimeoutDelay); | 376 startTime = WTF::monotonicallyIncreasingTime(); |
377 this->postDelayedTaskToMainThread(BLINK_FROM_HERE, bind(&CanvasAsyncBlob Creator::idleTaskCompleteTimeoutEvent, this, startTime), IdleTaskCompleteTimeout Delay); | |
313 } else if (m_idleTaskStatus == IdleTaskNotStarted) { | 378 } else if (m_idleTaskStatus == IdleTaskNotStarted) { |
314 // If the idle task does not start after a delay threshold, we will | 379 // If the idle task does not start after a delay threshold, we will |
315 // force it to happen on main thread (even though it may cause more | 380 // force it to happen on main thread (even though it may cause more |
316 // janks) to prevent toBlob being postponed forever in extreme cases. | 381 // janks) to prevent toBlob being postponed forever in extreme cases. |
317 m_idleTaskStatus = IdleTaskSwitchedToMainThreadTask; | 382 m_idleTaskStatus = IdleTaskSwitchedToMainThreadTask; |
318 signalTaskSwitchInStartTimeoutEventForTesting(); | 383 signalTaskSwitchInStartTimeoutEventForTesting(); |
319 | 384 |
320 if (m_mimeType == MimeTypePng) { | 385 if (m_mimeType == MimeTypePng) { |
321 if (initializePngStruct()) { | 386 if (initializePngStruct()) { |
322 Platform::current()->mainThread()->getWebTaskRunner()->postTask( BLINK_FROM_HERE, bind(&CanvasAsyncBlobCreator::encodeRowsPngOnMainThread, this)) ; | 387 Platform::current()->mainThread()->getWebTaskRunner()->postTask( BLINK_FROM_HERE, bind(&CanvasAsyncBlobCreator::encodeRowsPngOnMainThread, this)) ; |
(...skipping 10 matching lines...) Expand all Loading... | |
333 this->signalAlternativeCodePathFinishedForTesting(); | 398 this->signalAlternativeCodePathFinishedForTesting(); |
334 } | 399 } |
335 } | 400 } |
336 } else { | 401 } else { |
337 ASSERT(m_idleTaskStatus == IdleTaskFailed || m_idleTaskStatus == IdleTas kCompleted); | 402 ASSERT(m_idleTaskStatus == IdleTaskFailed || m_idleTaskStatus == IdleTas kCompleted); |
338 this->signalAlternativeCodePathFinishedForTesting(); | 403 this->signalAlternativeCodePathFinishedForTesting(); |
339 } | 404 } |
340 | 405 |
341 } | 406 } |
342 | 407 |
343 void CanvasAsyncBlobCreator::idleTaskCompleteTimeoutEvent() | 408 void CanvasAsyncBlobCreator::idleTaskCompleteTimeoutEvent(double startTime) |
344 { | 409 { |
345 ASSERT(m_idleTaskStatus != IdleTaskNotStarted); | 410 ASSERT(m_idleTaskStatus != IdleTaskNotStarted); |
411 recordTimeoutEvent(IdleTaskCompleteTimeout); | |
412 double elapsedTime = WTF::monotonicallyIncreasingTime() - startTime; | |
413 if (m_mimeType == MimeTypePng) { | |
414 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobPNGCompleteT imeoutCounter, new CustomCountHistogram("Blink.Canvas.ToBlobTimeoutDuration.PNG. Complete", 0, 10000000, 50)); | |
415 toBlobPNGCompleteTimeoutCounter.count(elapsedTime * 1000000.0); | |
416 } else if (m_mimeType == MimeTypeJpeg) { | |
417 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobJPEGComplete TimeoutCounter, new CustomCountHistogram("Blink.Canvas.ToBlobTimeoutDuration.JPE G.Complete", 0, 10000000, 50)); | |
418 toBlobJPEGCompleteTimeoutCounter.count(elapsedTime * 1000000.0); | |
419 } else if (m_mimeType == MimeTypeWebp) { | |
420 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobWEBPComplete TimeoutCounter, new CustomCountHistogram("Blink.Canvas.ToBlobTimeoutDuration.WEB P.Complete", 0, 10000000, 50)); | |
421 toBlobWEBPCompleteTimeoutCounter.count(elapsedTime * 1000000.0); | |
422 } else { | |
423 DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, toBlobUnknownCompl eteTimeoutCounter, new CustomCountHistogram("Blink.Canvas.ToBlobTimeoutDuration. Unknown.Complete", 0, 10000000, 50)); | |
424 toBlobUnknownCompleteTimeoutCounter.count(elapsedTime * 1000000.0); | |
425 } | |
346 | 426 |
347 if (m_idleTaskStatus == IdleTaskStarted) { | 427 if (m_idleTaskStatus == IdleTaskStarted) { |
348 // It has taken too long to complete for the idle task. | 428 // It has taken too long to complete for the idle task. |
349 m_idleTaskStatus = IdleTaskSwitchedToMainThreadTask; | 429 m_idleTaskStatus = IdleTaskSwitchedToMainThreadTask; |
350 signalTaskSwitchInCompleteTimeoutEventForTesting(); | 430 signalTaskSwitchInCompleteTimeoutEventForTesting(); |
351 | 431 |
352 if (m_mimeType == MimeTypePng) { | 432 if (m_mimeType == MimeTypePng) { |
353 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLIN K_FROM_HERE, bind(&CanvasAsyncBlobCreator::encodeRowsPngOnMainThread, this)); | 433 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLIN K_FROM_HERE, bind(&CanvasAsyncBlobCreator::encodeRowsPngOnMainThread, this)); |
354 } else { | 434 } else { |
355 ASSERT(m_mimeType == MimeTypeJpeg); | 435 ASSERT(m_mimeType == MimeTypeJpeg); |
356 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLIN K_FROM_HERE, bind(&CanvasAsyncBlobCreator::encodeRowsJpegOnMainThread, this)); | 436 Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLIN K_FROM_HERE, bind(&CanvasAsyncBlobCreator::encodeRowsJpegOnMainThread, this)); |
357 } | 437 } |
358 } else { | 438 } else { |
359 ASSERT(m_idleTaskStatus == IdleTaskFailed || m_idleTaskStatus == IdleTas kCompleted); | 439 ASSERT(m_idleTaskStatus == IdleTaskFailed || m_idleTaskStatus == IdleTas kCompleted); |
360 this->signalAlternativeCodePathFinishedForTesting(); | 440 this->signalAlternativeCodePathFinishedForTesting(); |
361 } | 441 } |
362 } | 442 } |
363 | 443 |
364 void CanvasAsyncBlobCreator::postDelayedTaskToMainThread(const WebTraceLocation& location, std::unique_ptr<SameThreadClosure> task, double delayMs) | 444 void CanvasAsyncBlobCreator::postDelayedTaskToMainThread(const WebTraceLocation& location, std::unique_ptr<SameThreadClosure> task, double delayMs) |
365 { | 445 { |
366 DCHECK(isMainThread()); | 446 DCHECK(isMainThread()); |
367 Platform::current()->mainThread()->getWebTaskRunner()->postDelayedTask(locat ion, std::move(task), delayMs); | 447 Platform::current()->mainThread()->getWebTaskRunner()->postDelayedTask(locat ion, std::move(task), delayMs); |
368 } | 448 } |
369 | 449 |
370 } // namespace blink | 450 } // namespace blink |
OLD | NEW |