Changeset 201493 in webkit


Ignore:
Timestamp:
May 28, 2016 9:20:06 PM (8 years ago)
Author:
Chris Dumez
Message:

Templatize NoncopyableFunction class similarly to std::function
​https://bugs.webkit.org/show_bug.cgi?id=158185

Reviewed by Darin Adler.

Templatize NoncopyableFunction class similarly to std::function, so
that it can be used as a std::function replacement in more places.

Previously, NoncopyableFunction could only support "void()" lambdas.

Source/WebCore:

  • Modules/mediastream/MediaEndpointPeerConnection.cpp:

(WebCore::MediaEndpointPeerConnection::runTask):

  • Modules/mediastream/MediaEndpointPeerConnection.h:
  • fileapi/AsyncFileStream.cpp:

(WebCore::callOnFileThread):
(WebCore::AsyncFileStream::perform):
(WebCore::AsyncFileStream::getSize):
(WebCore::AsyncFileStream::openForRead):
(WebCore::AsyncFileStream::openForWrite):
(WebCore::AsyncFileStream::write):

  • fileapi/AsyncFileStream.h:
  • page/scrolling/ScrollingThread.cpp:

(WebCore::ScrollingThread::dispatch):
(WebCore::ScrollingThread::dispatchBarrier):
(WebCore::ScrollingThread::dispatchFunctionsFromScrollingThread):

  • page/scrolling/ScrollingThread.h:
  • platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h:
  • platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm:

(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::scheduleDeferredTask):

  • platform/mediastream/MediaStreamPrivate.cpp:

(WebCore::MediaStreamPrivate::scheduleDeferredTask):

  • platform/mediastream/MediaStreamPrivate.h:
  • platform/mediastream/mac/AVMediaCaptureSource.h:
  • platform/mediastream/mac/AVMediaCaptureSource.mm:

(WebCore::AVMediaCaptureSource::scheduleDeferredTask):

Source/WebKit:

  • Storage/StorageSyncManager.cpp:

(WebCore::StorageSyncManager::dispatch):

  • Storage/StorageSyncManager.h:
  • Storage/StorageThread.cpp:

(WebCore::StorageThread::dispatch):
(WebCore::StorageThread::terminate):

  • Storage/StorageThread.h:

Source/WebKit2:

  • NetworkProcess/cache/NetworkCacheIOChannelSoup.cpp:

(WebKit::NetworkCache::runTaskInQueue):

Source/WTF:

  • wtf/FunctionDispatcher.h:
  • wtf/MainThread.cpp:

(WTF::functionQueue):
(WTF::dispatchFunctionsFromMainThread):
(WTF::callOnMainThread):

  • wtf/MainThread.h:
  • wtf/NoncopyableFunction.h:
  • wtf/RunLoop.cpp:

(WTF::RunLoop::performWork):
(WTF::RunLoop::dispatch):

  • wtf/RunLoop.h:
  • wtf/WorkQueue.h:
  • wtf/cocoa/WorkQueueCocoa.cpp:

(WTF::WorkQueue::dispatch):
(WTF::WorkQueue::dispatchAfter):

  • wtf/efl/DispatchQueueWorkItemEfl.h:

(WorkItem::WorkItem):
(TimerWorkItem::create):
(TimerWorkItem::TimerWorkItem):

  • wtf/efl/WorkQueueEfl.cpp:

(WTF::WorkQueue::dispatch):
(WTF::WorkQueue::dispatchAfter):

  • wtf/generic/RunLoopGeneric.cpp:

(WTF::RunLoop::TimerBase::ScheduledTask::create):
(WTF::RunLoop::TimerBase::ScheduledTask::ScheduledTask):
(WTF::RunLoop::dispatchAfter):

  • wtf/generic/WorkQueueGeneric.cpp:

(WorkQueue::dispatch):
(WorkQueue::dispatchAfter):

  • wtf/glib/RunLoopGLib.cpp:

(WTF::DispatchAfterContext::DispatchAfterContext):
(WTF::RunLoop::dispatchAfter):

  • wtf/win/WorkItemWin.cpp:

(WTF::WorkItemWin::WorkItemWin):
(WTF::WorkItemWin::create):
(WTF::HandleWorkItem::HandleWorkItem):
(WTF::HandleWorkItem::createByAdoptingHandle):

  • wtf/win/WorkItemWin.h:

(WTF::WorkItemWin::function):

  • wtf/win/WorkQueueWin.cpp:

(WTF::WorkQueue::dispatch):
(WTF::WorkQueue::dispatchAfter):

Location:
trunk/Source
Files:
37 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r201483 r201493  
     12016-05-28  Chris Dumez  <cdumez@apple.com>
     2
     3        Templatize NoncopyableFunction class similarly to std::function
     4        https://bugs.webkit.org/show_bug.cgi?id=158185
     5
     6        Reviewed by Darin Adler.
     7
     8        Templatize NoncopyableFunction class similarly to std::function, so
     9        that it can be used as a std::function replacement in more places.
     10
     11        Previously, NoncopyableFunction could only support "void()" lambdas.
     12
     13        * wtf/FunctionDispatcher.h:
     14        * wtf/MainThread.cpp:
     15        (WTF::functionQueue):
     16        (WTF::dispatchFunctionsFromMainThread):
     17        (WTF::callOnMainThread):
     18        * wtf/MainThread.h:
     19        * wtf/NoncopyableFunction.h:
     20        * wtf/RunLoop.cpp:
     21        (WTF::RunLoop::performWork):
     22        (WTF::RunLoop::dispatch):
     23        * wtf/RunLoop.h:
     24        * wtf/WorkQueue.h:
     25        * wtf/cocoa/WorkQueueCocoa.cpp:
     26        (WTF::WorkQueue::dispatch):
     27        (WTF::WorkQueue::dispatchAfter):
     28        * wtf/efl/DispatchQueueWorkItemEfl.h:
     29        (WorkItem::WorkItem):
     30        (TimerWorkItem::create):
     31        (TimerWorkItem::TimerWorkItem):
     32        * wtf/efl/WorkQueueEfl.cpp:
     33        (WTF::WorkQueue::dispatch):
     34        (WTF::WorkQueue::dispatchAfter):
     35        * wtf/generic/RunLoopGeneric.cpp:
     36        (WTF::RunLoop::TimerBase::ScheduledTask::create):
     37        (WTF::RunLoop::TimerBase::ScheduledTask::ScheduledTask):
     38        (WTF::RunLoop::dispatchAfter):
     39        * wtf/generic/WorkQueueGeneric.cpp:
     40        (WorkQueue::dispatch):
     41        (WorkQueue::dispatchAfter):
     42        * wtf/glib/RunLoopGLib.cpp:
     43        (WTF::DispatchAfterContext::DispatchAfterContext):
     44        (WTF::RunLoop::dispatchAfter):
     45        * wtf/win/WorkItemWin.cpp:
     46        (WTF::WorkItemWin::WorkItemWin):
     47        (WTF::WorkItemWin::create):
     48        (WTF::HandleWorkItem::HandleWorkItem):
     49        (WTF::HandleWorkItem::createByAdoptingHandle):
     50        * wtf/win/WorkItemWin.h:
     51        (WTF::WorkItemWin::function):
     52        * wtf/win/WorkQueueWin.cpp:
     53        (WTF::WorkQueue::dispatch):
     54        (WTF::WorkQueue::dispatchAfter):
     55
    1562016-05-28  Dan Bernstein  <mitz@apple.com>
    257

  • trunk/Source/WTF/wtf/FunctionDispatcher.h

    r201482 r201493  
    4040    WTF_EXPORT_PRIVATE virtual ~FunctionDispatcher();
    4141
    42     virtual void dispatch(NoncopyableFunction&&) = 0;
     42    virtual void dispatch(NoncopyableFunction<void ()>&&) = 0;
    4343
    4444protected:

  • trunk/Source/WTF/wtf/MainThread.cpp

    r201482 r201493  
    4848static StaticLock mainThreadFunctionQueueMutex;
    4949
    50 static Deque<NoncopyableFunction>& functionQueue()
    51 {
    52     static NeverDestroyed<Deque<NoncopyableFunction>> functionQueue;
     50static Deque<NoncopyableFunction<void ()>>& functionQueue()
     51{
     52    static NeverDestroyed<Deque<NoncopyableFunction<void ()>>> functionQueue;
    5353    return functionQueue;
    5454}
    … …  
    121121    auto startTime = std::chrono::steady_clock::now();
    122122
    123     NoncopyableFunction function;
     123    NoncopyableFunction<void ()> function;
    124124
    125125    while (true) {
    … …  
    145145}
    146146
    147 void callOnMainThread(NoncopyableFunction&& function)
     147void callOnMainThread(NoncopyableFunction<void ()>&& function)
    148148{
    149149    ASSERT(function);

  • trunk/Source/WTF/wtf/MainThread.h

    r201482 r201493  
    4242WTF_EXPORT_PRIVATE void initializeMainThread();
    4343
    44 WTF_EXPORT_PRIVATE void callOnMainThread(NoncopyableFunction&&);
     44WTF_EXPORT_PRIVATE void callOnMainThread(NoncopyableFunction<void ()>&&);
    4545
    4646#if PLATFORM(COCOA)

  • trunk/Source/WTF/wtf/NoncopyableFunction.h

    r201483 r201493  
    3131namespace WTF {
    3232
    33 // FIXME: We could make this templated to support other lambdas than void() and make this more reusable.
    34 class NoncopyableFunction {
     33template<typename> class NoncopyableFunction;
     34
     35template <typename Out, typename... In>
     36class NoncopyableFunction<Out(In...)> {
    3537public:
    3638    NoncopyableFunction() = default;
    … …  
    4244    }
    4345
    44     void operator()() const
     46    Out operator()(In... in) const
    4547    {
    4648        if (m_callableWrapper)
    47             m_callableWrapper->call();
     49            return m_callableWrapper->call(std::forward<In>(in)...);
     50        return Out();
    4851    }
    4952
    … …  
    6972        virtual ~CallableWrapperBase() { }
    7073
    71         virtual void call() = 0;
     74        virtual Out call(In...) = 0;
    7275    };
    7376
    7477    template<typename CallableType>
    75     class CallableWrapper final : public CallableWrapperBase {
     78    class CallableWrapper : public CallableWrapperBase {
    7679    public:
    7780        explicit CallableWrapper(CallableType&& callable)
    … …  
    8386        CallableWrapper& operator=(const CallableWrapper&) = delete;
    8487
    85         void call() final { m_callable(); }
     88        Out call(In... in) final { return m_callable(std::forward<In>(in)...); }
    8689
    8790    private:

  • trunk/Source/WTF/wtf/RunLoop.cpp

    r201464 r201493  
    9292    size_t functionsToHandle = 0;
    9393    {
    94         NoncopyableFunction function;
     94        NoncopyableFunction<void ()> function;
    9595        {
    9696            MutexLocker locker(m_functionQueueLock);
    … …  
    107107
    108108    for (size_t functionsHandled = 1; functionsHandled < functionsToHandle; ++functionsHandled) {
    109         NoncopyableFunction function;
     109        NoncopyableFunction<void ()> function;
    110110        {
    111111            MutexLocker locker(m_functionQueueLock);
    … …  
    124124}
    125125
    126 void RunLoop::dispatch(NoncopyableFunction&& function)
     126void RunLoop::dispatch(NoncopyableFunction<void ()>&& function)
    127127{
    128128    {

  • trunk/Source/WTF/wtf/RunLoop.h

    r201464 r201493  
    6060    ~RunLoop();
    6161
    62     void dispatch(NoncopyableFunction&&) override;
     62    void dispatch(NoncopyableFunction<void ()>&&) override;
    6363
    6464    WTF_EXPORT_PRIVATE static void run();
    … …  
    8080
    8181#if USE(GLIB_EVENT_LOOP) || USE(GENERIC_EVENT_LOOP)
    82     WTF_EXPORT_PRIVATE void dispatchAfter(std::chrono::nanoseconds, NoncopyableFunction&&);
     82    WTF_EXPORT_PRIVATE void dispatchAfter(std::chrono::nanoseconds, NoncopyableFunction<void ()>&&);
    8383#endif
    8484
    … …  
    156156
    157157    Mutex m_functionQueueLock;
    158     Deque<NoncopyableFunction> m_functionQueue;
     158    Deque<NoncopyableFunction<void ()>> m_functionQueue;
    159159
    160160#if USE(WINDOWS_EVENT_LOOP)

  • trunk/Source/WTF/wtf/WorkQueue.h

    r201464 r201493  
    7373    virtual ~WorkQueue();
    7474
    75     WTF_EXPORT_PRIVATE void dispatch(NoncopyableFunction&&) override;
    76     WTF_EXPORT_PRIVATE void dispatchAfter(std::chrono::nanoseconds, NoncopyableFunction&&);
     75    WTF_EXPORT_PRIVATE void dispatch(NoncopyableFunction<void ()>&&) override;
     76    WTF_EXPORT_PRIVATE void dispatchAfter(std::chrono::nanoseconds, NoncopyableFunction<void ()>&&);
    7777
    7878    WTF_EXPORT_PRIVATE static void concurrentApply(size_t iterations, const std::function<void (size_t index)>&);

  • trunk/Source/WTF/wtf/cocoa/WorkQueueCocoa.cpp

    r201464 r201493  
    2929namespace WTF {
    3030
    31 void WorkQueue::dispatch(NoncopyableFunction&& function)
     31void WorkQueue::dispatch(NoncopyableFunction<void ()>&& function)
    3232{
    3333    ref();
    34     auto* functionPtr = new NoncopyableFunction(WTFMove(function));
     34    auto* functionPtr = new NoncopyableFunction<void ()>(WTFMove(function));
    3535    dispatch_async(m_dispatchQueue, ^{
    3636        (*functionPtr)();
    … …  
    4040}
    4141
    42 void WorkQueue::dispatchAfter(std::chrono::nanoseconds duration, NoncopyableFunction&& function)
     42void WorkQueue::dispatchAfter(std::chrono::nanoseconds duration, NoncopyableFunction<void ()>&& function)
    4343{
    4444    ref();
    45     auto* functionPtr = new NoncopyableFunction(WTFMove(function));
     45    auto* functionPtr = new NoncopyableFunction<void ()>(WTFMove(function));
    4646    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, duration.count()), m_dispatchQueue, ^{
    4747        (*functionPtr)();

  • trunk/Source/WTF/wtf/efl/DispatchQueueWorkItemEfl.h

    r201464 r201493  
    3535class WorkItem {
    3636public:
    37     WorkItem(Ref<WorkQueue>&& workQueue, NoncopyableFunction&& function)
     37    WorkItem(Ref<WorkQueue>&& workQueue, NoncopyableFunction<void ()>&& function)
    3838        : m_workQueue(WTFMove(workQueue))
    3939        , m_function(WTFMove(function))
    … …  
    4545private:
    4646    Ref<WorkQueue> m_workQueue;
    47     NoncopyableFunction m_function;
     47    NoncopyableFunction<void ()> m_function;
    4848};
    4949
    5050class TimerWorkItem : public WorkItem {
    5151public:
    52     static std::unique_ptr<TimerWorkItem> create(Ref<WorkQueue>&& workQueue, NoncopyableFunction&& function, std::chrono::nanoseconds delayNanoSeconds)
     52    static std::unique_ptr<TimerWorkItem> create(Ref<WorkQueue>&& workQueue, NoncopyableFunction<void ()>&& function, std::chrono::nanoseconds delayNanoSeconds)
    5353    {
    5454        ASSERT(delayNanoSeconds.count() >= 0);
    … …  
    5959
    6060protected:
    61     TimerWorkItem(Ref<WorkQueue>&& workQueue, NoncopyableFunction&& function, double expirationTimeNanoSeconds)
     61    TimerWorkItem(Ref<WorkQueue>&& workQueue, NoncopyableFunction<void ()>&& function, double expirationTimeNanoSeconds)
    6262        : WorkItem(WTFMove(workQueue), WTFMove(function))
    6363        , m_expirationTimeNanoSeconds(expirationTimeNanoSeconds)

  • trunk/Source/WTF/wtf/efl/WorkQueueEfl.cpp

    r201464 r201493  
    5555}
    5656
    57 void WorkQueue::dispatch(NoncopyableFunction&& function)
     57void WorkQueue::dispatch(NoncopyableFunction<void ()>&& function)
    5858{
    5959    if (!m_dispatchQueue)
    … …  
    6363}
    6464
    65 void WorkQueue::dispatchAfter(std::chrono::nanoseconds duration, NoncopyableFunction&& function)
     65void WorkQueue::dispatchAfter(std::chrono::nanoseconds duration, NoncopyableFunction<void ()>&& function)
    6666{
    6767    if (!m_dispatchQueue)

  • trunk/Source/WTF/wtf/generic/RunLoopGeneric.cpp

    r201479 r201493  
    3333WTF_MAKE_NONCOPYABLE(ScheduledTask);
    3434public:
    35     static RefPtr<ScheduledTask> create(NoncopyableFunction&& function, double interval, bool repeating)
     35    static RefPtr<ScheduledTask> create(NoncopyableFunction<void ()>&& function, double interval, bool repeating)
    3636    {
    3737        return adoptRef(new ScheduledTask(WTFMove(function), interval, repeating));
    3838    }
    3939
    40     ScheduledTask(NoncopyableFunction&& function, double interval, bool repeating)
     40    ScheduledTask(NoncopyableFunction<void ()>&& function, double interval, bool repeating)
    4141        : m_function(WTFMove(function))
    4242        , m_fireInterval(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::duration<double>(interval)))
    … …  
    9191
    9292private:
    93     NoncopyableFunction m_function;
     93    NoncopyableFunction<void ()> m_function;
    9494    Condition::Clock::time_point m_scheduledTimePoint;
    9595    std::chrono::microseconds m_fireInterval;
    … …  
    238238}
    239239
    240 void RunLoop::dispatchAfter(std::chrono::nanoseconds delay, NoncopyableFunction&& function)
     240void RunLoop::dispatchAfter(std::chrono::nanoseconds delay, NoncopyableFunction<void ()>&& function)
    241241{
    242242    LockHolder locker(m_loopLock);

  • trunk/Source/WTF/wtf/generic/WorkQueueGeneric.cpp

    r201464 r201493  
    8282}
    8383
    84 void WorkQueue::dispatch(NoncopyableFunction&& function)
     84void WorkQueue::dispatch(NoncopyableFunction<void ()>&& function)
    8585{
    8686    RefPtr<WorkQueue> protect(this);
    … …  
    9090}
    9191
    92 void WorkQueue::dispatchAfter(std::chrono::nanoseconds delay, NoncopyableFunction&& function)
     92void WorkQueue::dispatchAfter(std::chrono::nanoseconds delay, NoncopyableFunction<void ()>&& function)
    9393{
    9494    RefPtr<WorkQueue> protect(this);

  • trunk/Source/WTF/wtf/glib/RunLoopGLib.cpp

    r201464 r201493  
    125125    WTF_MAKE_FAST_ALLOCATED;
    126126public:
    127     DispatchAfterContext(NoncopyableFunction&& function)
     127    DispatchAfterContext(NoncopyableFunction<void ()>&& function)
    128128        : m_function(WTFMove(function))
    129129    {
    … …  
    136136
    137137private:
    138     NoncopyableFunction m_function;
     138    NoncopyableFunction<void ()> m_function;
    139139};
    140140
    141 void RunLoop::dispatchAfter(std::chrono::nanoseconds duration, NoncopyableFunction&& function)
     141void RunLoop::dispatchAfter(std::chrono::nanoseconds duration, NoncopyableFunction<void ()>&& function)
    142142{
    143143    GRefPtr<GSource> source = adoptGRef(g_timeout_source_new(std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()));

  • trunk/Source/WTF/wtf/win/WorkItemWin.cpp

    r201464 r201493  
    3333namespace WTF {
    3434
    35 WorkItemWin::WorkItemWin(NoncopyableFunction&& function, WorkQueue* queue)
     35WorkItemWin::WorkItemWin(NoncopyableFunction<void ()>&& function, WorkQueue* queue)
    3636    : m_function(WTFMove(function))
    3737    , m_queue(queue)
    … …  
    3939}
    4040
    41 RefPtr<WorkItemWin> WorkItemWin::create(NoncopyableFunction&& function, WorkQueue* queue)
     41RefPtr<WorkItemWin> WorkItemWin::create(NoncopyableFunction<void ()>&& function, WorkQueue* queue)
    4242{
    4343    return adoptRef(new WorkItemWin(WTFMove(function), queue));
    … …  
    4848}
    4949
    50 HandleWorkItem::HandleWorkItem(HANDLE handle, NoncopyableFunction&& function, WorkQueue* queue)
     50HandleWorkItem::HandleWorkItem(HANDLE handle, NoncopyableFunction<void ()>&& function, WorkQueue* queue)
    5151    : WorkItemWin(WTFMove(function), queue)
    5252    , m_handle(handle)
    … …  
    5656}
    5757
    58 RefPtr<HandleWorkItem> HandleWorkItem::createByAdoptingHandle(HANDLE handle, NoncopyableFunction&& function, WorkQueue* queue)
     58RefPtr<HandleWorkItem> HandleWorkItem::createByAdoptingHandle(HANDLE handle, NoncopyableFunction<void ()>&& function, WorkQueue* queue)
    5959{
    6060    return adoptRef(new HandleWorkItem(handle, WTFMove(function), queue));

  • trunk/Source/WTF/wtf/win/WorkItemWin.h

    r201464 r201493  
    4040class WorkItemWin : public ThreadSafeRefCounted<WorkItemWin> {
    4141public:
    42     static RefPtr<WorkItemWin> create(NoncopyableFunction&&, WorkQueue*);
     42    static RefPtr<WorkItemWin> create(NoncopyableFunction<void ()>&&, WorkQueue*);
    4343    virtual ~WorkItemWin();
    4444
    45     NoncopyableFunction& function() { return m_function; }
     45    NoncopyableFunction<void ()>& function() { return m_function; }
    4646    WorkQueue* queue() const { return m_queue.get(); }
    4747
    4848protected:
    49     WorkItemWin(NoncopyableFunction&&, WorkQueue*);
     49    WorkItemWin(NoncopyableFunction<void ()>&&, WorkQueue*);
    5050
    5151private:
    52     NoncopyableFunction m_function;
     52    NoncopyableFunction<void ()> m_function;
    5353    RefPtr<WorkQueue> m_queue;
    5454};
    … …  
    5656class HandleWorkItem : public WorkItemWin {
    5757public:
    58     static RefPtr<HandleWorkItem> createByAdoptingHandle(HANDLE, NoncopyableFunction&&, WorkQueue*);
     58    static RefPtr<HandleWorkItem> createByAdoptingHandle(HANDLE, NoncopyableFunction<void ()>&&, WorkQueue*);
    5959    virtual ~HandleWorkItem();
    6060
    … …  
    6363
    6464private:
    65     HandleWorkItem(HANDLE, NoncopyableFunction&&, WorkQueue*);
     65    HandleWorkItem(HANDLE, NoncopyableFunction<void ()>&&, WorkQueue*);
    6666
    6767    HANDLE m_handle;

  • trunk/Source/WTF/wtf/win/WorkQueueWin.cpp

    r201464 r201493  
    130130}
    131131
    132 void WorkQueue::dispatch(NoncopyableFunction&& function)
     132void WorkQueue::dispatch(NoncopyableFunction<void ()>&& function)
    133133{
    134134    MutexLocker locker(m_workItemQueueLock);
    … …  
    150150
    151151    WorkQueue* queue;
    152     NoncopyableFunction function;
     152    NoncopyableFunction<void ()> function;
    153153    Mutex timerMutex;
    154154    HANDLE timer;
    … …  
    181181}
    182182
    183 void WorkQueue::dispatchAfter(std::chrono::nanoseconds duration, NoncopyableFunction&& function)
     183void WorkQueue::dispatchAfter(std::chrono::nanoseconds duration, NoncopyableFunction<void ()>&& function)
    184184{
    185185    ASSERT(m_timerQueue);

  • trunk/Source/WebCore/ChangeLog

    r201492 r201493  
     12016-05-28  Chris Dumez  <cdumez@apple.com>
     2
     3        Templatize NoncopyableFunction class similarly to std::function
     4        https://bugs.webkit.org/show_bug.cgi?id=158185
     5
     6        Reviewed by Darin Adler.
     7
     8        Templatize NoncopyableFunction class similarly to std::function, so
     9        that it can be used as a std::function replacement in more places.
     10
     11        Previously, NoncopyableFunction could only support "void()" lambdas.
     12
     13        * Modules/mediastream/MediaEndpointPeerConnection.cpp:
     14        (WebCore::MediaEndpointPeerConnection::runTask):
     15        * Modules/mediastream/MediaEndpointPeerConnection.h:
     16        * fileapi/AsyncFileStream.cpp:
     17        (WebCore::callOnFileThread):
     18        (WebCore::AsyncFileStream::perform):
     19        (WebCore::AsyncFileStream::getSize):
     20        (WebCore::AsyncFileStream::openForRead):
     21        (WebCore::AsyncFileStream::openForWrite):
     22        (WebCore::AsyncFileStream::write):
     23        * fileapi/AsyncFileStream.h:
     24        * page/scrolling/ScrollingThread.cpp:
     25        (WebCore::ScrollingThread::dispatch):
     26        (WebCore::ScrollingThread::dispatchBarrier):
     27        (WebCore::ScrollingThread::dispatchFunctionsFromScrollingThread):
     28        * page/scrolling/ScrollingThread.h:
     29        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h:
     30        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm:
     31        (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::scheduleDeferredTask):
     32        * platform/mediastream/MediaStreamPrivate.cpp:
     33        (WebCore::MediaStreamPrivate::scheduleDeferredTask):
     34        * platform/mediastream/MediaStreamPrivate.h:
     35        * platform/mediastream/mac/AVMediaCaptureSource.h:
     36        * platform/mediastream/mac/AVMediaCaptureSource.mm:
     37        (WebCore::AVMediaCaptureSource::scheduleDeferredTask):
     38
    1392016-05-28  Alexey Proskuryakov  <ap@apple.com>
    240

  • trunk/Source/WebCore/Modules/mediastream/MediaEndpointPeerConnection.cpp

    r201482 r201493  
    9696}
    9797
    98 void MediaEndpointPeerConnection::runTask(NoncopyableFunction&& task)
     98void MediaEndpointPeerConnection::runTask(NoncopyableFunction<void ()>&& task)
    9999{
    100100    if (m_dtlsFingerprint.isNull()) {

  • trunk/Source/WebCore/Modules/mediastream/MediaEndpointPeerConnection.h

    r201482 r201493  
    7979
    8080private:
    81     void runTask(NoncopyableFunction&&);
     81    void runTask(NoncopyableFunction<void ()>&&);
    8282    void startRunningTasks();
    8383
    … …  
    9393    std::unique_ptr<MediaEndpoint> m_mediaEndpoint;
    9494
    95     NoncopyableFunction m_initialDeferredTask;
     95    NoncopyableFunction<void ()> m_initialDeferredTask;
    9696
    9797    std::unique_ptr<SDPProcessor> m_sdpProcessor;

  • trunk/Source/WebCore/fileapi/AsyncFileStream.cpp

    r201482 r201493  
    6565}
    6666
    67 static void callOnFileThread(NoncopyableFunction&& function)
     67static void callOnFileThread(NoncopyableFunction<void ()>&& function)
    6868{
    6969    ASSERT(isMainThread());
    7070    ASSERT(function);
    7171
    72     static NeverDestroyed<MessageQueue<NoncopyableFunction>> queue;
     72    static NeverDestroyed<MessageQueue<NoncopyableFunction<void ()>>> queue;
    7373
    7474    static std::once_flag createFileThreadOnce;
    … …  
    9191    });
    9292
    93     queue.get().append(std::make_unique<NoncopyableFunction>(WTFMove(function)));
     93    queue.get().append(std::make_unique<NoncopyableFunction<void ()>>(WTFMove(function)));
    9494}
    9595
    … …  
    115115}
    116116
    117 void AsyncFileStream::perform(std::function<std::function<void(FileStreamClient&)>(FileStream&)>&& operation)
     117void AsyncFileStream::perform(NoncopyableFunction<std::function<void(FileStreamClient&)>(FileStream&)>&& operation)
    118118{
    119119    auto& internals = *m_internals;
    … …  
    135135void AsyncFileStream::getSize(const String& path, double expectedModificationTime)
    136136{
    137     StringCapture capturedPath(path);
    138137    // FIXME: Explicit return type here and in all the other cases like this below is a workaround for a deficiency
    139138    // in the Windows compiler at the time of this writing. Could remove it if that is resolved.
    140     perform([capturedPath, expectedModificationTime](FileStream& stream) -> std::function<void(FileStreamClient&)> {
    141         long long size = stream.getSize(capturedPath.string(), expectedModificationTime);
     139    perform([path = path.isolatedCopy(), expectedModificationTime](FileStream& stream) -> std::function<void(FileStreamClient&)> {
     140        long long size = stream.getSize(path, expectedModificationTime);
    142141        return [size](FileStreamClient& client) {
    143142            client.didGetSize(size);
    … …  
    148147void AsyncFileStream::openForRead(const String& path, long long offset, long long length)
    149148{
    150     StringCapture capturedPath(path);
    151149    // FIXME: Explicit return type here is a workaround for a deficiency in the Windows compiler at the time of this writing.
    152     perform([capturedPath, offset, length](FileStream& stream) -> std::function<void(FileStreamClient&)> {
    153         bool success = stream.openForRead(capturedPath.string(), offset, length);
     150    perform([path = path.isolatedCopy(), offset, length](FileStream& stream) -> std::function<void(FileStreamClient&)> {
     151        bool success = stream.openForRead(path, offset, length);
    154152        return [success](FileStreamClient& client) {
    155153            client.didOpen(success);
    … …  
    160158void AsyncFileStream::openForWrite(const String& path)
    161159{
    162     StringCapture capturedPath(path);
    163     perform([capturedPath](FileStream& stream) -> std::function<void(FileStreamClient&)> {
    164         bool success = stream.openForWrite(capturedPath.string());
     160    perform([path = path.isolatedCopy()](FileStream& stream) -> std::function<void(FileStreamClient&)> {
     161        bool success = stream.openForWrite(path);
    165162        return [success](FileStreamClient& client) {
    166163            client.didOpen(success);
    … …  
    189186void AsyncFileStream::write(const URL& blobURL, long long position, int length)
    190187{
    191     URLCapture capturedURL(blobURL);
    192     perform([capturedURL, position, length](FileStream& stream) -> std::function<void(FileStreamClient&)> {
    193         int bytesWritten = stream.write(capturedURL.url(), position, length);
     188    perform([blobURL = blobURL.isolatedCopy(), position, length](FileStream& stream) -> std::function<void(FileStreamClient&)> {
     189        int bytesWritten = stream.write(blobURL, position, length);
    194190        return [bytesWritten](FileStreamClient& client) {
    195191            client.didWrite(bytesWritten);

  • trunk/Source/WebCore/fileapi/AsyncFileStream.h

    r201482 r201493  
    3535#include <functional>
    3636#include <wtf/Forward.h>
     37#include <wtf/NoncopyableFunction.h>
    3738
    3839namespace WebCore {
    … …  
    5758private:
    5859    void start();
    59     void perform(std::function<std::function<void(FileStreamClient&)>(FileStream&)>&&);
     60    void perform(NoncopyableFunction<std::function<void(FileStreamClient&)>(FileStream&)>&&);
    6061
    6162    struct Internals;

  • trunk/Source/WebCore/page/scrolling/ScrollingThread.cpp

    r201482 r201493  
    4646}
    4747
    48 void ScrollingThread::dispatch(NoncopyableFunction&& function)
     48void ScrollingThread::dispatch(NoncopyableFunction<void ()>&& function)
    4949{
    5050    auto& scrollingThread = ScrollingThread::singleton();
    … …  
    5959}
    6060
    61 void ScrollingThread::dispatchBarrier(NoncopyableFunction&& function)
     61void ScrollingThread::dispatchBarrier(NoncopyableFunction<void ()>&& function)
    6262{
    6363    dispatch([function = WTFMove(function)]() mutable {
    … …  
    105105    ASSERT(isCurrentThread());
    106106
    107     Vector<NoncopyableFunction> functions;
     107    Vector<NoncopyableFunction<void ()>> functions;
    108108   
    109109    {

  • trunk/Source/WebCore/page/scrolling/ScrollingThread.h

    r201482 r201493  
    4949public:
    5050    static bool isCurrentThread();
    51     WEBCORE_EXPORT static void dispatch(NoncopyableFunction&&);
     51    WEBCORE_EXPORT static void dispatch(NoncopyableFunction<void ()>&&);
    5252
    5353    // Will dispatch the given function on the main thread once all pending functions
    5454    // on the scrolling thread have finished executing. Used for synchronization purposes.
    55     WEBCORE_EXPORT static void dispatchBarrier(NoncopyableFunction&&);
     55    WEBCORE_EXPORT static void dispatchBarrier(NoncopyableFunction<void ()>&&);
    5656
    5757private:
    … …  
    8181
    8282    Lock m_functionsMutex;
    83     Vector<NoncopyableFunction> m_functions;
     83    Vector<NoncopyableFunction<void ()>> m_functions;
    8484
    8585#if PLATFORM(COCOA)

  • trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h

    r201482 r201493  
    144144    void renderingModeChanged();
    145145
    146     void scheduleDeferredTask(NoncopyableFunction&&);
     146    void scheduleDeferredTask(NoncopyableFunction<void ()>&&);
    147147
    148148    enum DisplayMode {

  • trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm

    r201482 r201493  
    625625}
    626626
    627 void MediaPlayerPrivateMediaStreamAVFObjC::scheduleDeferredTask(NoncopyableFunction&& function)
     627void MediaPlayerPrivateMediaStreamAVFObjC::scheduleDeferredTask(NoncopyableFunction<void ()>&& function)
    628628{
    629629    ASSERT(function);

  • trunk/Source/WebCore/platform/mediastream/MediaStreamPrivate.cpp

    r201482 r201493  
    300300}
    301301
    302 void MediaStreamPrivate::scheduleDeferredTask(NoncopyableFunction&& function)
     302void MediaStreamPrivate::scheduleDeferredTask(NoncopyableFunction<void ()>&& function)
    303303{
    304304    ASSERT(function);

  • trunk/Source/WebCore/platform/mediastream/MediaStreamPrivate.h

    r201482 r201493  
    113113    void updateActiveVideoTrack();
    114114
    115     void scheduleDeferredTask(NoncopyableFunction&&);
     115    void scheduleDeferredTask(NoncopyableFunction<void ()>&&);
    116116
    117117    WeakPtrFactory<MediaStreamPrivate> m_weakPtrFactory;

  • trunk/Source/WebCore/platform/mediastream/mac/AVMediaCaptureSource.h

    r201482 r201493  
    8787    void setAudioSampleBufferDelegate(AVCaptureAudioDataOutput*);
    8888
    89     void scheduleDeferredTask(NoncopyableFunction&&);
     89    void scheduleDeferredTask(NoncopyableFunction<void ()>&&);
    9090
    9191private:

  • trunk/Source/WebCore/platform/mediastream/mac/AVMediaCaptureSource.mm

    r201482 r201493  
    241241}
    242242
    243 void AVMediaCaptureSource::scheduleDeferredTask(NoncopyableFunction&& function)
     243void AVMediaCaptureSource::scheduleDeferredTask(NoncopyableFunction<void ()>&& function)
    244244{
    245245    ASSERT(function);

  • trunk/Source/WebKit/ChangeLog

    r201482 r201493  
     12016-05-28  Chris Dumez  <cdumez@apple.com>
     2
     3        Templatize NoncopyableFunction class similarly to std::function
     4        https://bugs.webkit.org/show_bug.cgi?id=158185
     5
     6        Reviewed by Darin Adler.
     7
     8        Templatize NoncopyableFunction class similarly to std::function, so
     9        that it can be used as a std::function replacement in more places.
     10
     11        Previously, NoncopyableFunction could only support "void()" lambdas.
     12
     13        * Storage/StorageSyncManager.cpp:
     14        (WebCore::StorageSyncManager::dispatch):
     15        * Storage/StorageSyncManager.h:
     16        * Storage/StorageThread.cpp:
     17        (WebCore::StorageThread::dispatch):
     18        (WebCore::StorageThread::terminate):
     19        * Storage/StorageThread.h:
     20
    1212016-05-27  Chris Dumez  <cdumez@apple.com>
    222

  • trunk/Source/WebKit/Storage/StorageSyncManager.cpp

    r201482 r201493  
    6464}
    6565
    66 void StorageSyncManager::dispatch(NoncopyableFunction&& function)
     66void StorageSyncManager::dispatch(NoncopyableFunction<void ()>&& function)
    6767{
    6868    ASSERT(isMainThread());

  • trunk/Source/WebKit/Storage/StorageSyncManager.h

    r201482 r201493  
    4444    ~StorageSyncManager();
    4545
    46     void dispatch(NoncopyableFunction&&);
     46    void dispatch(NoncopyableFunction<void ()>&&);
    4747    void close();
    4848

  • trunk/Source/WebKit/Storage/StorageThread.cpp

    r201482 r201493  
    7575}
    7676
    77 void StorageThread::dispatch(NoncopyableFunction&& function)
     77void StorageThread::dispatch(NoncopyableFunction<void ()>&& function)
    7878{
    7979    ASSERT(isMainThread());
    8080    ASSERT(!m_queue.killed() && m_threadID);
    81     m_queue.append(std::make_unique<NoncopyableFunction>(WTFMove(function)));
     81    m_queue.append(std::make_unique<NoncopyableFunction<void ()>>(WTFMove(function)));
    8282}
    8383
    … …  
    9191        return;
    9292
    93     m_queue.append(std::make_unique<NoncopyableFunction>([this] {
     93    m_queue.append(std::make_unique<NoncopyableFunction<void ()>>([this] {
    9494        performTerminate();
    9595    }));

  • trunk/Source/WebKit/Storage/StorageThread.h

    r201482 r201493  
    4747    void terminate();
    4848
    49     void dispatch(NoncopyableFunction&&);
     49    void dispatch(NoncopyableFunction<void ()>&&);
    5050
    5151    static void releaseFastMallocFreeMemoryInAllThreads();
    … …  
    6060
    6161    ThreadIdentifier m_threadID;
    62     MessageQueue<NoncopyableFunction> m_queue;
     62    MessageQueue<NoncopyableFunction<void ()>> m_queue;
    6363};
    6464

  • trunk/Source/WebKit2/ChangeLog

    r201492 r201493  
     12016-05-28  Chris Dumez  <cdumez@apple.com>
     2
     3        Templatize NoncopyableFunction class similarly to std::function
     4        https://bugs.webkit.org/show_bug.cgi?id=158185
     5
     6        Reviewed by Darin Adler.
     7
     8        Templatize NoncopyableFunction class similarly to std::function, so
     9        that it can be used as a std::function replacement in more places.
     10
     11        Previously, NoncopyableFunction could only support "void()" lambdas.
     12
     13        * NetworkProcess/cache/NetworkCacheIOChannelSoup.cpp:
     14        (WebKit::NetworkCache::runTaskInQueue):
     15
    1162016-05-28  Alexey Proskuryakov  <ap@apple.com>
    217

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheIOChannelSoup.cpp

    r201484 r201493  
    7070}
    7171
    72 static inline void runTaskInQueue(NoncopyableFunction&& task, WorkQueue* queue)
     72static inline void runTaskInQueue(NoncopyableFunction<void ()>&& task, WorkQueue* queue)
    7373{
    7474    if (queue) {
Note: See TracChangeset for help on using the changeset viewer.