/*

 * Copyright 2015 Google Inc.

 *

 * Use of this source code is governed by a BSD-style license that can be

 * found in the LICENSE file.

 */

#ifndef SkMutex_DEFINED

#define SkMutex_DEFINED

#include "include/private/base/SkAssert.h"

#include "include/private/base/SkDebug.h"

#include "include/private/base/SkSemaphore.h"

#include "include/private/base/SkThreadAnnotations.h"

#include "include/private/base/SkThreadID.h"

class SK_CAPABILITY("mutex") SkMutex {

public:

    constexpr SkMutex() = default;

    ~SkMutex() {

        this->assertNotHeld();

    }

    void acquire() SK_ACQUIRE() {

        fSemaphore.wait();

        SkDEBUGCODE(fOwner = SkGetThreadID();)

    }

SkMutex::acquire()

Line

Count

Source

25

416M

    void acquire() SK_ACQUIRE() {

26

416M

        fSemaphore.wait();

27

416M

        SkDEBUGCODE(fOwner = SkGetThreadID();)

28

416M

    }

SkMutex::acquire()

Line

Count

Source

25

416M

    void acquire() SK_ACQUIRE() {

26

416M

        fSemaphore.wait();

27

416M

        SkDEBUGCODE(fOwner = SkGetThreadID();)

28

416M

    }

    void release() SK_RELEASE_CAPABILITY() {

        this->assertHeld();

        SkDEBUGCODE(fOwner = kIllegalThreadID;)

        fSemaphore.signal();

    }

SkMutex::release()

Line

Count

Source

30

416M

    void release() SK_RELEASE_CAPABILITY() {

31

416M

        this->assertHeld();

32

416M

        SkDEBUGCODE(fOwner = kIllegalThreadID;)

33

416M

        fSemaphore.signal();

34

416M

    }

SkMutex::release()

Line

Count

Source

30

416M

    void release() SK_RELEASE_CAPABILITY() {

31

416M

        this->assertHeld();

32

416M

        SkDEBUGCODE(fOwner = kIllegalThreadID;)

33

416M

        fSemaphore.signal();

34

416M

    }

    void assertHeld() SK_ASSERT_CAPABILITY(this) {

        SkASSERT(fOwner == SkGetThreadID());

    }

    void assertNotHeld() {

        SkASSERT(fOwner == kIllegalThreadID);

    }

private:

    SkSemaphore fSemaphore{1};

    SkDEBUGCODE(SkThreadID fOwner{kIllegalThreadID};)

};

class SK_SCOPED_CAPABILITY SkAutoMutexExclusive {

public:

    SkAutoMutexExclusive(SkMutex& mutex) SK_ACQUIRE(mutex) : fMutex(mutex) { fMutex.acquire(); }

    ~SkAutoMutexExclusive() SK_RELEASE_CAPABILITY() { fMutex.release(); }

    SkAutoMutexExclusive(const SkAutoMutexExclusive&) = delete;

    SkAutoMutexExclusive(SkAutoMutexExclusive&&) = delete;

    SkAutoMutexExclusive& operator=(const SkAutoMutexExclusive&) = delete;

    SkAutoMutexExclusive& operator=(SkAutoMutexExclusive&&) = delete;

private:

    SkMutex& fMutex;

};

#endif  // SkMutex_DEFINED