Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/platform/graphics/PictureSnapshot.cpp

 /*
  * Copyright (C) 2013 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 28 matching lines @@
 #include "platform/image-decoders/ImageDecoder.h"
 #include "platform/image-decoders/ImageFrame.h"
 #include "platform/image-decoders/SegmentReader.h"
 #include "platform/image-encoders/PNGImageEncoder.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/HexNumber.h"
-#include "wtf/PtrUtil.h"
 #include "wtf/text/Base64.h"
 #include "wtf/text/TextEncoding.h"
-#include <memory>
 
 namespace blink {
 
 PictureSnapshot::PictureSnapshot(PassRefPtr<const SkPicture> picture)
     : m_picture(picture)
 {
 }
 
 static bool decodeBitmap(const void* data, size_t length, SkBitmap* result)
 {
-    std::unique_ptr<ImageDecoder> imageDecoder = ImageDecoder::create(static_cast<const char*>(data), length,
+    OwnPtr<ImageDecoder> imageDecoder = ImageDecoder::create(static_cast<const char*>(data), length,
         ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileIgnored);
     if (!imageDecoder)
         return false;
 
     // No need to copy the data; this decodes immediately.
     RefPtr<SegmentReader> segmentReader = SegmentReader::createFromSkData(adoptRef(SkData::NewWithoutCopy(data, length)));
     imageDecoder->setData(segmentReader.release(), true);
     ImageFrame* frame = imageDecoder->frameBufferAtIndex(0);
     if (!frame)
         return true;
@@ skipping 28 matching lines @@
         canvas->restore();
     }
     return adoptRef(new PictureSnapshot(fromSkSp(recorder.finishRecordingAsPicture())));
 }
 
 bool PictureSnapshot::isEmpty() const
 {
     return m_picture->cullRect().isEmpty();
 }
 
-std::unique_ptr<Vector<char>> PictureSnapshot::replay(unsigned fromStep, unsigned toStep, double scale) const
+PassOwnPtr<Vector<char>> PictureSnapshot::replay(unsigned fromStep, unsigned toStep, double scale) const
 {
     const SkIRect bounds = m_picture->cullRect().roundOut();
 
     // TODO(fmalita): convert this to SkSurface/SkImage, drop the intermediate SkBitmap.
     SkBitmap bitmap;
     bitmap.allocPixels(SkImageInfo::MakeN32Premul(bounds.width(), bounds.height()));
     bitmap.eraseARGB(0, 0, 0, 0);
     {
         ReplayingCanvas canvas(bitmap, fromStep, toStep);
         // Disable LCD text preemptively, because the picture opacity is unknown.
         // The canonical API involves SkSurface props, but since we're not SkSurface-based
         // at this point (see TODO above) we (ab)use saveLayer for this purpose.
         SkAutoCanvasRestore autoRestore(&canvas, false);
         canvas.saveLayer(nullptr, nullptr);
 
         canvas.scale(scale, scale);
         canvas.resetStepCount();
         m_picture->playback(&canvas, &canvas);
     }
-    std::unique_ptr<Vector<char>> base64Data = wrapUnique(new Vector<char>());
+    OwnPtr<Vector<char>> base64Data = adoptPtr(new Vector<char>());
     Vector<char> encodedImage;
 
     RefPtr<SkImage> image = fromSkSp(SkImage::MakeFromBitmap(bitmap));
     if (!image)
         return nullptr;
 
     ImagePixelLocker pixelLocker(image, kUnpremul_SkAlphaType, kRGBA_8888_SkColorType);
     ImageDataBuffer imageData(IntSize(image->width(), image->height()),
         static_cast<const unsigned char*>(pixelLocker.pixels()));
     if (!PNGImageEncoder::encode(imageData, reinterpret_cast<Vector<unsigned char>*>(&encodedImage)))
         return nullptr;
 
     base64Encode(encodedImage, *base64Data);
     return base64Data;
 }
 
-std::unique_ptr<PictureSnapshot::Timings> PictureSnapshot::profile(unsigned minRepeatCount, double minDuration, const FloatRect* clipRect) const
+PassOwnPtr<PictureSnapshot::Timings> PictureSnapshot::profile(unsigned minRepeatCount, double minDuration, const FloatRect* clipRect) const
 {
-    std::unique_ptr<PictureSnapshot::Timings> timings = wrapUnique(new PictureSnapshot::Timings());
+    OwnPtr<PictureSnapshot::Timings> timings = adoptPtr(new PictureSnapshot::Timings());
     timings->reserveCapacity(minRepeatCount);
     const SkIRect bounds = m_picture->cullRect().roundOut();
     SkBitmap bitmap;
     bitmap.allocPixels(SkImageInfo::MakeN32Premul(bounds.width(), bounds.height()));
     bitmap.eraseARGB(0, 0, 0, 0);
 
     double now = WTF::monotonicallyIncreasingTime();
     double stopTime = now + minDuration;
     for (unsigned step = 0; step < minRepeatCount || now < stopTime; ++step) {
         timings->append(Vector<double>());
@@ skipping 14 matching lines @@
 
 PassRefPtr<JSONArray> PictureSnapshot::snapshotCommandLog() const
 {
     const SkIRect bounds = m_picture->cullRect().roundOut();
     LoggingCanvas canvas(bounds.width(), bounds.height());
     m_picture->playback(&canvas);
     return canvas.log();
 }
 
 } // namespace blink