Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 659 insertions, 0 deletions

diff --git a/vcl/source/app/scheduler.cxx b/vcl/source/app/scheduler.cxx
new file mode 100644
index 000000000..aa716f88b
--- /dev/null
+++ b/vcl/source/app/scheduler.cxx
@@ -0,0 +1,659 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <cassert>
+#include <cstdlib>
+#include <exception>
+#include <typeinfo>
+
+#include <com/sun/star/uno/Exception.hpp>
+#include <sal/log.hxx>
+#include <sal/types.h>
+#include <svdata.hxx>
+#include <tools/time.hxx>
+#include <tools/debug.hxx>
+#include <tools/diagnose_ex.h>
+#include <unotools/configmgr.hxx>
+#include <vcl/TaskStopwatch.hxx>
+#include <vcl/scheduler.hxx>
+#include <vcl/idle.hxx>
+#include <saltimer.hxx>
+#include <salinst.hxx>
+#include <comphelper/profilezone.hxx>
+#include <schedulerimpl.hxx>
+
+namespace {
+
+template< typename charT, typename traits >
+std::basic_ostream<charT, traits> & operator <<(
+    std::basic_ostream<charT, traits> & stream, const Task& task )
+{
+    stream << "a: " << task.IsActive() << " p: " << static_cast<int>(task.GetPriority());
+    const char *name = task.GetDebugName();
+    if( nullptr == name )
+        return stream << " (nullptr)";
+    else
+        return stream << " " << name;
+}
+
+/**
+ * clang won't compile this in the Timer.hxx header, even with a class Idle
+ * forward definition, due to the incomplete Idle type in the template.
+ * Currently the code is just used in the Scheduler, so we keep it local.
+ *
+ * @see http://clang.llvm.org/compatibility.html#undep_incomplete
+ */
+template< typename charT, typename traits >
+std::basic_ostream<charT, traits> & operator <<(
+    std::basic_ostream<charT, traits> & stream, const Timer& timer )
+{
+    bool bIsIdle = (dynamic_cast<const Idle*>( &timer ) != nullptr);
+    stream << (bIsIdle ? "Idle " : "Timer")
+           << " a: " << timer.IsActive() << " p: " << static_cast<int>(timer.GetPriority());
+    const char *name = timer.GetDebugName();
+    if ( nullptr == name )
+        stream << " (nullptr)";
+    else
+        stream << " " << name;
+    if ( !bIsIdle )
+        stream << " " << timer.GetTimeout() << "ms";
+    stream << " (" << &timer << ")";
+    return stream;
+}
+
+template< typename charT, typename traits >
+std::basic_ostream<charT, traits> & operator <<(
+    std::basic_ostream<charT, traits> & stream, const Idle& idle )
+{
+    return stream << static_cast<const Timer*>( &idle );
+}
+
+template< typename charT, typename traits >
+std::basic_ostream<charT, traits> & operator <<(
+    std::basic_ostream<charT, traits> & stream, const ImplSchedulerData& data )
+{
+    stream << " i: " << data.mbInScheduler;
+    return stream;
+}
+
+} // end anonymous namespace
+
+unsigned int TaskStopwatch::m_nTimeSlice = TaskStopwatch::nDefaultTimeSlice;
+
+void Scheduler::ImplDeInitScheduler()
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    assert( pSVData != nullptr );
+    ImplSchedulerContext &rSchedCtx = pSVData->maSchedCtx;
+
+    DBG_TESTSOLARMUTEX();
+
+    SchedulerGuard aSchedulerGuard;
+
+    int nTaskPriority = 0;
+#if OSL_DEBUG_LEVEL > 0
+    sal_uInt32 nTasks = 0;
+    for (nTaskPriority = 0; nTaskPriority < PRIO_COUNT; ++nTaskPriority)
+    {
+        ImplSchedulerData* pSchedulerData = rSchedCtx.mpFirstSchedulerData[nTaskPriority];
+        while ( pSchedulerData )
+        {
+            ++nTasks;
+            pSchedulerData = pSchedulerData->mpNext;
+        }
+    }
+    SAL_INFO( "vcl.schedule.deinit",
+              "DeInit the scheduler - pending tasks: " << nTasks );
+
+    // clean up all the sfx::SfxItemDisruptor_Impl Idles
+    ProcessEventsToIdle();
+#endif
+    rSchedCtx.mbActive = false;
+
+    assert( nullptr == rSchedCtx.mpSchedulerStack );
+    assert( 1 == rSchedCtx.maMutex.lockDepth() );
+
+    if (rSchedCtx.mpSalTimer) rSchedCtx.mpSalTimer->Stop();
+    DELETEZ( rSchedCtx.mpSalTimer );
+
+#if OSL_DEBUG_LEVEL > 0
+    sal_uInt32 nActiveTasks = 0, nIgnoredTasks = 0;
+#endif
+    nTaskPriority = 0;
+    ImplSchedulerData* pSchedulerData = nullptr;
+
+next_priority:
+    pSchedulerData = rSchedCtx.mpFirstSchedulerData[nTaskPriority];
+    while ( pSchedulerData )
+    {
+        Task *pTask = pSchedulerData->mpTask;
+        if ( pTask )
+        {
+            if ( pTask->mbActive )
+            {
+#if OSL_DEBUG_LEVEL > 0
+                const char *sIgnored = "";
+                ++nActiveTasks;
+                // TODO: shutdown these timers before Scheduler de-init
+                // TODO: remove Task from static object
+                if ( pTask->GetDebugName() && ( false
+                        || !strcmp( pTask->GetDebugName(), "desktop::Desktop m_firstRunTimer" )
+                        || !strcmp( pTask->GetDebugName(), "DrawWorkStartupTimer" )
+                        || !strcmp( pTask->GetDebugName(), "editeng::ImpEditEngine aOnlineSpellTimer" )
+                        || !strcmp( pTask->GetDebugName(), "ImplHandleMouseMsg SalData::mpMouseLeaveTimer" )
+                        || !strcmp( pTask->GetDebugName(), "sc ScModule IdleTimer" )
+                        || !strcmp( pTask->GetDebugName(), "sd::CacheConfiguration maReleaseTimer" )
+                        || !strcmp( pTask->GetDebugName(), "svtools::GraphicCache maReleaseTimer" )
+                        || !strcmp( pTask->GetDebugName(), "svtools::GraphicObject mpSwapOutTimer" )
+                        || !strcmp( pTask->GetDebugName(), "svx OLEObjCache pTimer UnloadCheck" )
+                        || !strcmp( pTask->GetDebugName(), "vcl SystemDependentDataBuffer aSystemDependentDataBuffer" )
+                        ))
+                {
+                    sIgnored = " (ignored)";
+                    ++nIgnoredTasks;
+                }
+                const Timer *timer = dynamic_cast<Timer*>( pTask );
+                if ( timer )
+                    SAL_WARN( "vcl.schedule.deinit", "DeInit task: " << *timer << sIgnored );
+                else
+                    SAL_WARN( "vcl.schedule.deinit", "DeInit task: " << *pTask << sIgnored );
+#endif
+                pTask->mbActive = false;
+            }
+            pTask->mpSchedulerData = nullptr;
+            pTask->SetStatic();
+        }
+        ImplSchedulerData* pDeleteSchedulerData = pSchedulerData;
+        pSchedulerData = pSchedulerData->mpNext;
+        delete pDeleteSchedulerData;
+    }
+
+    ++nTaskPriority;
+    if (nTaskPriority < PRIO_COUNT)
+        goto next_priority;
+
+#if OSL_DEBUG_LEVEL > 0
+    SAL_INFO( "vcl.schedule.deinit", "DeInit the scheduler - finished" );
+    SAL_WARN_IF( 0 != nActiveTasks, "vcl.schedule.deinit", "DeInit active tasks: "
+        << nActiveTasks << " (ignored: " << nIgnoredTasks << ")" );
+//    assert( nIgnoredTasks == nActiveTasks );
+#endif
+
+    for (nTaskPriority = 0; nTaskPriority < PRIO_COUNT; ++nTaskPriority)
+    {
+        rSchedCtx.mpFirstSchedulerData[nTaskPriority] = nullptr;
+        rSchedCtx.mpLastSchedulerData[nTaskPriority]  = nullptr;
+    }
+    rSchedCtx.mnTimerPeriod        = InfiniteTimeoutMs;
+}
+
+void SchedulerMutex::acquire( sal_uInt32 nLockCount )
+{
+    assert(nLockCount > 0);
+    for (sal_uInt32 i = 0; i != nLockCount; ++i) {
+        if (!maMutex.acquire())
+            abort();
+    }
+    mnLockDepth += nLockCount;
+}
+
+sal_uInt32 SchedulerMutex::release( bool bUnlockAll )
+{
+    assert(mnLockDepth > 0);
+    const sal_uInt32 nLockCount =
+        (bUnlockAll || 0 == mnLockDepth) ? mnLockDepth : 1;
+    mnLockDepth -= nLockCount;
+    for (sal_uInt32 i = 0; i != nLockCount; ++i) {
+        if (!maMutex.release())
+            abort();
+    }
+    return nLockCount;
+}
+
+void Scheduler::Lock( sal_uInt32 nLockCount )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    assert( pSVData != nullptr );
+    pSVData->maSchedCtx.maMutex.acquire( nLockCount );
+}
+
+sal_uInt32 Scheduler::Unlock( bool bUnlockAll )
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    assert( pSVData != nullptr );
+    return pSVData->maSchedCtx.maMutex.release( bUnlockAll );
+}
+
+/**
+ * Start a new timer if we need to for nMS duration.
+ *
+ * if this is longer than the existing duration we're
+ * waiting for, do nothing - unless bForce - which means
+ * to reset the minimum period; used by the scheduled itself.
+ */
+void Scheduler::ImplStartTimer(sal_uInt64 nMS, bool bForce, sal_uInt64 nTime)
+{
+    ImplSVData* pSVData = ImplGetSVData();
+    ImplSchedulerContext &rSchedCtx = pSVData->maSchedCtx;
+    if ( !rSchedCtx.mbActive )
+        return;
+
+    if (!rSchedCtx.mpSalTimer)
+    {
+        rSchedCtx.mnTimerStart = 0;
+        rSchedCtx.mnTimerPeriod = InfiniteTimeoutMs;
+        rSchedCtx.mpSalTimer = pSVData->mpDefInst->CreateSalTimer();
+        rSchedCtx.mpSalTimer->SetCallback(Scheduler::CallbackTaskScheduling);
+    }
+
+    assert(SAL_MAX_UINT64 - nMS >= nTime);
+
+    sal_uInt64 nProposedTimeout = nTime + nMS;
+    sal_uInt64 nCurTimeout = ( rSchedCtx.mnTimerPeriod == InfiniteTimeoutMs )
+        ? SAL_MAX_UINT64 : rSchedCtx.mnTimerStart + rSchedCtx.mnTimerPeriod;
+
+    // Only if smaller timeout, to avoid skipping.
+    // Force instant wakeup on 0ms, if the previous period was not 0ms
+    if (bForce || nProposedTimeout < nCurTimeout || (!nMS && rSchedCtx.mnTimerPeriod))
+    {
+        SAL_INFO( "vcl.schedule", "  Starting scheduler system timer (" << nMS << "ms)" );
+        rSchedCtx.mnTimerStart = nTime;
+        rSchedCtx.mnTimerPeriod = nMS;
+        rSchedCtx.mpSalTimer->Start( nMS );
+    }
+}
+
+void Scheduler::CallbackTaskScheduling()
+{
+    // this function is for the saltimer callback
+    Scheduler::ProcessTaskScheduling();
+}
+
+static bool g_bDeterministicMode = false;
+
+void Scheduler::SetDeterministicMode(bool bDeterministic)
+{
+    g_bDeterministicMode = bDeterministic;
+}
+
+bool Scheduler::GetDeterministicMode()
+{
+    return g_bDeterministicMode;
+}
+
+inline void Scheduler::UpdateSystemTimer( ImplSchedulerContext &rSchedCtx,
+                                          const sal_uInt64 nMinPeriod,
+                                          const bool bForce, const sal_uInt64 nTime )
+{
+    if ( InfiniteTimeoutMs == nMinPeriod )
+    {
+        SAL_INFO("vcl.schedule", "  Stopping system timer");
+        if ( rSchedCtx.mpSalTimer )
+            rSchedCtx.mpSalTimer->Stop();
+        rSchedCtx.mnTimerPeriod = nMinPeriod;
+    }
+    else
+        Scheduler::ImplStartTimer( nMinPeriod, bForce, nTime );
+}
+
+static void AppendSchedulerData( ImplSchedulerContext &rSchedCtx,
+                                        ImplSchedulerData * const pSchedulerData)
+{
+    assert(pSchedulerData->mpTask);
+    pSchedulerData->mePriority = pSchedulerData->mpTask->GetPriority();
+    pSchedulerData->mpNext = nullptr;
+
+    const int nTaskPriority = static_cast<int>(pSchedulerData->mePriority);
+    if (!rSchedCtx.mpLastSchedulerData[nTaskPriority])
+    {
+        rSchedCtx.mpFirstSchedulerData[nTaskPriority] = pSchedulerData;
+        rSchedCtx.mpLastSchedulerData[nTaskPriority] = pSchedulerData;
+    }
+    else
+    {
+        rSchedCtx.mpLastSchedulerData[nTaskPriority]->mpNext = pSchedulerData;
+        rSchedCtx.mpLastSchedulerData[nTaskPriority] = pSchedulerData;
+    }
+}
+
+static ImplSchedulerData* DropSchedulerData(
+    ImplSchedulerContext &rSchedCtx, ImplSchedulerData * const pPrevSchedulerData,
+    const ImplSchedulerData * const pSchedulerData, const int nTaskPriority)
+{
+    assert( pSchedulerData );
+    if ( pPrevSchedulerData )
+        assert( pPrevSchedulerData->mpNext == pSchedulerData );
+    else
+        assert(rSchedCtx.mpFirstSchedulerData[nTaskPriority] == pSchedulerData);
+
+    ImplSchedulerData * const pSchedulerDataNext = pSchedulerData->mpNext;
+    if ( pPrevSchedulerData )
+        pPrevSchedulerData->mpNext = pSchedulerDataNext;
+    else
+        rSchedCtx.mpFirstSchedulerData[nTaskPriority] = pSchedulerDataNext;
+    if ( !pSchedulerDataNext )
+        rSchedCtx.mpLastSchedulerData[nTaskPriority] = pPrevSchedulerData;
+    return pSchedulerDataNext;
+}
+
+bool Scheduler::ProcessTaskScheduling()
+{
+    ImplSVData *pSVData = ImplGetSVData();
+    ImplSchedulerContext &rSchedCtx = pSVData->maSchedCtx;
+
+    DBG_TESTSOLARMUTEX();
+
+    SchedulerGuard aSchedulerGuard;
+    if ( !rSchedCtx.mbActive || InfiniteTimeoutMs == rSchedCtx.mnTimerPeriod )
+        return false;
+
+    sal_uInt64 nTime = tools::Time::GetSystemTicks();
+    // Allow for decimals, so subtract in the compare (needed at least on iOS)
+    if ( nTime < rSchedCtx.mnTimerStart + rSchedCtx.mnTimerPeriod -1)
+    {
+        int nSleep = rSchedCtx.mnTimerStart + rSchedCtx.mnTimerPeriod - nTime;
+        UpdateSystemTimer(rSchedCtx, nSleep, true, nTime);
+        return false;
+    }
+
+    ImplSchedulerData* pSchedulerData = nullptr;
+    ImplSchedulerData* pPrevSchedulerData = nullptr;
+    ImplSchedulerData *pMostUrgent = nullptr;
+    ImplSchedulerData *pPrevMostUrgent = nullptr;
+    int                nMostUrgentPriority = 0;
+    sal_uInt64         nMinPeriod = InfiniteTimeoutMs;
+    sal_uInt64         nReadyPeriod = InfiniteTimeoutMs;
+    unsigned           nTasks = 0;
+    int                nTaskPriority = 0;
+
+    for (; nTaskPriority < PRIO_COUNT; ++nTaskPriority)
+    {
+        pSchedulerData = rSchedCtx.mpFirstSchedulerData[nTaskPriority];
+        pPrevSchedulerData = nullptr;
+        while (pSchedulerData)
+        {
+            ++nTasks;
+            const Timer *timer = dynamic_cast<Timer*>( pSchedulerData->mpTask );
+            if ( timer )
+                SAL_INFO( "vcl.schedule", tools::Time::GetSystemTicks() << " "
+                        << pSchedulerData << " " << *pSchedulerData << " " << *timer );
+            else if ( pSchedulerData->mpTask )
+                SAL_INFO( "vcl.schedule", tools::Time::GetSystemTicks() << " "
+                        << pSchedulerData << " " << *pSchedulerData
+                        << " " << *pSchedulerData->mpTask );
+            else
+                SAL_INFO( "vcl.schedule", tools::Time::GetSystemTicks() << " "
+                        << pSchedulerData << " " << *pSchedulerData << " (to be deleted)" );
+
+            // Should the Task be released from scheduling?
+            assert(!pSchedulerData->mbInScheduler);
+            if (!pSchedulerData->mpTask || !pSchedulerData->mpTask->IsActive())
+            {
+                ImplSchedulerData * const pSchedulerDataNext =
+                    DropSchedulerData(rSchedCtx, pPrevSchedulerData, pSchedulerData, nTaskPriority);
+                if ( pSchedulerData->mpTask )
+                    pSchedulerData->mpTask->mpSchedulerData = nullptr;
+                delete pSchedulerData;
+                pSchedulerData = pSchedulerDataNext;
+                continue;
+            }
+
+            assert(pSchedulerData->mpTask);
+            if (pSchedulerData->mpTask->IsActive())
+            {
+                nReadyPeriod = pSchedulerData->mpTask->UpdateMinPeriod( nTime );
+                if (ImmediateTimeoutMs == nReadyPeriod)
+                {
+                    if (!pMostUrgent)
+                    {
+                        pPrevMostUrgent = pPrevSchedulerData;
+                        pMostUrgent = pSchedulerData;
+                        nMostUrgentPriority = nTaskPriority;
+                    }
+                    else
+                    {
+                        nMinPeriod = ImmediateTimeoutMs;
+                        break;
+                    }
+                }
+                else if (nMinPeriod > nReadyPeriod)
+                    nMinPeriod = nReadyPeriod;
+            }
+
+            pPrevSchedulerData = pSchedulerData;
+            pSchedulerData = pSchedulerData->mpNext;
+        }
+
+        if (ImmediateTimeoutMs == nMinPeriod)
+            break;
+    }
+
+    if ( InfiniteTimeoutMs != nMinPeriod )
+        SAL_INFO("vcl.schedule", "Calculated minimum timeout as " << nMinPeriod
+                                 << " of " << nTasks << " tasks" );
+    UpdateSystemTimer( rSchedCtx, nMinPeriod, true, nTime );
+
+    if ( pMostUrgent )
+    {
+        SAL_INFO( "vcl.schedule", tools::Time::GetSystemTicks() << " "
+                  << pMostUrgent << "  invoke-in  " << *pMostUrgent->mpTask );
+
+        Task *pTask = pMostUrgent->mpTask;
+
+        comphelper::ProfileZone aZone( pTask->GetDebugName() );
+
+        // prepare Scheduler object for deletion after handling
+        pTask->SetDeletionFlags();
+
+        pMostUrgent->mbInScheduler = true;
+
+        // always push the stack, as we don't traverse the whole list to push later
+        DropSchedulerData(rSchedCtx, pPrevMostUrgent, pMostUrgent, nMostUrgentPriority);
+        pMostUrgent->mpNext = rSchedCtx.mpSchedulerStack;
+        rSchedCtx.mpSchedulerStack = pMostUrgent;
+        rSchedCtx.mpSchedulerStackTop = pMostUrgent;
+
+        // invoke the task
+        sal_uInt32 nLockCount = Unlock( true );
+        try
+        {
+            pTask->Invoke();
+        }
+        catch (css::uno::Exception&)
+        {
+            TOOLS_WARN_EXCEPTION("vcl.schedule", "Uncaught");
+            std::abort();
+        }
+        catch (std::exception& e)
+        {
+            SAL_WARN("vcl.schedule", "Uncaught " << typeid(e).name() << " " << e.what());
+            std::abort();
+        }
+        catch (...)
+        {
+            SAL_WARN("vcl.schedule", "Uncaught exception during Task::Invoke()!");
+            std::abort();
+        }
+        Lock( nLockCount );
+        pMostUrgent->mbInScheduler = false;
+
+        SAL_INFO( "vcl.schedule", tools::Time::GetSystemTicks() << " "
+                  << pMostUrgent << "  invoke-out" );
+
+        // pop the scheduler stack
+        pSchedulerData = rSchedCtx.mpSchedulerStack;
+        assert(pSchedulerData == pMostUrgent);
+        rSchedCtx.mpSchedulerStack = pSchedulerData->mpNext;
+
+        const bool bTaskAlive = pMostUrgent->mpTask && pMostUrgent->mpTask->IsActive();
+        if (!bTaskAlive)
+        {
+            if (pMostUrgent->mpTask)
+                pMostUrgent->mpTask->mpSchedulerData = nullptr;
+            delete pMostUrgent;
+        }
+        else
+            AppendSchedulerData(rSchedCtx, pMostUrgent);
+
+        // this just happens for nested calls, which renders all accounting
+        // invalid, so we just enforce a rescheduling!
+        if (rSchedCtx.mpSchedulerStackTop != pSchedulerData)
+        {
+            UpdateSystemTimer( rSchedCtx, ImmediateTimeoutMs, true,
+                               tools::Time::GetSystemTicks() );
+        }
+        else if (bTaskAlive)
+        {
+            pMostUrgent->mnUpdateTime = nTime;
+            nReadyPeriod = pMostUrgent->mpTask->UpdateMinPeriod( nTime );
+            if ( nMinPeriod > nReadyPeriod )
+                nMinPeriod = nReadyPeriod;
+            UpdateSystemTimer( rSchedCtx, nMinPeriod, false, nTime );
+        }
+    }
+
+    return !!pMostUrgent;
+}
+
+void Scheduler::Wakeup()
+{
+    Scheduler::ImplStartTimer( 0, false, tools::Time::GetSystemTicks() );
+}
+
+void Task::StartTimer( sal_uInt64 nMS )
+{
+    Scheduler::ImplStartTimer( nMS, false, tools::Time::GetSystemTicks() );
+}
+
+void Task::SetDeletionFlags()
+{
+    mbActive = false;
+}
+
+void Task::Start()
+{
+    ImplSVData *const pSVData = ImplGetSVData();
+    ImplSchedulerContext &rSchedCtx = pSVData->maSchedCtx;
+
+    SchedulerGuard aSchedulerGuard;
+    if ( !rSchedCtx.mbActive )
+        return;
+
+    // is the task scheduled in the correct priority queue?
+    // if not we have to get a new data object, as we don't want to traverse
+    // the whole list to move the data to the correct list, as the task list
+    // is just single linked.
+    // Task priority doesn't change that often AFAIK, or we might need to
+    // start caching ImplSchedulerData objects.
+    if (mpSchedulerData && mpSchedulerData->mePriority != mePriority)
+    {
+        mpSchedulerData->mpTask = nullptr;
+        mpSchedulerData = nullptr;
+    }
+    mbActive = true;
+
+    if ( !mpSchedulerData )
+    {
+        // insert Task
+        ImplSchedulerData* pSchedulerData = new ImplSchedulerData;
+        pSchedulerData->mpTask            = this;
+        pSchedulerData->mbInScheduler     = false;
+        // mePriority is set in AppendSchedulerData
+        mpSchedulerData = pSchedulerData;
+
+        AppendSchedulerData( rSchedCtx, pSchedulerData );
+        SAL_INFO( "vcl.schedule", tools::Time::GetSystemTicks()
+                  << " " << mpSchedulerData << "  added      " << *this );
+    }
+    else
+        SAL_INFO( "vcl.schedule", tools::Time::GetSystemTicks()
+                  << " " << mpSchedulerData << "  restarted  " << *this );
+
+    mpSchedulerData->mnUpdateTime  = tools::Time::GetSystemTicks();
+}
+
+void Task::Stop()
+{
+    SAL_INFO_IF( mbActive, "vcl.schedule", tools::Time::GetSystemTicks()
+                  << " " << mpSchedulerData << "  stopped    " << *this );
+    mbActive = false;
+}
+
+void Task::SetPriority(TaskPriority ePriority)
+{
+    // you don't actually need to call Stop() before but Start() after, but we
+    // can't check that and don't know when Start() should be called.
+    SAL_WARN_IF(mpSchedulerData && mbActive, "vcl.schedule",
+                "Stop the task before changing the priority, as it will just "
+                "change after the task was scheduled with the old prio!");
+    mePriority = ePriority;
+}
+
+Task& Task::operator=( const Task& rTask )
+{
+    if(this == &rTask)
+        return *this;
+
+    if ( IsActive() )
+        Stop();
+
+    mbActive = false;
+    mePriority = rTask.mePriority;
+
+    if ( rTask.IsActive() )
+        Start();
+
+    return *this;
+}
+
+Task::Task( const char *pDebugName )
+    : mpSchedulerData( nullptr )
+    , mpDebugName( pDebugName )
+    , mePriority( TaskPriority::DEFAULT )
+    , mbActive( false )
+    , mbStatic( false )
+{
+}
+
+Task::Task( const Task& rTask )
+    : mpSchedulerData( nullptr )
+    , mpDebugName( rTask.mpDebugName )
+    , mePriority( rTask.mePriority )
+    , mbActive( false )
+    , mbStatic( false )
+{
+    if ( rTask.IsActive() )
+        Start();
+}
+
+Task::~Task() COVERITY_NOEXCEPT_FALSE
+{
+    if ( !IsStatic() )
+    {
+        SchedulerGuard aSchedulerGuard;
+        if ( mpSchedulerData )
+            mpSchedulerData->mpTask = nullptr;
+    }
+    else
+        assert(nullptr == mpSchedulerData || utl::ConfigManager::IsFuzzing());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */