browservice/src/timeout.cpp at master · startergo/browservice · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include "timeout.hpp"

#include "include/wrapper/cef_closure_task.h"
#include "include/base/cef_callback.h"

namespace browservice {

Timeout::Timeout(CKey, int64_t delayMs) {
    REQUIRE_UI_THREAD();

    delayMs_ = max(delayMs, (int64_t)1);
    active_ = false;
    delayedTaskScheduled_ = false;
}

void Timeout::set(Func func) {
    REQUIRE_UI_THREAD();
    REQUIRE(!active_);

    active_ = true;
    func_ = func;
    funcTime_ = steady_clock::now() + milliseconds(delayMs_);

    if(!delayedTaskScheduled_) {
        delayedTaskScheduled_ = true;
        delayedTaskTime_ = funcTime_;

        shared_ptr<Timeout> self = shared_from_this();
        function<void()> task = [self]() {
            self->delayedTask_();
        };

        void (*call)(function<void()>) = [](function<void()> func) {
            func();
        };
        CefPostDelayedTask(TID_UI, base::BindOnce(call, task), delayMs_);
    }
}

void Timeout::clear(bool runFunc) {
    REQUIRE_UI_THREAD();

    if(!active_) {
        return;
    }

    active_ = false;

    Func func;
    swap(func_, func);

    if(runFunc) {
        func();
    }
}

bool Timeout::isActive() {
    REQUIRE_UI_THREAD();
    return active_;
}

void Timeout::delayedTask_() {
    REQUIRE_UI_THREAD();

    REQUIRE(delayedTaskScheduled_);
    delayedTaskScheduled_ = false;

    if(!active_) {
        return;
    }

    if(funcTime_ == delayedTaskTime_) {
        active_ = false;
        Func func;
        swap(func_, func);
        func();
    } else {
        int64_t addDelayMs = (int64_t)(duration_cast<milliseconds>(
            funcTime_ - delayedTaskTime_
        ).count());
        addDelayMs = max(addDelayMs, (int64_t)1);

        delayedTaskScheduled_ = true;
        delayedTaskTime_ = funcTime_;

        shared_ptr<Timeout> self = shared_from_this();
        function<void()> task = [self]() {
            self->delayedTask_();
        };

        void (*call)(function<void()>) = [](function<void()> func) {
            func();
        };
        CefPostDelayedTask(TID_UI, base::BindOnce(call, task), addDelayMs);
    }
}

}