Remove OwnPtr from Blink.

third_party/WebKit/Source/core/fileapi/FileReaderLoader.h

 /*
  * 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 18 matching lines @@
  */
 
 #ifndef FileReaderLoader_h
 #define FileReaderLoader_h
 
 #include "core/CoreExport.h"
 #include "core/fileapi/FileError.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "platform/weborigin/KURL.h"
 #include "wtf/Forward.h"
-#include "wtf/OwnPtr.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/text/TextEncoding.h"
 #include "wtf/text/WTFString.h"
 #include "wtf/typed_arrays/ArrayBufferBuilder.h"
+#include <memory>
 
 namespace blink {
 
 class BlobDataHandle;
 class DOMArrayBuffer;
 class ExecutionContext;
 class FileReaderLoaderClient;
 class Stream;
 class TextResourceDecoder;
 class ThreadableLoader;
 
 class CORE_EXPORT FileReaderLoader final : public ThreadableLoaderClient {
     USING_FAST_MALLOC(FileReaderLoader);
 public:
     enum ReadType {
         ReadAsArrayBuffer,
         ReadAsBinaryString,
         ReadAsText,
         ReadAsDataURL,
         ReadByClient
     };
 
     // If client is given, do the loading asynchronously. Otherwise, load synchronously.
-    static PassOwnPtr<FileReaderLoader> create(ReadType readType, FileReaderLoaderClient* client)
+    static std::unique_ptr<FileReaderLoader> create(ReadType readType, FileReaderLoaderClient* client)
     {
-        return adoptPtr(new FileReaderLoader(readType, client));
+        return wrapUnique(new FileReaderLoader(readType, client));
     }
 
     FileReaderLoader(ReadType, FileReaderLoaderClient*);
     ~FileReaderLoader() override;
 
     void start(ExecutionContext*, PassRefPtr<BlobDataHandle>);
     void start(ExecutionContext*, const Stream&, unsigned readSize);
     void cancel();
 
     // ThreadableLoaderClient
-    void didReceiveResponse(unsigned long, const ResourceResponse&, PassOwnPtr<WebDataConsumerHandle>) override;
+    void didReceiveResponse(unsigned long, const ResourceResponse&, std::unique_ptr<WebDataConsumerHandle>) override;
     void didReceiveData(const char*, unsigned) override;
     void didFinishLoading(unsigned long, double) override;
     void didFail(const ResourceError&) override;
 
     String stringResult();
     DOMArrayBuffer* arrayBufferResult() const;
 
     // Returns the total bytes received. Bytes ignored by m_rawData won't be
     // counted.
     //
@@ skipping 25 matching lines @@
 
     static FileError::ErrorCode httpStatusCodeToErrorCode(int);
 
     ReadType m_readType;
     FileReaderLoaderClient* m_client;
     WTF::TextEncoding m_encoding;
     String m_dataType;
 
     KURL m_urlForReading;
     bool m_urlForReadingIsStream;
-    OwnPtr<ThreadableLoader> m_loader;
+    std::unique_ptr<ThreadableLoader> m_loader;
 
-    OwnPtr<ArrayBufferBuilder> m_rawData;
+    std::unique_ptr<ArrayBufferBuilder> m_rawData;
     bool m_isRawDataConverted;
 
     String m_stringResult;
 
     // The decoder used to decode the text data.
-    OwnPtr<TextResourceDecoder> m_decoder;
+    std::unique_ptr<TextResourceDecoder> m_decoder;
 
     bool m_finishedLoading;
     long long m_bytesLoaded;
     // If the total size of the resource is unknown, m_totalBytes is set to -1
     // until completion of loading, and the buffer for receiving data is set to
     // dynamically grow. Otherwise, m_totalBytes is set to the total size and
     // the buffer for receiving data of m_totalBytes is allocated and never grow
     // even when extra data is appeneded.
     long long m_totalBytes;
 
     bool m_hasRange;
     unsigned m_rangeStart;
     unsigned m_rangeEnd;
 
     FileError::ErrorCode m_errorCode;
 };
 
 } // namespace blink
 
 #endif // FileReaderLoader_h