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

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

Issue 2080623002: Revert "Remove OwnPtr from Blink." (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: 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 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;
};
};

Powered by Google App Engine
This is Rietveld 408576698