← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Source/WebCore/platform/efl/RunLoopEfl.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/WebCore/platform/efl/RunLoopEfl.cpp
 
1
/*
 
2
 * Copyright (C) 2012 ProFUSION embedded systems. All rights reserved.
 
3
 * Copyright (C) 2012 Samsung Electronics
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 * 1. Redistributions of source code must retain the above copyright
 
9
 *    notice, this list of conditions and the following disclaimer.
 
10
 * 2. Redistributions in binary form must reproduce the above copyright
 
11
 *    notice, this list of conditions and the following disclaimer in the
 
12
 *    documentation and/or other materials provided with the distribution.
 
13
 *
 
14
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
15
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
16
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
17
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
18
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
19
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
20
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
21
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
22
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
23
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
24
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
25
 */
 
26
 
 
27
#include "config.h"
 
28
#include "RunLoop.h"
 
29
 
 
30
#include <Ecore.h>
 
31
#include <Ecore_Evas.h>
 
32
#include <Ecore_File.h>
 
33
#include <Edje.h>
 
34
#include <wtf/OwnPtr.h>
 
35
#include <wtf/PassOwnPtr.h>
 
36
 
 
37
static const int ecorePipeMessageSize = 1;
 
38
static const char wakupEcorePipeMessage[] = "W";
 
39
 
 
40
namespace WebCore {
 
41
 
 
42
RunLoop::RunLoop()
 
43
    : m_initEfl(false)
 
44
{
 
45
    if (!ecore_init()) {
 
46
        LOG_ERROR("could not init ecore.");
 
47
        return;
 
48
    }
 
49
 
 
50
    if (!ecore_evas_init()) {
 
51
        LOG_ERROR("could not init ecore_evas.");
 
52
        goto errorEcoreEvas;
 
53
    }
 
54
 
 
55
    if (!ecore_file_init()) {
 
56
        LOG_ERROR("could not init ecore_file.");
 
57
        goto errorEcoreFile;
 
58
    }
 
59
 
 
60
    if (!edje_init()) {
 
61
        LOG_ERROR("could not init edje.");
 
62
        goto errorEdje;
 
63
    }
 
64
 
 
65
    m_pipe = adoptPtr(ecore_pipe_add(wakeUpEvent, this));
 
66
    m_initEfl = true;
 
67
 
 
68
    return;
 
69
 
 
70
errorEdje:
 
71
    ecore_file_shutdown();
 
72
errorEcoreFile:
 
73
    ecore_evas_shutdown();
 
74
errorEcoreEvas:
 
75
    ecore_shutdown();
 
76
}
 
77
 
 
78
RunLoop::~RunLoop()
 
79
{
 
80
    if (m_initEfl) {
 
81
        edje_shutdown();
 
82
        ecore_file_shutdown();
 
83
        ecore_evas_shutdown();
 
84
        ecore_shutdown();
 
85
    }
 
86
}
 
87
 
 
88
void RunLoop::run()
 
89
{
 
90
    ecore_main_loop_begin();
 
91
}
 
92
 
 
93
void RunLoop::stop()
 
94
{
 
95
    ecore_main_loop_quit();
 
96
}
 
97
 
 
98
void RunLoop::wakeUpEvent(void* data, void*, unsigned int)
 
99
{
 
100
    static_cast<RunLoop*>(data)->performWork();
 
101
}
 
102
 
 
103
void RunLoop::wakeUp()
 
104
{
 
105
    MutexLocker locker(m_pipeLock);
 
106
    ecore_pipe_write(m_pipe.get(), wakupEcorePipeMessage, ecorePipeMessageSize);
 
107
}
 
108
 
 
109
RunLoop::TimerBase::TimerBase(RunLoop*)
 
110
    : m_isRepeating(false)
 
111
{
 
112
}
 
113
 
 
114
RunLoop::TimerBase::~TimerBase()
 
115
{
 
116
    stop();
 
117
}
 
118
 
 
119
bool RunLoop::TimerBase::timerFired(void* data)
 
120
{
 
121
    RunLoop::TimerBase* timer = static_cast<RunLoop::TimerBase*>(data);
 
122
 
 
123
    timer->fired();
 
124
 
 
125
    if (!timer->m_isRepeating) {
 
126
        timer->m_timer = nullptr;
 
127
        return ECORE_CALLBACK_CANCEL;
 
128
    }
 
129
 
 
130
    return ECORE_CALLBACK_RENEW;
 
131
}
 
132
 
 
133
void RunLoop::TimerBase::start(double nextFireInterval, bool repeat)
 
134
{
 
135
    m_isRepeating = repeat;
 
136
    m_timer = adoptPtr(ecore_timer_add(nextFireInterval, reinterpret_cast<Ecore_Task_Cb>(timerFired), this));
 
137
}
 
138
 
 
139
void RunLoop::TimerBase::stop()
 
140
{
 
141
    m_timer = nullptr;
 
142
}
 
143
 
 
144
bool RunLoop::TimerBase::isActive() const
 
145
{
 
146
    return (m_timer) ? true : false;
 
147
}
 
148
 
 
149
} // namespace WebCore