Index: third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h |
diff --git a/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h b/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h |
index 47cb1c700ea6b5174ed06d8e81166d1d89b7d48d..e629a0312679007a23d889b0ae11cc137f54c1eb 100644 |
--- a/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h |
+++ b/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h |
@@ -20,13 +20,14 @@ |
#include "public/platform/WebTraceLocation.h" |
#include "wtf/Deque.h" |
#include "wtf/Locker.h" |
-#include "wtf/PtrUtil.h" |
+#include "wtf/OwnPtr.h" |
+#include "wtf/PassOwnPtr.h" |
#include "wtf/ThreadSafeRefCounted.h" |
#include "wtf/ThreadingPrimitives.h" |
#include "wtf/Vector.h" |
+ |
#include <gmock/gmock.h> |
#include <gtest/gtest.h> |
-#include <memory> |
#include <v8.h> |
namespace blink { |
@@ -68,11 +69,11 @@ public: |
void initialize(); |
void shutdown(); |
- std::unique_ptr<WebThreadSupportingGC> m_thread; |
+ OwnPtr<WebThreadSupportingGC> m_thread; |
const InitializationPolicy m_initializationPolicy; |
- std::unique_ptr<WaitableEvent> m_waitableEvent; |
+ OwnPtr<WaitableEvent> m_waitableEvent; |
Persistent<NullExecutionContext> m_executionContext; |
- std::unique_ptr<gin::IsolateHolder> m_isolateHolder; |
+ OwnPtr<gin::IsolateHolder> m_isolateHolder; |
RefPtr<ScriptState> m_scriptState; |
}; |
@@ -159,8 +160,8 @@ public: |
public: |
ThreadHolder(ThreadingTestBase* test) |
: m_context(test->m_context) |
- , m_readingThread(wrapUnique(new Thread("reading thread"))) |
- , m_updatingThread(wrapUnique(new Thread("updating thread"))) |
+ , m_readingThread(adoptPtr(new Thread("reading thread"))) |
+ , m_updatingThread(adoptPtr(new Thread("updating thread"))) |
{ |
m_context->registerThreadHolder(this); |
} |
@@ -174,8 +175,8 @@ public: |
private: |
RefPtr<Context> m_context; |
- std::unique_ptr<Thread> m_readingThread; |
- std::unique_ptr<Thread> m_updatingThread; |
+ OwnPtr<Thread> m_readingThread; |
+ OwnPtr<Thread> m_updatingThread; |
}; |
class ReaderImpl final : public WebDataConsumerHandle::Reader { |
@@ -199,9 +200,9 @@ public: |
class DataConsumerHandle final : public WebDataConsumerHandle { |
USING_FAST_MALLOC(DataConsumerHandle); |
public: |
- static std::unique_ptr<WebDataConsumerHandle> create(const String& name, PassRefPtr<Context> context) |
+ static PassOwnPtr<WebDataConsumerHandle> create(const String& name, PassRefPtr<Context> context) |
{ |
- return wrapUnique(new DataConsumerHandle(name, context)); |
+ return adoptPtr(new DataConsumerHandle(name, context)); |
} |
private: |
@@ -240,8 +241,8 @@ public: |
: m_context(Context::create()) { } |
RefPtr<Context> m_context; |
- std::unique_ptr<WebDataConsumerHandle::Reader> m_reader; |
- std::unique_ptr<WaitableEvent> m_waitableEvent; |
+ OwnPtr<WebDataConsumerHandle::Reader> m_reader; |
+ OwnPtr<WaitableEvent> m_waitableEvent; |
NoopClient m_client; |
}; |
@@ -250,10 +251,10 @@ public: |
using Self = ThreadingHandleNotificationTest; |
static PassRefPtr<Self> create() { return adoptRef(new Self); } |
- void run(std::unique_ptr<WebDataConsumerHandle> handle) |
+ void run(PassOwnPtr<WebDataConsumerHandle> handle) |
{ |
ThreadHolder holder(this); |
- m_waitableEvent = wrapUnique(new WaitableEvent()); |
+ m_waitableEvent = adoptPtr(new WaitableEvent()); |
m_handle = std::move(handle); |
postTaskToReadingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::obtainReader, this)); |
@@ -271,7 +272,7 @@ public: |
postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::signalDone, this)); |
} |
- std::unique_ptr<WebDataConsumerHandle> m_handle; |
+ OwnPtr<WebDataConsumerHandle> m_handle; |
}; |
class ThreadingHandleNoNotificationTest : public ThreadingTestBase, public WebDataConsumerHandle::Client { |
@@ -279,10 +280,10 @@ public: |
using Self = ThreadingHandleNoNotificationTest; |
static PassRefPtr<Self> create() { return adoptRef(new Self); } |
- void run(std::unique_ptr<WebDataConsumerHandle> handle) |
+ void run(PassOwnPtr<WebDataConsumerHandle> handle) |
{ |
ThreadHolder holder(this); |
- m_waitableEvent = wrapUnique(new WaitableEvent()); |
+ m_waitableEvent = adoptPtr(new WaitableEvent()); |
m_handle = std::move(handle); |
postTaskToReadingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::obtainReader, this)); |
@@ -301,12 +302,12 @@ public: |
ASSERT_NOT_REACHED(); |
} |
- std::unique_ptr<WebDataConsumerHandle> m_handle; |
+ OwnPtr<WebDataConsumerHandle> m_handle; |
}; |
class MockFetchDataConsumerHandle : public FetchDataConsumerHandle { |
public: |
- static std::unique_ptr<::testing::StrictMock<MockFetchDataConsumerHandle>> create() { return wrapUnique(new ::testing::StrictMock<MockFetchDataConsumerHandle>); } |
+ static PassOwnPtr<::testing::StrictMock<MockFetchDataConsumerHandle>> create() { return adoptPtr(new ::testing::StrictMock<MockFetchDataConsumerHandle>); } |
MOCK_METHOD1(obtainReaderInternal, Reader*(Client*)); |
private: |
@@ -315,7 +316,7 @@ public: |
class MockFetchDataConsumerReader : public FetchDataConsumerHandle::Reader { |
public: |
- static std::unique_ptr<::testing::StrictMock<MockFetchDataConsumerReader>> create() { return wrapUnique(new ::testing::StrictMock<MockFetchDataConsumerReader>); } |
+ static PassOwnPtr<::testing::StrictMock<MockFetchDataConsumerReader>> create() { return adoptPtr(new ::testing::StrictMock<MockFetchDataConsumerReader>); } |
using Result = WebDataConsumerHandle::Result; |
using Flags = WebDataConsumerHandle::Flags; |
@@ -387,7 +388,7 @@ public: |
class ReplayingHandle final : public WebDataConsumerHandle { |
USING_FAST_MALLOC(ReplayingHandle); |
public: |
- static std::unique_ptr<ReplayingHandle> create() { return wrapUnique(new ReplayingHandle()); } |
+ static PassOwnPtr<ReplayingHandle> create() { return adoptPtr(new ReplayingHandle()); } |
~ReplayingHandle(); |
// Add a command to this handle. This function must be called on the |
@@ -424,7 +425,7 @@ public: |
Result m_result; |
bool m_isHandleAttached; |
Mutex m_mutex; |
- std::unique_ptr<WaitableEvent> m_detached; |
+ OwnPtr<WaitableEvent> m_detached; |
}; |
Context* getContext() { return m_context.get(); } |
@@ -457,15 +458,15 @@ public: |
class HandleReader final : public WebDataConsumerHandle::Client { |
USING_FAST_MALLOC(HandleReader); |
public: |
- using OnFinishedReading = WTF::Function<void(std::unique_ptr<HandleReadResult>)>; |
+ using OnFinishedReading = WTF::Function<void(PassOwnPtr<HandleReadResult>)>; |
- HandleReader(std::unique_ptr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>); |
+ HandleReader(PassOwnPtr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>); |
void didGetReadable() override; |
private: |
- void runOnFinishedReading(std::unique_ptr<HandleReadResult>); |
+ void runOnFinishedReading(PassOwnPtr<HandleReadResult>); |
- std::unique_ptr<WebDataConsumerHandle::Reader> m_reader; |
+ OwnPtr<WebDataConsumerHandle::Reader> m_reader; |
std::unique_ptr<OnFinishedReading> m_onFinishedReading; |
Vector<char> m_data; |
}; |
@@ -475,15 +476,15 @@ public: |
class HandleTwoPhaseReader final : public WebDataConsumerHandle::Client { |
USING_FAST_MALLOC(HandleTwoPhaseReader); |
public: |
- using OnFinishedReading = WTF::Function<void(std::unique_ptr<HandleReadResult>)>; |
+ using OnFinishedReading = WTF::Function<void(PassOwnPtr<HandleReadResult>)>; |
- HandleTwoPhaseReader(std::unique_ptr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>); |
+ HandleTwoPhaseReader(PassOwnPtr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>); |
void didGetReadable() override; |
private: |
- void runOnFinishedReading(std::unique_ptr<HandleReadResult>); |
+ void runOnFinishedReading(PassOwnPtr<HandleReadResult>); |
- std::unique_ptr<WebDataConsumerHandle::Reader> m_reader; |
+ OwnPtr<WebDataConsumerHandle::Reader> m_reader; |
std::unique_ptr<OnFinishedReading> m_onFinishedReading; |
Vector<char> m_data; |
}; |
@@ -494,9 +495,9 @@ public: |
class HandleReaderRunner final { |
STACK_ALLOCATED(); |
public: |
- explicit HandleReaderRunner(std::unique_ptr<WebDataConsumerHandle> handle) |
- : m_thread(wrapUnique(new Thread("reading thread"))) |
- , m_event(wrapUnique(new WaitableEvent())) |
+ explicit HandleReaderRunner(PassOwnPtr<WebDataConsumerHandle> handle) |
+ : m_thread(adoptPtr(new Thread("reading thread"))) |
+ , m_event(adoptPtr(new WaitableEvent())) |
, m_isDone(false) |
{ |
m_thread->thread()->postTask(BLINK_FROM_HERE, threadSafeBind(&HandleReaderRunner::start, AllowCrossThreadAccess(this), passed(std::move(handle)))); |
@@ -506,7 +507,7 @@ public: |
wait(); |
} |
- std::unique_ptr<HandleReadResult> wait() |
+ PassOwnPtr<HandleReadResult> wait() |
{ |
if (m_isDone) |
return nullptr; |
@@ -516,24 +517,24 @@ public: |
} |
private: |
- void start(std::unique_ptr<WebDataConsumerHandle> handle) |
+ void start(PassOwnPtr<WebDataConsumerHandle> handle) |
{ |
- m_handleReader = wrapUnique(new T(std::move(handle), WTF::bind<std::unique_ptr<HandleReadResult>>(&HandleReaderRunner::onFinished, this))); |
+ m_handleReader = adoptPtr(new T(std::move(handle), bind<PassOwnPtr<HandleReadResult>>(&HandleReaderRunner::onFinished, this))); |
} |
- void onFinished(std::unique_ptr<HandleReadResult> result) |
+ void onFinished(PassOwnPtr<HandleReadResult> result) |
{ |
m_handleReader = nullptr; |
m_result = std::move(result); |
m_event->signal(); |
} |
- std::unique_ptr<Thread> m_thread; |
- std::unique_ptr<WaitableEvent> m_event; |
- std::unique_ptr<HandleReadResult> m_result; |
+ OwnPtr<Thread> m_thread; |
+ OwnPtr<WaitableEvent> m_event; |
+ OwnPtr<HandleReadResult> m_result; |
bool m_isDone; |
- std::unique_ptr<T> m_handleReader; |
+ OwnPtr<T> m_handleReader; |
}; |
}; |