Move DOMArrayBuffer, DOMArrayBufferViews and DataView to the heap.

third_party/WebKit/Source/core/html/canvas/CanvasAsyncBlobCreator.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "CanvasAsyncBlobCreator.h"
 
 #include "core/fileapi/Blob.h"
 #include "platform/ThreadSafeFunctional.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/heap/Handle.h"
@@ skipping 16 matching lines @@
 const int NumChannelsPng = 4;
 const int LongTaskImageSizeThreshold = 1000 * 1000; // The max image size we expect to encode in 14ms on Linux in PNG format
 
 bool isDeadlineNearOrPassed(double deadlineSeconds)
 {
     return (deadlineSeconds - SlackBeforeDeadline - monotonicallyIncreasingTime() <= 0);
 }
 
 } // anonymous namespace
 
-PassRefPtr<CanvasAsyncBlobCreator> CanvasAsyncBlobCreator::create(PassRefPtr<DOMUint8ClampedArray> unpremultipliedRGBAImageData, const String& mimeType, const IntSize& size, BlobCallback* callback)
+CanvasAsyncBlobCreator* CanvasAsyncBlobCreator::create(DOMUint8ClampedArray* unpremultipliedRGBAImageData, const String& mimeType, const IntSize& size, BlobCallback* callback)
 {
-    RefPtr<CanvasAsyncBlobCreator> asyncBlobCreator = adoptRef(new CanvasAsyncBlobCreator(unpremultipliedRGBAImageData, mimeType, size, callback));
-    return asyncBlobCreator.release();
+    return new CanvasAsyncBlobCreator(unpremultipliedRGBAImageData, mimeType, size, callback);
 }
 
-CanvasAsyncBlobCreator::CanvasAsyncBlobCreator(PassRefPtr<DOMUint8ClampedArray> data, const String& mimeType, const IntSize& size, BlobCallback* callback)
+CanvasAsyncBlobCreator::CanvasAsyncBlobCreator(DOMUint8ClampedArray* data, const String& mimeType, const IntSize& size, BlobCallback* callback)
     : m_data(data)
     , m_size(size)
     , m_mimeType(mimeType)
     , m_callback(callback)
 {
     ASSERT(m_data->length() == (unsigned) (size.height() * size.width() * 4));
     m_encodedImage = adoptPtr(new Vector<unsigned char>());
     m_pixelRowStride = size.width() * NumChannelsPng;
     m_numRowsCompleted = 0;
 }
 
 CanvasAsyncBlobCreator::~CanvasAsyncBlobCreator()
 {
 }
 
 void CanvasAsyncBlobCreator::scheduleAsyncBlobCreation(bool canUseIdlePeriodScheduling, double quality)
 {
     // TODO: async blob creation should be supported in worker_pool threads as well. but right now blink does not have that
     ASSERT(isMainThread());
 
     // Make self-reference to keep this object alive until the final task completes
-    m_selfRef = this;
+    m_keepAlive = this;

[haraken, 2016/04/11 04:34:33]

Isn't the |this| object kept alive by the persistent handle implicitly created
by threadSafeBind (so we don't need the m_keepAlive)?

Either way, you don't need to address it in this CL.

[sof, 2016/04/11 05:14:21]

I believe that's correct, but
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...
gave me reasons to wonder if there's more to it. Will followup.

 
     // At the time being, progressive encoding is only applicable to png image format,
     // and thus idle tasks scheduling can only be applied to png image format.
     // TODO(xlai): Progressive encoding on jpeg and webp image formats (crbug.com/571398, crbug.com/571399)
     if (canUseIdlePeriodScheduling) {
         ASSERT(m_mimeType == "image/png");
         Platform::current()->mainThread()->scheduler()->postIdleTask(BLINK_FROM_HERE, bind<double>(&CanvasAsyncBlobCreator::initiatePngEncoding, this));
     } else if (m_mimeType == "image/jpeg") {
         Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, bind(&CanvasAsyncBlobCreator::initiateJpegEncoding, this, quality));
     } else {
         BackgroundTaskRunner::TaskSize taskSize = (m_size.height() * m_size.width() >= LongTaskImageSizeThreshold) ? BackgroundTaskRunner::TaskSizeLongRunningTask : BackgroundTaskRunner::TaskSizeShortRunningTask;
         BackgroundTaskRunner::postOnBackgroundThread(BLINK_FROM_HERE, threadSafeBind(&CanvasAsyncBlobCreator::encodeImageOnEncoderThread, AllowCrossThreadAccess(this), quality), taskSize);
     }
 }
 
 void CanvasAsyncBlobCreator::initiateJpegEncoding(const double& quality)
 {
     m_jpegEncoderState = JPEGImageEncoderState::create(m_size, quality, m_encodedImage.get());
     if (!m_jpegEncoderState) {
         Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, bind(&BlobCallback::handleEvent, m_callback, nullptr));
-        m_selfRef.clear();
+        m_keepAlive.clear();
         return;
     }
     BackgroundTaskRunner::TaskSize taskSize = (m_size.height() * m_size.width() >= LongTaskImageSizeThreshold) ? BackgroundTaskRunner::TaskSizeLongRunningTask : BackgroundTaskRunner::TaskSizeShortRunningTask;
     BackgroundTaskRunner::postOnBackgroundThread(BLINK_FROM_HERE, threadSafeBind(&CanvasAsyncBlobCreator::encodeImageOnEncoderThread, AllowCrossThreadAccess(this), quality), taskSize);
 }
 
 void CanvasAsyncBlobCreator::initiatePngEncoding(double deadlineSeconds)
 {
     ASSERT(isMainThread());
     m_pngEncoderState = PNGImageEncoderState::create(m_size, m_encodedImage.get());
     if (!m_pngEncoderState) {
         Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, bind(&BlobCallback::handleEvent, m_callback, nullptr));
-        m_selfRef.clear();
+        m_keepAlive.clear();
         return;
     }
 
     CanvasAsyncBlobCreator::idleEncodeRowsPng(deadlineSeconds);
 }
 
 void CanvasAsyncBlobCreator::scheduleIdleEncodeRowsPng()
 {
     ASSERT(isMainThread());
     Platform::current()->currentThread()->scheduler()->postIdleTask(BLINK_FROM_HERE, WTF::bind<double>(&CanvasAsyncBlobCreator::idleEncodeRowsPng, this));
@@ skipping 47 matching lines @@
     }
 
     scheduleCreateBlobAndCallOnMainThread();
 }
 
 void CanvasAsyncBlobCreator::clearSelfReference()
 {
     // Some persistent members in CanvasAsyncBlobCreator can only be destroyed
     // on the thread that creates them. In this case, it's the main thread.
     ASSERT(isMainThread());
-    m_selfRef.clear();
+    m_keepAlive.clear();
 }
 
 void CanvasAsyncBlobCreator::scheduleCreateBlobAndCallOnMainThread()
 {
     ASSERT(!isMainThread());
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&CanvasAsyncBlobCreator::createBlobAndCall, AllowCrossThreadAccess(this)));
 }
 
 void CanvasAsyncBlobCreator::scheduleCreateNullptrAndCallOnMainThread()
 {
     ASSERT(!isMainThread());
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&BlobCallback::handleEvent, m_callback.get(), nullptr));
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&CanvasAsyncBlobCreator::clearSelfReference, AllowCrossThreadAccess(this)));
 }
 
 } // namespace blink