Remove OwnPtr from Blink.

third_party/WebKit/Source/platform/testing/ImageDecodeBench.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.
 
 // Provides a minimal wrapping of the Blink image decoders. Used to perform
 // a non-threaded, memory-to-memory image decode using micro second accuracy
 // clocks to measure image decode time. Optionally applies color correction
 // during image decoding on supported platforms (default off). Usage:
 //
 //   % ninja -C out/Release image_decode_bench &&
 //      ./out/Release/image_decode_bench file [iterations]
 //
 // TODO(noel): Consider adding md5 checksum support to WTF. Use it to compute
 // the decoded image frame md5 and output that value.
 //
 // TODO(noel): Consider integrating this tool in Chrome telemetry for realz,
 // using the image corpii used to assess Blink image decode performance. Refer
 // to http://crbug.com/398235#c103 and http://crbug.com/258324#c5
 
 #include "base/command_line.h"
 #include "platform/SharedBuffer.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "public/platform/Platform.h"
-#include "wtf/OwnPtr.h"
 #include "wtf/PassRefPtr.h"
+#include "wtf/PtrUtil.h"
+#include <memory>
 
 #if defined(_WIN32)
 #include <mmsystem.h>
 #include <sys/stat.h>
 #include <time.h>
 #define stat(x,y) _stat(x,y)
 typedef struct _stat sttype;
 #else
 #include <sys/stat.h>
 #include <sys/time.h>
@@ skipping 203 matching lines @@
         fprintf(stderr, "Can't open file %s\n", fileName);
         exit(2);
     }
 
     sttype s;
     stat(fileName, &s);
     size_t fileSize = s.st_size;
     if (s.st_size <= 0)
         return SharedBuffer::create();
 
-    OwnPtr<unsigned char[]> buffer = adoptArrayPtr(new unsigned char[fileSize]);
+    std::unique_ptr<unsigned char[]> buffer = wrapArrayUnique(new unsigned char[fileSize]);
     if (fileSize != fread(buffer.get(), 1, fileSize, fp)) {
         fprintf(stderr, "Error reading file %s\n", fileName);
         exit(2);
     }
 
     fclose(fp);
     return SharedBuffer::create(buffer.get(), fileSize);
 }
 
 bool decodeImageData(SharedBuffer* data, bool colorCorrection, size_t packetSize)
 {
-    OwnPtr<ImageDecoder> decoder = ImageDecoder::create(*data,
+    std::unique_ptr<ImageDecoder> decoder = ImageDecoder::create(*data,
         ImageDecoder::AlphaPremultiplied, colorCorrection ?
             ImageDecoder::GammaAndColorProfileApplied : ImageDecoder::GammaAndColorProfileIgnored);
 
     if (!packetSize) {
         bool allDataReceived = true;
         decoder->setData(data, allDataReceived);
 
         int frameCount = decoder->frameCount();
         for (int i = 0; i < frameCount; ++i) {
             if (!decoder->frameBufferAtIndex(i))
@@ skipping 121 matching lines @@
             exit(3);
         }
     }
 
     // Results to stdout.
 
     double averageTime = totalTime / static_cast<double>(iterations);
     printf("%f %f\n", totalTime, averageTime);
     return 0;
 }