Changeset 201673 in webkit


Ignore:
Timestamp:
Jun 3, 2016 5:56:57 PM (8 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r201663.
​https://bugs.webkit.org/show_bug.cgi?id=158374

Broke the Windows build (Requested by andersca on #webkit).

Reverted changeset:

"Rename NoncopyableFunction to Function"
​https://bugs.webkit.org/show_bug.cgi?id=158354
​http://trac.webkit.org/changeset/201663

Location:
trunk/Source
Files:
55 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r201663 r201673  
     12016-06-03  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r201663.
     4        https://bugs.webkit.org/show_bug.cgi?id=158374
     5
     6        Broke the Windows build (Requested by andersca on #webkit).
     7
     8        Reverted changeset:
     9
     10        "Rename NoncopyableFunction to Function"
     11        https://bugs.webkit.org/show_bug.cgi?id=158354
     12        http://trac.webkit.org/changeset/201663
     13
    1142016-06-03  Anders Carlsson  <andersca@apple.com>
    215

  • trunk/Source/WTF/WTF.xcodeproj/project.pbxproj

    r201663 r201673  
    119119                8134013815B092FD001FF0B8 /* Base64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8134013615B092FD001FF0B8 /* Base64.cpp */; };
    120120                8134013915B092FD001FF0B8 /* Base64.h in Headers */ = {isa = PBXBuildFile; fileRef = 8134013715B092FD001FF0B8 /* Base64.h */; };
    121                 83F2BADF1CF9524E003E99C3 /* Function.h in Headers */ = {isa = PBXBuildFile; fileRef = 83F2BADE1CF9524E003E99C3 /* Function.h */; };
     121                83F2BADF1CF9524E003E99C3 /* NoncopyableFunction.h in Headers */ = {isa = PBXBuildFile; fileRef = 83F2BADE1CF9524E003E99C3 /* NoncopyableFunction.h */; };
    122122                83FBA93219DF459700F30ADB /* TypeCasts.h in Headers */ = {isa = PBXBuildFile; fileRef = 83FBA93119DF459700F30ADB /* TypeCasts.h */; };
    123123                86F46F611A2840EE00CCBF22 /* RefCounter.h in Headers */ = {isa = PBXBuildFile; fileRef = 86F46F5F1A2840EE00CCBF22 /* RefCounter.h */; };
    … …  
    448448                8134013615B092FD001FF0B8 /* Base64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Base64.cpp; sourceTree = "<group>"; };
    449449                8134013715B092FD001FF0B8 /* Base64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Base64.h; sourceTree = "<group>"; };
    450                 83F2BADE1CF9524E003E99C3 /* Function.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Function.h; sourceTree = "<group>"; };
     450                83F2BADE1CF9524E003E99C3 /* NoncopyableFunction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NoncopyableFunction.h; sourceTree = "<group>"; };
    451451                83FBA93119DF459700F30ADB /* TypeCasts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TypeCasts.h; sourceTree = "<group>"; };
    452452                86F46F5F1A2840EE00CCBF22 /* RefCounter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RefCounter.h; sourceTree = "<group>"; };
    … …  
    841841                                0F2B66A517B6B4F700A7AE3F /* FlipBytes.h */,
    842842                                A8A472A6151A825A004123FF /* Forward.h */,
    843                                 83F2BADE1CF9524E003E99C3 /* Function.h */,
    844843                                1A1D8B9D1731879800141DA4 /* FunctionDispatcher.cpp */,
    845844                                1A1D8B9B173186CE00141DA4 /* FunctionDispatcher.h */,
    … …  
    888887                                0F0D85B317234CB100338210 /* NoLock.h */,
    889888                                A8A472D0151A825B004123FF /* Noncopyable.h */,
     889                                83F2BADE1CF9524E003E99C3 /* NoncopyableFunction.h */,
    890890                                A8A472D5151A825B004123FF /* NumberOfCores.cpp */,
    891891                                A8A472D6151A825B004123FF /* NumberOfCores.h */,
    … …  
    12511251                                A8A473DA151A825B004123FF /* HashTraits.h in Headers */,
    12521252                                A8A473DB151A825B004123FF /* HexNumber.h in Headers */,
    1253                                 83F2BADF1CF9524E003E99C3 /* Function.h in Headers */,
     1253                                83F2BADF1CF9524E003E99C3 /* NoncopyableFunction.h in Headers */,
    12541254                                2684D4361C000D400081D663 /* IndexSparseSet.h in Headers */,
    12551255                                A8A473DC151A825B004123FF /* InlineASM.h in Headers */,

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

    r201663 r201673  
    2727
    2828#include <wtf/CrossThreadCopier.h>
    29 #include <wtf/Function.h>
     29#include <wtf/NoncopyableFunction.h>
    3030#include <wtf/StdLibExtras.h>
    3131
    … …  
    3636    CrossThreadTask() = default;
    3737
    38     CrossThreadTask(Function<void ()>&& taskFunction)
     38    CrossThreadTask(NoncopyableFunction<void ()>&& taskFunction)
    3939        : m_taskFunction(WTFMove(taskFunction))
    4040    {
    … …  
    4848
    4949protected:
    50     Function<void ()> m_taskFunction;
     50    NoncopyableFunction<void ()> m_taskFunction;
    5151};
    5252

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

    r201663 r201673  
    2828
    2929#include <functional>
    30 #include <wtf/Function.h>
     30#include <wtf/NoncopyableFunction.h>
    3131#include <wtf/ThreadSafeRefCounted.h>
    3232
    … …  
    4040    WTF_EXPORT_PRIVATE virtual ~FunctionDispatcher();
    4141
    42     virtual void dispatch(Function<void ()>&&) = 0;
     42    virtual void dispatch(NoncopyableFunction<void ()>&&) = 0;
    4343
    4444protected:

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

    r201663 r201673  
    4848static StaticLock mainThreadFunctionQueueMutex;
    4949
    50 static Deque<Function<void ()>>& functionQueue()
    51 {
    52     static NeverDestroyed<Deque<Function<void ()>>> 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     Function<void ()> function;
     123    NoncopyableFunction<void ()> function;
    124124
    125125    while (true) {
    … …  
    145145}
    146146
    147 void callOnMainThread(Function<void ()>&& function)
     147void callOnMainThread(NoncopyableFunction<void ()>&& function)
    148148{
    149149    ASSERT(function);

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

    r201663 r201673  
    3333#include <functional>
    3434#include <stdint.h>
    35 #include <wtf/Function.h>
     35#include <wtf/NoncopyableFunction.h>
    3636
    3737namespace WTF {
    … …  
    4242WTF_EXPORT_PRIVATE void initializeMainThread();
    4343
    44 WTF_EXPORT_PRIVATE void callOnMainThread(Function<void ()>&&);
     44WTF_EXPORT_PRIVATE void callOnMainThread(NoncopyableFunction<void ()>&&);
    4545
    4646#if PLATFORM(COCOA)

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

    r201672 r201673  
    3131namespace WTF {
    3232
    33 template<typename> class Function;
     33template<typename> class NoncopyableFunction;
    3434
    3535template <typename Out, typename... In>
    36 class Function<Out(In...)> {
     36class NoncopyableFunction<Out(In...)> {
    3737public:
    38     Function() = default;
     38    NoncopyableFunction() = default;
    3939
    4040    template<typename CallableType, class = typename std::enable_if<std::is_rvalue_reference<CallableType&&>::value>::type>
    41     Function(CallableType&& callable)
     41    NoncopyableFunction(CallableType&& callable)
    4242        : m_callableWrapper(std::make_unique<CallableWrapper<CallableType>>(WTFMove(callable)))
    4343    {
    … …  
    5454
    5555    template<typename CallableType, class = typename std::enable_if<std::is_rvalue_reference<CallableType&&>::value>::type>
    56     Function& operator=(CallableType&& callable)
     56    NoncopyableFunction& operator=(CallableType&& callable)
    5757    {
    5858        m_callableWrapper = std::make_unique<CallableWrapper<CallableType>>(WTFMove(callable));
    … …  
    6060    }
    6161
    62     Function& operator=(std::nullptr_t)
     62    NoncopyableFunction& operator=(std::nullptr_t)
    6363    {
    6464        m_callableWrapper = nullptr;
    … …  
    9797} // namespace WTF
    9898
    99 using WTF::Function;
     99using WTF::NoncopyableFunction;

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

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

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

    r201663 r201673  
    6060    ~RunLoop();
    6161
    62     void dispatch(Function<void ()>&&) 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, Function<void ()>&&);
     82    WTF_EXPORT_PRIVATE void dispatchAfter(std::chrono::nanoseconds, NoncopyableFunction<void ()>&&);
    8383#endif
    8484
    … …  
    156156
    157157    Mutex m_functionQueueLock;
    158     Deque<Function<void ()>> m_functionQueue;
     158    Deque<NoncopyableFunction<void ()>> m_functionQueue;
    159159
    160160#if USE(WINDOWS_EVENT_LOOP)

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

    r201663 r201673  
    7373    virtual ~WorkQueue();
    7474
    75     WTF_EXPORT_PRIVATE void dispatch(Function<void ()>&&) override;
    76     WTF_EXPORT_PRIVATE void dispatchAfter(std::chrono::nanoseconds, Function<void ()>&&);
     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

    r201663 r201673  
    2929namespace WTF {
    3030
    31 void WorkQueue::dispatch(Function<void ()>&& function)
     31void WorkQueue::dispatch(NoncopyableFunction<void ()>&& function)
    3232{
    3333    ref();
    34     auto* functionPtr = new Function<void ()>(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, Function<void ()>&& function)
     42void WorkQueue::dispatchAfter(std::chrono::nanoseconds duration, NoncopyableFunction<void ()>&& function)
    4343{
    4444    ref();
    45     auto* functionPtr = new Function<void ()>(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

    r201663 r201673  
    3535class WorkItem {
    3636public:
    37     WorkItem(Ref<WorkQueue>&& workQueue, Function<void ()>&& 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     Function<void ()> m_function;
     47    NoncopyableFunction<void ()> m_function;
    4848};
    4949
    5050class TimerWorkItem : public WorkItem {
    5151public:
    52     static std::unique_ptr<TimerWorkItem> create(Ref<WorkQueue>&& workQueue, Function<void ()>&& 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, Function<void ()>&& 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

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

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

    r201663 r201673  
    3333WTF_MAKE_NONCOPYABLE(ScheduledTask);
    3434public:
    35     static RefPtr<ScheduledTask> create(Function<void ()>&& 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(Function<void ()>&& 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     Function<void ()> 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, Function<void ()>&& function)
     240void RunLoop::dispatchAfter(std::chrono::nanoseconds delay, NoncopyableFunction<void ()>&& function)
    241241{
    242242    LockHolder locker(m_loopLock);

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

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

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

    r201663 r201673  
    125125    WTF_MAKE_FAST_ALLOCATED;
    126126public:
    127     DispatchAfterContext(Function<void ()>&& function)
     127    DispatchAfterContext(NoncopyableFunction<void ()>&& function)
    128128        : m_function(WTFMove(function))
    129129    {
    … …  
    136136
    137137private:
    138     Function<void ()> m_function;
     138    NoncopyableFunction<void ()> m_function;
    139139};
    140140
    141 void RunLoop::dispatchAfter(std::chrono::nanoseconds duration, Function<void ()>&& 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

    r201663 r201673  
    3333namespace WTF {
    3434
    35 WorkItemWin::WorkItemWin(Function<void ()>&& 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(Function<void ()>&& 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, Function<void ()>&& 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, Function<void ()>&& 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

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

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

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

  • trunk/Source/WebCore/ChangeLog

    r201667 r201673  
     12016-06-03  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r201663.
     4        https://bugs.webkit.org/show_bug.cgi?id=158374
     5
     6        Broke the Windows build (Requested by andersca on #webkit).
     7
     8        Reverted changeset:
     9
     10        "Rename NoncopyableFunction to Function"
     11        https://bugs.webkit.org/show_bug.cgi?id=158354
     12        http://trac.webkit.org/changeset/201663
     13
    1142016-06-03  Ryosuke Niwa  <rniwa@webkit.org>
    215

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

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

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

    r201663 r201673  
    3838#include "PeerConnectionBackend.h"
    3939#include "RTCSessionDescription.h"
    40 #include <wtf/Function.h>
     40#include <wtf/NoncopyableFunction.h>
    4141#include <wtf/RefPtr.h>
    4242
    … …  
    8080
    8181private:
    82     void runTask(Function<void ()>&&);
     82    void runTask(NoncopyableFunction<void ()>&&);
    8383    void startRunningTasks();
    8484
    … …  
    9494    std::unique_ptr<MediaEndpoint> m_mediaEndpoint;
    9595
    96     Function<void ()> m_initialDeferredTask;
     96    NoncopyableFunction<void ()> m_initialDeferredTask;
    9797
    9898    std::unique_ptr<SDPProcessor> m_sdpProcessor;

  • trunk/Source/WebCore/Modules/webaudio/AudioDestinationNode.h

    r201663 r201673  
    3131#include "AudioNode.h"
    3232#include "AudioSourceProvider.h"
    33 #include <wtf/Function.h>
     33#include <wtf/NoncopyableFunction.h>
    3434
    3535namespace WebCore {
    … …  
    6060
    6161    virtual void startRendering() = 0;
    62     virtual void resume(Function<void ()>&&) { }
    63     virtual void suspend(Function<void ()>&&) { }
    64     virtual void close(Function<void ()>&&) { }
     62    virtual void resume(NoncopyableFunction<void ()>&&) { }
     63    virtual void suspend(NoncopyableFunction<void ()>&&) { }
     64    virtual void close(NoncopyableFunction<void ()>&&) { }
    6565
    6666    virtual bool isPlaying() { return false; }

  • trunk/Source/WebCore/Modules/webaudio/DefaultAudioDestinationNode.cpp

    r201663 r201673  
    107107}
    108108
    109 void DefaultAudioDestinationNode::resume(Function<void ()>&& function)
     109void DefaultAudioDestinationNode::resume(NoncopyableFunction<void ()>&& function)
    110110{
    111111    ASSERT(isInitialized());
    … …  
    116116}
    117117
    118 void DefaultAudioDestinationNode::suspend(Function<void ()>&& function)
     118void DefaultAudioDestinationNode::suspend(NoncopyableFunction<void ()>&& function)
    119119{
    120120    ASSERT(isInitialized());
    … …  
    125125}
    126126
    127 void DefaultAudioDestinationNode::close(Function<void()>&& function)
     127void DefaultAudioDestinationNode::close(NoncopyableFunction<void()>&& function)
    128128{
    129129    ASSERT(isInitialized());

  • trunk/Source/WebCore/Modules/webaudio/DefaultAudioDestinationNode.h

    r201663 r201673  
    5151    void enableInput(const String& inputDeviceId) override;
    5252    void startRendering() override;
    53     void resume(Function<void ()>&&) override;
    54     void suspend(Function<void ()>&&) override;
    55     void close(Function<void ()>&&) override;
     53    void resume(NoncopyableFunction<void ()>&&) override;
     54    void suspend(NoncopyableFunction<void ()>&&) override;
     55    void close(NoncopyableFunction<void ()>&&) override;
    5656    unsigned long maxChannelCount() const override;
    5757    bool isPlaying() override;

  • trunk/Source/WebCore/dom/ActiveDOMCallbackMicrotask.cpp

    r201663 r201673  
    2929namespace WebCore {
    3030
    31 ActiveDOMCallbackMicrotask::ActiveDOMCallbackMicrotask(MicrotaskQueue& queue, ScriptExecutionContext& scriptExecutionContext, Function<void()>&& task)
     31ActiveDOMCallbackMicrotask::ActiveDOMCallbackMicrotask(MicrotaskQueue& queue, ScriptExecutionContext& scriptExecutionContext, NoncopyableFunction<void()>&& task)
    3232    : ActiveDOMCallback(&scriptExecutionContext)
    3333    , m_queue(queue)

  • trunk/Source/WebCore/dom/ActiveDOMCallbackMicrotask.h

    r201663 r201673  
    2828#include "ActiveDOMCallback.h"
    2929#include "Microtasks.h"
    30 #include <wtf/Function.h>
     30#include <wtf/NoncopyableFunction.h>
    3131
    3232namespace WebCore {
    … …  
    3535    WTF_MAKE_FAST_ALLOCATED;
    3636public:
    37     WEBCORE_EXPORT ActiveDOMCallbackMicrotask(MicrotaskQueue&, ScriptExecutionContext&, Function<void()>&&);
     37    WEBCORE_EXPORT ActiveDOMCallbackMicrotask(MicrotaskQueue&, ScriptExecutionContext&, NoncopyableFunction<void()>&&);
    3838    WEBCORE_EXPORT virtual ~ActiveDOMCallbackMicrotask();
    3939
    … …  
    4747    // queue.
    4848    MicrotaskQueue& m_queue;
    49     Function<void()> m_task;
     49    NoncopyableFunction<void()> m_task;
    5050};
    5151

  • trunk/Source/WebCore/dom/ScriptExecutionContext.h

    r201663 r201673  
    3636#include <wtf/CrossThreadTask.h>
    3737#include <wtf/HashSet.h>
    38 #include <wtf/Function.h>
     38#include <wtf/NoncopyableFunction.h>
    3939
    4040namespace JSC {
    … …  
    134134        enum CleanupTaskTag { CleanupTask };
    135135
    136         template<typename T, typename = typename std::enable_if<!std::is_base_of<Task, T>::value && std::is_convertible<T, Function<void (ScriptExecutionContext&)>>::value>::type>
     136        template<typename T, typename = typename std::enable_if<!std::is_base_of<Task, T>::value && std::is_convertible<T, NoncopyableFunction<void (ScriptExecutionContext&)>>::value>::type>
    137137        Task(T task)
    138138            : m_task(WTFMove(task))
    … …  
    141141        }
    142142
    143         Task(Function<void ()>&& task)
     143        Task(NoncopyableFunction<void ()>&& task)
    144144            : m_task([task = WTFMove(task)](ScriptExecutionContext&) { task(); })
    145145            , m_isCleanupTask(false)
    … …  
    147147        }
    148148
    149         template<typename T, typename = typename std::enable_if<std::is_convertible<T, Function<void (ScriptExecutionContext&)>>::value>::type>
     149        template<typename T, typename = typename std::enable_if<std::is_convertible<T, NoncopyableFunction<void (ScriptExecutionContext&)>>::value>::type>
    150150        Task(CleanupTaskTag, T task)
    151151            : m_task(WTFMove(task))
    … …  
    164164
    165165    protected:
    166         Function<void (ScriptExecutionContext&)> m_task;
     166        NoncopyableFunction<void (ScriptExecutionContext&)> m_task;
    167167        bool m_isCleanupTask;
    168168    };

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

    r201663 r201673  
    4040#include <wtf/MessageQueue.h>
    4141#include <wtf/NeverDestroyed.h>
    42 #include <wtf/Function.h>
     42#include <wtf/NoncopyableFunction.h>
    4343
    4444namespace WebCore {
    … …  
    6565}
    6666
    67 static void callOnFileThread(Function<void ()>&& function)
     67static void callOnFileThread(NoncopyableFunction<void ()>&& function)
    6868{
    6969    ASSERT(isMainThread());
    7070    ASSERT(function);
    7171
    72     static NeverDestroyed<MessageQueue<Function<void ()>>> queue;
     72    static NeverDestroyed<MessageQueue<NoncopyableFunction<void ()>>> queue;
    7373
    7474    static std::once_flag createFileThreadOnce;
    … …  
    9191    });
    9292
    93     queue.get().append(std::make_unique<Function<void ()>>(WTFMove(function)));
     93    queue.get().append(std::make_unique<NoncopyableFunction<void ()>>(WTFMove(function)));
    9494}
    9595
    … …  
    115115}
    116116
    117 void AsyncFileStream::perform(Function<std::function<void(FileStreamClient&)>(FileStream&)>&& operation)
     117void AsyncFileStream::perform(NoncopyableFunction<std::function<void(FileStreamClient&)>(FileStream&)>&& operation)
    118118{
    119119    auto& internals = *m_internals;

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

    r201663 r201673  
    3535#include <functional>
    3636#include <wtf/Forward.h>
    37 #include <wtf/Function.h>
     37#include <wtf/NoncopyableFunction.h>
    3838
    3939namespace WebCore {
    … …  
    5858private:
    5959    void start();
    60     void perform(Function<std::function<void(FileStreamClient&)>(FileStream&)>&&);
     60    void perform(NoncopyableFunction<std::function<void(FileStreamClient&)>(FileStream&)>&&);
    6161
    6262    struct Internals;

  • trunk/Source/WebCore/page/FrameView.cpp

    r201663 r201673  
    31343134}
    31353135
    3136 void FrameView::queuePostLayoutCallback(Function<void()>&& callback)
     3136void FrameView::queuePostLayoutCallback(NoncopyableFunction<void()>&& callback)
    31373137{
    31383138    m_postLayoutCallbackQueue.append(WTFMove(callback));
    … …  
    31473147        return;
    31483148
    3149     Vector<Function<void()>> queue = WTFMove(m_postLayoutCallbackQueue);
     3149    Vector<NoncopyableFunction<void()>> queue = WTFMove(m_postLayoutCallbackQueue);
    31503150    for (auto& task : queue)
    31513151        task();

  • trunk/Source/WebCore/page/FrameView.h

    r201663 r201673  
    3838#include <wtf/HashSet.h>
    3939#include <wtf/ListHashSet.h>
    40 #include <wtf/Function.h>
     40#include <wtf/NoncopyableFunction.h>
    4141#include <wtf/text/WTFString.h>
    4242
    … …  
    112112    void scheduleRelayoutOfSubtree(RenderElement&);
    113113    void unscheduleRelayout();
    114     void queuePostLayoutCallback(Function<void()>&&);
     114    void queuePostLayoutCallback(NoncopyableFunction<void()>&&);
    115115    bool layoutPending() const;
    116116    bool isInLayout() const { return m_layoutPhase != OutsideLayout; }
    … …  
    829829
    830830    IntRect* m_cachedWindowClipRect { nullptr };
    831     Vector<Function<void()>> m_postLayoutCallbackQueue;
     831    Vector<NoncopyableFunction<void()>> m_postLayoutCallbackQueue;
    832832};
    833833

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

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

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

    r201663 r201673  
    3434#include <wtf/Lock.h>
    3535#include <wtf/Noncopyable.h>
    36 #include <wtf/Function.h>
     36#include <wtf/NoncopyableFunction.h>
    3737#include <wtf/Threading.h>
    3838#include <wtf/Vector.h>
    … …  
    4949public:
    5050    static bool isCurrentThread();
    51     WEBCORE_EXPORT static void dispatch(Function<void ()>&&);
     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(Function<void ()>&&);
     55    WEBCORE_EXPORT static void dispatchBarrier(NoncopyableFunction<void ()>&&);
    5656
    5757private:
    … …  
    8181
    8282    Lock m_functionsMutex;
    83     Vector<Function<void ()>> m_functions;
     83    Vector<NoncopyableFunction<void ()>> m_functions;
    8484
    8585#if PLATFORM(COCOA)

  • trunk/Source/WebCore/platform/GenericTaskQueue.cpp

    r201663 r201673  
    3737}
    3838
    39 void TaskDispatcher<Timer>::postTask(Function<void()>&& function)
     39void TaskDispatcher<Timer>::postTask(NoncopyableFunction<void()>&& function)
    4040{
    4141    m_pendingTasks.append(WTFMove(function));

  • trunk/Source/WebCore/platform/GenericTaskQueue.h

    r201663 r201673  
    2828#include "Timer.h"
    2929#include <wtf/Deque.h>
    30 #include <wtf/Function.h>
     30#include <wtf/NoncopyableFunction.h>
    3131#include <wtf/WeakPtr.h>
    3232
    … …  
    4141    }
    4242
    43     void postTask(Function<void()>&& f)
     43    void postTask(NoncopyableFunction<void()>&& f)
    4444    {
    4545        m_context.postTask(WTFMove(f));
    … …  
    5454public:
    5555    TaskDispatcher();
    56     void postTask(Function<void()>&&);
     56    void postTask(NoncopyableFunction<void()>&&);
    5757
    5858private:
    … …  
    6464
    6565    WeakPtrFactory<TaskDispatcher> m_weakPtrFactory;
    66     Deque<Function<void()>> m_pendingTasks;
     66    Deque<NoncopyableFunction<void()>> m_pendingTasks;
    6767};
    6868
    … …  
    8282    }
    8383
    84     typedef Function<void()> TaskFunction;
     84    typedef NoncopyableFunction<void()> TaskFunction;
    8585
    8686    void enqueueTask(TaskFunction&& task)

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

    r201663 r201673  
    3232#include "MediaStreamPrivate.h"
    3333#include <wtf/MediaTime.h>
    34 #include <wtf/Function.h>
     34#include <wtf/NoncopyableFunction.h>
    3535#include <wtf/Vector.h>
    3636#include <wtf/WeakPtr.h>
    … …  
    144144    void renderingModeChanged();
    145145
    146     void scheduleDeferredTask(Function<void ()>&&);
     146    void scheduleDeferredTask(NoncopyableFunction<void ()>&&);
    147147
    148148    enum DisplayMode {

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

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

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

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

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

    r201663 r201673  
    4242#include <wtf/HashMap.h>
    4343#include <wtf/MediaTime.h>
    44 #include <wtf/Function.h>
     44#include <wtf/NoncopyableFunction.h>
    4545#include <wtf/RefCounted.h>
    4646#include <wtf/RefPtr.h>
    … …  
    113113    void updateActiveVideoTrack();
    114114
    115     void scheduleDeferredTask(Function<void ()>&&);
     115    void scheduleDeferredTask(NoncopyableFunction<void ()>&&);
    116116
    117117    WeakPtrFactory<MediaStreamPrivate> m_weakPtrFactory;

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

    r201663 r201673  
    3232#include "RealtimeMediaSource.h"
    3333#include "Timer.h"
    34 #include <wtf/Function.h>
     34#include <wtf/NoncopyableFunction.h>
    3535#include <wtf/RetainPtr.h>
    3636#include <wtf/WeakPtr.h>
    … …  
    8787    void setAudioSampleBufferDelegate(AVCaptureAudioDataOutput*);
    8888
    89     void scheduleDeferredTask(Function<void ()>&&);
     89    void scheduleDeferredTask(NoncopyableFunction<void ()>&&);
    9090
    9191private:

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

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

  • trunk/Source/WebCore/style/StyleTreeResolver.cpp

    r201663 r201673  
    522522}
    523523
    524 static Vector<Function<void ()>>& postResolutionCallbackQueue()
    525 {
    526     static NeverDestroyed<Vector<Function<void ()>>> vector;
     524static Vector<NoncopyableFunction<void ()>>& postResolutionCallbackQueue()
     525{
     526    static NeverDestroyed<Vector<NoncopyableFunction<void ()>>> vector;
    527527    return vector;
    528528}
    529529
    530 void queuePostResolutionCallback(Function<void ()>&& callback)
     530void queuePostResolutionCallback(NoncopyableFunction<void ()>&& callback)
    531531{
    532532    postResolutionCallbackQueue().append(WTFMove(callback));

  • trunk/Source/WebCore/style/StyleTreeResolver.h

    r201663 r201673  
    3535#include <functional>
    3636#include <wtf/HashMap.h>
    37 #include <wtf/Function.h>
     37#include <wtf/NoncopyableFunction.h>
    3838#include <wtf/RefPtr.h>
    3939
    … …  
    111111};
    112112
    113 void queuePostResolutionCallback(Function<void ()>&&);
     113void queuePostResolutionCallback(NoncopyableFunction<void ()>&&);
    114114bool postResolutionCallbacksAreSuspended();
    115115

  • trunk/Source/WebKit/ChangeLog

    r201663 r201673  
     12016-06-03  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r201663.
     4        https://bugs.webkit.org/show_bug.cgi?id=158374
     5
     6        Broke the Windows build (Requested by andersca on #webkit).
     7
     8        Reverted changeset:
     9
     10        "Rename NoncopyableFunction to Function"
     11        https://bugs.webkit.org/show_bug.cgi?id=158354
     12        http://trac.webkit.org/changeset/201663
     13
    1142016-06-03  Anders Carlsson  <andersca@apple.com>
    215

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

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

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

    r201663 r201673  
    2929#include <functional>
    3030#include <wtf/Forward.h>
    31 #include <wtf/Function.h>
     31#include <wtf/NoncopyableFunction.h>
    3232#include <wtf/PassRefPtr.h>
    3333#include <wtf/RefCounted.h>
    … …  
    4444    ~StorageSyncManager();
    4545
    46     void dispatch(Function<void ()>&&);
     46    void dispatch(NoncopyableFunction<void ()>&&);
    4747    void close();
    4848

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

    r201663 r201673  
    7575}
    7676
    77 void StorageThread::dispatch(Function<void ()>&& 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<Function<void ()>>(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<Function<void ()>>([this] {
     93    m_queue.append(std::make_unique<NoncopyableFunction<void ()>>([this] {
    9494        performTerminate();
    9595    }));

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

    r201663 r201673  
    2727#define StorageThread_h
    2828
    29 #include <wtf/Function.h>
     29#include <functional>
    3030#include <wtf/HashSet.h>
    3131#include <wtf/MessageQueue.h>
     32#include <wtf/NoncopyableFunction.h>
    3233#include <wtf/Threading.h>
    3334
    … …  
    4647    void terminate();
    4748
    48     void dispatch(Function<void ()>&&);
     49    void dispatch(NoncopyableFunction<void ()>&&);
    4950
    5051    static void releaseFastMallocFreeMemoryInAllThreads();
    … …  
    5960
    6061    ThreadIdentifier m_threadID;
    61     MessageQueue<Function<void ()>> m_queue;
     62    MessageQueue<NoncopyableFunction<void ()>> m_queue;
    6263};
    6364

  • trunk/Source/WebKit2/ChangeLog

    r201663 r201673  
     12016-06-03  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r201663.
     4        https://bugs.webkit.org/show_bug.cgi?id=158374
     5
     6        Broke the Windows build (Requested by andersca on #webkit).
     7
     8        Reverted changeset:
     9
     10        "Rename NoncopyableFunction to Function"
     11        https://bugs.webkit.org/show_bug.cgi?id=158354
     12        http://trac.webkit.org/changeset/201663
     13
    1142016-06-03  Anders Carlsson  <andersca@apple.com>
    215

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

    r201663 r201673  
    309309}
    310310
    311 static void fetchDiskCacheEntries(SessionID sessionID, OptionSet<WebsiteDataFetchOption> fetchOptions, Function<void (Vector<WebsiteData::Entry>)>&& completionHandler)
     311static void fetchDiskCacheEntries(SessionID sessionID, OptionSet<WebsiteDataFetchOption> fetchOptions, NoncopyableFunction<void (Vector<WebsiteData::Entry>)>&& completionHandler)
    312312{
    313313#if ENABLE(NETWORK_CACHE)
    … …  
    353353{
    354354    struct CallbackAggregator final : public RefCounted<CallbackAggregator> {
    355         explicit CallbackAggregator(Function<void (WebsiteData)>&& completionHandler)
     355        explicit CallbackAggregator(NoncopyableFunction<void (WebsiteData)>&& completionHandler)
    356356            : m_completionHandler(WTFMove(completionHandler))
    357357        {
    … …  
    367367        }
    368368
    369         Function<void (WebsiteData)> m_completionHandler;
     369        NoncopyableFunction<void (WebsiteData)> m_completionHandler;
    370370        WebsiteData m_websiteData;
    371371    };
    … …  
    413413}
    414414
    415 static void clearDiskCacheEntries(const Vector<SecurityOriginData>& origins, Function<void ()>&& completionHandler)
     415static void clearDiskCacheEntries(const Vector<SecurityOriginData>& origins, NoncopyableFunction<void ()>&& completionHandler)
    416416{
    417417#if ENABLE(NETWORK_CACHE)

  • trunk/Source/WebKit2/NetworkProcess/NetworkProcess.h

    r201663 r201673  
    3636#include <memory>
    3737#include <wtf/Forward.h>
    38 #include <wtf/Function.h>
    3938#include <wtf/NeverDestroyed.h>
     39#include <wtf/NoncopyableFunction.h>
    4040#include <wtf/RetainPtr.h>
    4141

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

    r201663 r201673  
    522522}
    523523
    524 void Cache::traverse(Function<void (const TraversalEntry*)>&& traverseHandler)
     524void Cache::traverse(NoncopyableFunction<void (const TraversalEntry*)>&& traverseHandler)
    525525{
    526526    ASSERT(isEnabled());

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCache.h

    r201663 r201673  
    3333#include "ShareableResource.h"
    3434#include <WebCore/ResourceResponse.h>
    35 #include <wtf/Function.h>
     35#include <wtf/NoncopyableFunction.h>
    3636#include <wtf/text/WTFString.h>
    3737
    … …  
    115115        const Storage::RecordInfo& recordInfo;
    116116    };
    117     void traverse(Function<void (const TraversalEntry*)>&&);
     117    void traverse(NoncopyableFunction<void (const TraversalEntry*)>&&);
    118118    void remove(const Key&);
    119119    void remove(const WebCore::ResourceRequest&);

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

    r201663 r201673  
    7070}
    7171
    72 static inline void runTaskInQueue(Function<void ()>&& task, WorkQueue* queue)
     72static inline void runTaskInQueue(NoncopyableFunction<void ()>&& task, WorkQueue* queue)
    7373{
    7474    if (queue) {

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheStorage.h

    r201663 r201673  
    3636#include <wtf/Deque.h>
    3737#include <wtf/HashSet.h>
    38 #include <wtf/Function.h>
     38#include <wtf/NoncopyableFunction.h>
    3939#include <wtf/Optional.h>
    4040#include <wtf/WorkQueue.h>
    … …  
    8080    };
    8181    typedef unsigned TraverseFlags;
    82     typedef Function<void (const Record*, const RecordInfo&)> TraverseHandler;
     82    typedef NoncopyableFunction<void (const Record*, const RecordInfo&)> TraverseHandler;
    8383    // Null record signals end.
    8484    void traverse(const String& type, TraverseFlags, TraverseHandler&&);
Note: See TracChangeset for help on using the changeset viewer.