Remove SK_SUPPORT_LEGACY_DATA_FACTORIES.

third_party/WebKit/Source/platform/image-decoders/SegmentReader.cpp

 // Copyright 2016 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 "platform/image-decoders/SegmentReader.h"
 
 #include "platform/SharedBuffer.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "wtf/Assertions.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/ThreadingPrimitives.h"
 
 namespace blink {
 
 // SharedBufferSegmentReader ---------------------------------------------------
 
 // Interface for ImageDecoder to read a SharedBuffer.
 class SharedBufferSegmentReader final : public SegmentReader {
     WTF_MAKE_NONCOPYABLE(SharedBufferSegmentReader);
 public:
     SharedBufferSegmentReader(PassRefPtr<SharedBuffer>);
     size_t size() const override;
     size_t getSomeData(const char*& data, size_t position) const override;
-    PassRefPtr<SkData> getAsSkData() const override;
+    sk_sp<SkData> getAsSkData() const override;
 private:
     RefPtr<SharedBuffer> m_sharedBuffer;
 };
 
 SharedBufferSegmentReader::SharedBufferSegmentReader(PassRefPtr<SharedBuffer> buffer)
     : m_sharedBuffer(buffer) {}
 
 size_t SharedBufferSegmentReader::size() const
 {
     return m_sharedBuffer->size();
 }
 
 size_t SharedBufferSegmentReader::getSomeData(const char*& data, size_t position) const
 {
     return m_sharedBuffer->getSomeData(data, position);
 }
 
-PassRefPtr<SkData> SharedBufferSegmentReader::getAsSkData() const
+sk_sp<SkData> SharedBufferSegmentReader::getAsSkData() const
 {
     return m_sharedBuffer->getAsSkData();
 }
 
 // DataSegmentReader -----------------------------------------------------------
 
 // Interface for ImageDecoder to read an SkData.
 class DataSegmentReader final : public SegmentReader {
     WTF_MAKE_NONCOPYABLE(DataSegmentReader);
 public:
-    DataSegmentReader(PassRefPtr<SkData>);
+    DataSegmentReader(sk_sp<SkData>);
     size_t size() const override;
     size_t getSomeData(const char*& data, size_t position) const override;
-    PassRefPtr<SkData> getAsSkData() const override;
+    sk_sp<SkData> getAsSkData() const override;
 private:
-    RefPtr<SkData> m_data;
+    sk_sp<SkData> m_data;
 };
 
-DataSegmentReader::DataSegmentReader(PassRefPtr<SkData> data)
-    : m_data(data) {}
+DataSegmentReader::DataSegmentReader(sk_sp<SkData> data)
+    : m_data(std::move(data)) {}
 
 size_t DataSegmentReader::size() const
 {
     return m_data->size();
 }
 
 size_t DataSegmentReader::getSomeData(const char*& data, size_t position) const
 {
     if (position >= m_data->size())
         return 0;
 
     data = reinterpret_cast<const char*>(m_data->bytes() + position);
     return m_data->size() - position;
 }
 
-PassRefPtr<SkData> DataSegmentReader::getAsSkData() const
+sk_sp<SkData> DataSegmentReader::getAsSkData() const
 {
-    return m_data.get();
+    return m_data;
 }
 
 // ROBufferSegmentReader -------------------------------------------------------
 
 class ROBufferSegmentReader final : public SegmentReader {
     WTF_MAKE_NONCOPYABLE(ROBufferSegmentReader);
 public:
     ROBufferSegmentReader(PassRefPtr<SkROBuffer>);
 
     size_t size() const override;
     size_t getSomeData(const char*& data, size_t position) const override;
-    PassRefPtr<SkData> getAsSkData() const override;
+    sk_sp<SkData> getAsSkData() const override;
 
 private:
     RefPtr<SkROBuffer> m_roBuffer;
     // Protects access to mutable fields.
     mutable Mutex m_readMutex;
     // Position of the first char in the current block of m_iter.
     mutable size_t m_positionOfBlock;
     mutable SkROBuffer::Iter m_iter;
 };
 
@@ skipping 41 matching lines @@
     }
 
     return 0;
 }
 
 static void unrefROBuffer(const void* ptr, void* context)
 {
     static_cast<SkROBuffer*>(context)->unref();
 }
 
-PassRefPtr<SkData> ROBufferSegmentReader::getAsSkData() const
+sk_sp<SkData> ROBufferSegmentReader::getAsSkData() const
 {
     if (!m_roBuffer)
         return nullptr;
 
     // Check to see if the data is already contiguous.
     SkROBuffer::Iter iter(m_roBuffer.get());
     const bool multipleBlocks = iter.next();
     iter.reset(m_roBuffer.get());
 
     if (!multipleBlocks) {
         // Contiguous data. No need to copy.
         m_roBuffer->ref();
-        return adoptRef(SkData::NewWithProc(iter.data(), iter.size(), &unrefROBuffer, m_roBuffer.get()));
+        return SkData::MakeWithProc(iter.data(), iter.size(), &unrefROBuffer, m_roBuffer.get());
     }
 
-    RefPtr<SkData> data = adoptRef(SkData::NewUninitialized(m_roBuffer->size()));
+    sk_sp<SkData> data = SkData::MakeUninitialized(m_roBuffer->size());
     char* dst = static_cast<char*>(data->writable_data());
     do {
         size_t size = iter.size();
         memcpy(dst, iter.data(), size);
         dst += size;
     } while (iter.next());
-    return data.release();
+    return data;
 }
 
 // SegmentReader ---------------------------------------------------------------
 
 PassRefPtr<SegmentReader> SegmentReader::createFromSharedBuffer(PassRefPtr<SharedBuffer> buffer)
 {
     return adoptRef(new SharedBufferSegmentReader(buffer));
 }
 
-PassRefPtr<SegmentReader> SegmentReader::createFromSkData(PassRefPtr<SkData> data)
+PassRefPtr<SegmentReader> SegmentReader::createFromSkData(sk_sp<SkData> data)
 {
-    return adoptRef(new DataSegmentReader(data));
+    return adoptRef(new DataSegmentReader(std::move(data)));
 }
 
 PassRefPtr<SegmentReader> SegmentReader::createFromSkROBuffer(PassRefPtr<SkROBuffer> buffer)
 {
     return adoptRef(new ROBufferSegmentReader(buffer));
 }
 
 } // namespace blink