Return unique_ptr<WebDataConsumerHandle::Reader> directly from obtainReader

third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h

 // 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.
 
 #ifndef DataConsumerHandleTestUtil_h
 #define DataConsumerHandleTestUtil_h
 
 #include "bindings/core/v8/ScriptState.h"
 #include "core/testing/NullExecutionContext.h"
 #include "gin/public/isolate_holder.h"
@@ skipping 189 matching lines @@
             USING_FAST_MALLOC(DataConsumerHandle);
         public:
             static std::unique_ptr<WebDataConsumerHandle> create(const String& name, PassRefPtr<Context> context)
             {
                 return wrapUnique(new DataConsumerHandle(name, context));
             }
 
         private:
             DataConsumerHandle(const String& name, PassRefPtr<Context> context) : m_name(name.isolatedCopy()), m_context(context) { }
 
-            Reader* obtainReaderInternal(Client*) { return new ReaderImpl(m_name, m_context); }
+            std::unique_ptr<Reader> obtainReader(Client*) { return WTF::wrapUnique(new ReaderImpl(m_name, m_context)); }
             const char* debugName() const override { return "ThreadingTestBase::DataConsumerHandle"; }
 
             const String m_name;
             RefPtr<Context> m_context;
         };
 
         void resetReader() { m_reader = nullptr; }
         void signalDone() { m_waitableEvent->signal(); }
         const String& result() { return m_context->result(); }
         void postTaskToReadingThread(const WebTraceLocation& location, std::unique_ptr<CrossThreadClosure> task)
@@ skipping 79 matching lines @@
         {
             ASSERT_NOT_REACHED();
         }
 
         std::unique_ptr<WebDataConsumerHandle> m_handle;
     };
 
     class MockFetchDataConsumerHandle : public FetchDataConsumerHandle {
     public:
         static std::unique_ptr<::testing::StrictMock<MockFetchDataConsumerHandle>> create() { return wrapUnique(new ::testing::StrictMock<MockFetchDataConsumerHandle>); }
-        MOCK_METHOD1(obtainReaderInternal, Reader*(Client*));
+        MOCK_METHOD1(obtainFetchDataReader, std::unique_ptr<Reader>(Client*));
 
     private:
         const char* debugName() const override { return "MockFetchDataConsumerHandle"; }
     };
 
     class MockFetchDataConsumerReader : public FetchDataConsumerHandle::Reader {
     public:
         static std::unique_ptr<::testing::StrictMock<MockFetchDataConsumerReader>> create() { return wrapUnique(new ::testing::StrictMock<MockFetchDataConsumerReader>); }
 
         using Result = WebDataConsumerHandle::Result;
@@ skipping 100 matching lines @@
             size_t m_offset;
             WebThread* m_readerThread;
             Client* m_client;
             Result m_result;
             bool m_isHandleAttached;
             Mutex m_mutex;
             std::unique_ptr<WaitableEvent> m_detached;
         };
 
         Context* getContext() { return m_context.get(); }
+        std::unique_ptr<Reader> obtainReader(Client*) override;
 
     private:
         class ReaderImpl;
 
         ReplayingHandle();
-        Reader* obtainReaderInternal(Client*) override;
         const char* debugName() const override { return "ReplayingHandle"; }
 
         RefPtr<Context> m_context;
     };
 
     class HandleReadResult final {
         USING_FAST_MALLOC(HandleReadResult);
     public:
         HandleReadResult(WebDataConsumerHandle::Result result, const Vector<char>& data) : m_result(result), m_data(data) { }
         WebDataConsumerHandle::Result result() const { return m_result; }
@@ skipping 86 matching lines @@
         std::unique_ptr<HandleReadResult> m_result;
         bool m_isDone;
 
         std::unique_ptr<T> m_handleReader;
     };
 };
 
 } // namespace blink
 
 #endif // DataConsumerHandleTestUtil_h