Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(793)

Unified Diff: third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h

Issue 2050123002: Remove OwnPtr from Blink. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: First attempt to land. Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
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 e629a0312679007a23d889b0ae11cc137f54c1eb..47cb1c700ea6b5174ed06d8e81166d1d89b7d48d 100644
--- a/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h
+++ b/third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h
@@ -20,14 +20,13 @@
#include "public/platform/WebTraceLocation.h"
#include "wtf/Deque.h"
#include "wtf/Locker.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/PassOwnPtr.h"
+#include "wtf/PtrUtil.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 {
@@ -69,11 +68,11 @@ public:
void initialize();
void shutdown();
- OwnPtr<WebThreadSupportingGC> m_thread;
+ std::unique_ptr<WebThreadSupportingGC> m_thread;
const InitializationPolicy m_initializationPolicy;
- OwnPtr<WaitableEvent> m_waitableEvent;
+ std::unique_ptr<WaitableEvent> m_waitableEvent;
Persistent<NullExecutionContext> m_executionContext;
- OwnPtr<gin::IsolateHolder> m_isolateHolder;
+ std::unique_ptr<gin::IsolateHolder> m_isolateHolder;
RefPtr<ScriptState> m_scriptState;
};
@@ -160,8 +159,8 @@ public:
public:
ThreadHolder(ThreadingTestBase* test)
: m_context(test->m_context)
- , m_readingThread(adoptPtr(new Thread("reading thread")))
- , m_updatingThread(adoptPtr(new Thread("updating thread")))
+ , m_readingThread(wrapUnique(new Thread("reading thread")))
+ , m_updatingThread(wrapUnique(new Thread("updating thread")))
{
m_context->registerThreadHolder(this);
}
@@ -175,8 +174,8 @@ public:
private:
RefPtr<Context> m_context;
- OwnPtr<Thread> m_readingThread;
- OwnPtr<Thread> m_updatingThread;
+ std::unique_ptr<Thread> m_readingThread;
+ std::unique_ptr<Thread> m_updatingThread;
};
class ReaderImpl final : public WebDataConsumerHandle::Reader {
@@ -200,9 +199,9 @@ public:
class DataConsumerHandle final : public WebDataConsumerHandle {
USING_FAST_MALLOC(DataConsumerHandle);
public:
- static PassOwnPtr<WebDataConsumerHandle> create(const String& name, PassRefPtr<Context> context)
+ static std::unique_ptr<WebDataConsumerHandle> create(const String& name, PassRefPtr<Context> context)
{
- return adoptPtr(new DataConsumerHandle(name, context));
+ return wrapUnique(new DataConsumerHandle(name, context));
}
private:
@@ -241,8 +240,8 @@ public:
: m_context(Context::create()) { }
RefPtr<Context> m_context;
- OwnPtr<WebDataConsumerHandle::Reader> m_reader;
- OwnPtr<WaitableEvent> m_waitableEvent;
+ std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
+ std::unique_ptr<WaitableEvent> m_waitableEvent;
NoopClient m_client;
};
@@ -251,10 +250,10 @@ public:
using Self = ThreadingHandleNotificationTest;
static PassRefPtr<Self> create() { return adoptRef(new Self); }
- void run(PassOwnPtr<WebDataConsumerHandle> handle)
+ void run(std::unique_ptr<WebDataConsumerHandle> handle)
{
ThreadHolder holder(this);
- m_waitableEvent = adoptPtr(new WaitableEvent());
+ m_waitableEvent = wrapUnique(new WaitableEvent());
m_handle = std::move(handle);
postTaskToReadingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::obtainReader, this));
@@ -272,7 +271,7 @@ public:
postTaskToReadingThread(BLINK_FROM_HERE, threadSafeBind(&Self::signalDone, this));
}
- OwnPtr<WebDataConsumerHandle> m_handle;
+ std::unique_ptr<WebDataConsumerHandle> m_handle;
};
class ThreadingHandleNoNotificationTest : public ThreadingTestBase, public WebDataConsumerHandle::Client {
@@ -280,10 +279,10 @@ public:
using Self = ThreadingHandleNoNotificationTest;
static PassRefPtr<Self> create() { return adoptRef(new Self); }
- void run(PassOwnPtr<WebDataConsumerHandle> handle)
+ void run(std::unique_ptr<WebDataConsumerHandle> handle)
{
ThreadHolder holder(this);
- m_waitableEvent = adoptPtr(new WaitableEvent());
+ m_waitableEvent = wrapUnique(new WaitableEvent());
m_handle = std::move(handle);
postTaskToReadingThreadAndWait(BLINK_FROM_HERE, threadSafeBind(&Self::obtainReader, this));
@@ -302,12 +301,12 @@ public:
ASSERT_NOT_REACHED();
}
- OwnPtr<WebDataConsumerHandle> m_handle;
+ std::unique_ptr<WebDataConsumerHandle> m_handle;
};
class MockFetchDataConsumerHandle : public FetchDataConsumerHandle {
public:
- static PassOwnPtr<::testing::StrictMock<MockFetchDataConsumerHandle>> create() { return adoptPtr(new ::testing::StrictMock<MockFetchDataConsumerHandle>); }
+ static std::unique_ptr<::testing::StrictMock<MockFetchDataConsumerHandle>> create() { return wrapUnique(new ::testing::StrictMock<MockFetchDataConsumerHandle>); }
MOCK_METHOD1(obtainReaderInternal, Reader*(Client*));
private:
@@ -316,7 +315,7 @@ public:
class MockFetchDataConsumerReader : public FetchDataConsumerHandle::Reader {
public:
- static PassOwnPtr<::testing::StrictMock<MockFetchDataConsumerReader>> create() { return adoptPtr(new ::testing::StrictMock<MockFetchDataConsumerReader>); }
+ static std::unique_ptr<::testing::StrictMock<MockFetchDataConsumerReader>> create() { return wrapUnique(new ::testing::StrictMock<MockFetchDataConsumerReader>); }
using Result = WebDataConsumerHandle::Result;
using Flags = WebDataConsumerHandle::Flags;
@@ -388,7 +387,7 @@ public:
class ReplayingHandle final : public WebDataConsumerHandle {
USING_FAST_MALLOC(ReplayingHandle);
public:
- static PassOwnPtr<ReplayingHandle> create() { return adoptPtr(new ReplayingHandle()); }
+ static std::unique_ptr<ReplayingHandle> create() { return wrapUnique(new ReplayingHandle()); }
~ReplayingHandle();
// Add a command to this handle. This function must be called on the
@@ -425,7 +424,7 @@ public:
Result m_result;
bool m_isHandleAttached;
Mutex m_mutex;
- OwnPtr<WaitableEvent> m_detached;
+ std::unique_ptr<WaitableEvent> m_detached;
};
Context* getContext() { return m_context.get(); }
@@ -458,15 +457,15 @@ public:
class HandleReader final : public WebDataConsumerHandle::Client {
USING_FAST_MALLOC(HandleReader);
public:
- using OnFinishedReading = WTF::Function<void(PassOwnPtr<HandleReadResult>)>;
+ using OnFinishedReading = WTF::Function<void(std::unique_ptr<HandleReadResult>)>;
- HandleReader(PassOwnPtr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>);
+ HandleReader(std::unique_ptr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>);
void didGetReadable() override;
private:
- void runOnFinishedReading(PassOwnPtr<HandleReadResult>);
+ void runOnFinishedReading(std::unique_ptr<HandleReadResult>);
- OwnPtr<WebDataConsumerHandle::Reader> m_reader;
+ std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
std::unique_ptr<OnFinishedReading> m_onFinishedReading;
Vector<char> m_data;
};
@@ -476,15 +475,15 @@ public:
class HandleTwoPhaseReader final : public WebDataConsumerHandle::Client {
USING_FAST_MALLOC(HandleTwoPhaseReader);
public:
- using OnFinishedReading = WTF::Function<void(PassOwnPtr<HandleReadResult>)>;
+ using OnFinishedReading = WTF::Function<void(std::unique_ptr<HandleReadResult>)>;
- HandleTwoPhaseReader(PassOwnPtr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>);
+ HandleTwoPhaseReader(std::unique_ptr<WebDataConsumerHandle>, std::unique_ptr<OnFinishedReading>);
void didGetReadable() override;
private:
- void runOnFinishedReading(PassOwnPtr<HandleReadResult>);
+ void runOnFinishedReading(std::unique_ptr<HandleReadResult>);
- OwnPtr<WebDataConsumerHandle::Reader> m_reader;
+ std::unique_ptr<WebDataConsumerHandle::Reader> m_reader;
std::unique_ptr<OnFinishedReading> m_onFinishedReading;
Vector<char> m_data;
};
@@ -495,9 +494,9 @@ public:
class HandleReaderRunner final {
STACK_ALLOCATED();
public:
- explicit HandleReaderRunner(PassOwnPtr<WebDataConsumerHandle> handle)
- : m_thread(adoptPtr(new Thread("reading thread")))
- , m_event(adoptPtr(new WaitableEvent()))
+ explicit HandleReaderRunner(std::unique_ptr<WebDataConsumerHandle> handle)
+ : m_thread(wrapUnique(new Thread("reading thread")))
+ , m_event(wrapUnique(new WaitableEvent()))
, m_isDone(false)
{
m_thread->thread()->postTask(BLINK_FROM_HERE, threadSafeBind(&HandleReaderRunner::start, AllowCrossThreadAccess(this), passed(std::move(handle))));
@@ -507,7 +506,7 @@ public:
wait();
}
- PassOwnPtr<HandleReadResult> wait()
+ std::unique_ptr<HandleReadResult> wait()
{
if (m_isDone)
return nullptr;
@@ -517,24 +516,24 @@ public:
}
private:
- void start(PassOwnPtr<WebDataConsumerHandle> handle)
+ void start(std::unique_ptr<WebDataConsumerHandle> handle)
{
- m_handleReader = adoptPtr(new T(std::move(handle), bind<PassOwnPtr<HandleReadResult>>(&HandleReaderRunner::onFinished, this)));
+ m_handleReader = wrapUnique(new T(std::move(handle), WTF::bind<std::unique_ptr<HandleReadResult>>(&HandleReaderRunner::onFinished, this)));
}
- void onFinished(PassOwnPtr<HandleReadResult> result)
+ void onFinished(std::unique_ptr<HandleReadResult> result)
{
m_handleReader = nullptr;
m_result = std::move(result);
m_event->signal();
}
- OwnPtr<Thread> m_thread;
- OwnPtr<WaitableEvent> m_event;
- OwnPtr<HandleReadResult> m_result;
+ std::unique_ptr<Thread> m_thread;
+ std::unique_ptr<WaitableEvent> m_event;
+ std::unique_ptr<HandleReadResult> m_result;
bool m_isDone;
- OwnPtr<T> m_handleReader;
+ std::unique_ptr<T> m_handleReader;
};
};

Powered by Google App Engine
This is Rietveld 408576698