Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/platform/image-encoders/JPEGImageEncoder.cpp

 /*
  * Copyright (c) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/image-encoders/JPEGImageEncoder.h"
 
 #include "SkColorPriv.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "wtf/CurrentTime.h"
-#include "wtf/PtrUtil.h"
-#include <memory>
 
 extern "C" {
 #include <setjmp.h>
 #include <stdio.h> // jpeglib.h needs stdio.h FILE
 #include "jpeglib.h"
 }
 
 namespace blink {
 
 struct JPEGOutputBuffer : public jpeg_destination_mgr {
@@ skipping 80 matching lines @@
     }
 }
 
 #define SET_JUMP_BUFFER(jpeg_compress_struct_ptr, what_to_return) \
     jmp_buf jumpBuffer;                                           \
     jpeg_compress_struct_ptr->client_data = &jumpBuffer;          \
     if (setjmp(jumpBuffer)) {                                     \
         return what_to_return;                                    \
     }
 
-std::unique_ptr<JPEGImageEncoderState> JPEGImageEncoderState::create(const IntSize& imageSize, const double& quality, Vector<unsigned char>* output)
+PassOwnPtr<JPEGImageEncoderState> JPEGImageEncoderState::create(const IntSize& imageSize, const double& quality, Vector<unsigned char>* output)
 {
     if (imageSize.width() <= 0 || imageSize.height() <= 0)
         return nullptr;
 
-    std::unique_ptr<JPEGImageEncoderStateImpl> encoderState = wrapUnique(new JPEGImageEncoderStateImpl());
+    OwnPtr<JPEGImageEncoderStateImpl> encoderState = adoptPtr(new JPEGImageEncoderStateImpl());
 
     jpeg_compress_struct* cinfo = encoderState->cinfo();
     jpeg_error_mgr* error = encoderState->error();
     cinfo->err = jpeg_std_error(error);
     error->error_exit = handleError;
 
     SET_JUMP_BUFFER(cinfo, nullptr);
 
     JPEGOutputBuffer* destination = encoderState->outputBuffer();
     destination->output = output;
@@ skipping 45 matching lines @@
 
         if (deadlineSeconds - SlackBeforeDeadline - monotonicallyIncreasingTime() <= 0) {
             return currentRowsCompleted;
         }
     }
 
     jpeg_finish_compress(encoderStateImpl->cinfo());
     return currentRowsCompleted;
 }
 
-bool JPEGImageEncoder::encodeWithPreInitializedState(std::unique_ptr<JPEGImageEncoderState> encoderState, const unsigned char* inputPixels, int numRowsCompleted)
+bool JPEGImageEncoder::encodeWithPreInitializedState(PassOwnPtr<JPEGImageEncoderState> encoderState, const unsigned char* inputPixels, int numRowsCompleted)
 {
     JPEGImageEncoderStateImpl* encoderStateImpl = static_cast<JPEGImageEncoderStateImpl*>(encoderState.get());
 
     Vector<JSAMPLE> row;
     row.resize(encoderStateImpl->cinfo()->image_width * encoderStateImpl->cinfo()->input_components);
 
     SET_JUMP_BUFFER(encoderStateImpl->cinfo(), false);
 
     const size_t pixelRowStride = encoderStateImpl->cinfo()->image_width * 4;
     unsigned char* pixels = const_cast<unsigned char*>(inputPixels) + pixelRowStride * numRowsCompleted;
     while (encoderStateImpl->cinfo()->next_scanline < encoderStateImpl->cinfo()->image_height) {
         JSAMPLE* rowData = row.data();
         RGBAtoRGB(pixels, encoderStateImpl->cinfo()->image_width, rowData);
         jpeg_write_scanlines(encoderStateImpl->cinfo(), &rowData, 1);
         pixels += pixelRowStride;
     }
 
     jpeg_finish_compress(encoderStateImpl->cinfo());
     return true;
 }
 
 bool JPEGImageEncoder::encode(const ImageDataBuffer& imageData, const double& quality, Vector<unsigned char>* output)
 {
     if (!imageData.pixels())
         return false;
 
-    std::unique_ptr<JPEGImageEncoderState> encoderState = JPEGImageEncoderState::create(imageData.size(), quality, output);
+    OwnPtr<JPEGImageEncoderState> encoderState = JPEGImageEncoderState::create(imageData.size(), quality, output);
     if (!encoderState)
         return false;
 
     return JPEGImageEncoder::encodeWithPreInitializedState(std::move(encoderState), imageData.pixels());
 }
 
 } // namespace blink