LayerTreeHostGtk.cpp 13.9 KB
Newer Older
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
/*
 * Copyright (C) 2011 Apple Inc. All rights reserved.
 * Copyright (C) 2012 Igalia S.L.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "LayerTreeHostGtk.h"

30
31
#if USE(TEXTURE_MAPPER_GL)

32
33
34
35
#include "DrawingAreaImpl.h"
#include "TextureMapperGL.h"
#include "WebPage.h"
#include "WebProcess.h"
36
37
38
39

#if USE(OPENGL_ES_2)
#include <GLES2/gl2.h>
#else
40
#include <GL/gl.h>
41
42
#endif

43
#include <WebCore/FrameView.h>
44
#include <WebCore/GLContext.h>
45
#include <WebCore/GraphicsLayerTextureMapper.h>
darin@apple.com's avatar
darin@apple.com committed
46
#include <WebCore/MainFrame.h>
47
48
#include <WebCore/Page.h>
#include <WebCore/Settings.h>
49
#include <wtf/CurrentTime.h>
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

#include <gdk/gdk.h>
#if defined(GDK_WINDOWING_X11)
#define Region XRegion
#define Font XFont
#define Cursor XCursor
#define Screen XScreen
#include <gdk/gdkx.h>
#endif

using namespace WebCore;

namespace WebKit {

PassRefPtr<LayerTreeHostGtk> LayerTreeHostGtk::create(WebPage* webPage)
{
    RefPtr<LayerTreeHostGtk> host = adoptRef(new LayerTreeHostGtk(webPage));
    host->initialize();
    return host.release();
}

LayerTreeHostGtk::LayerTreeHostGtk(WebPage* webPage)
    : LayerTreeHost(webPage)
    , m_isValid(true)
    , m_notifyAfterScheduledLayerFlush(false)
75
    , m_lastFlushTime(0)
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
    , m_layerFlushSchedulingEnabled(true)
    , m_layerFlushTimerCallbackId(0)
{
}

GLContext* LayerTreeHostGtk::glContext()
{
    if (m_context)
        return m_context.get();

    uint64_t windowHandle = m_webPage->nativeWindowHandle();
    if (!windowHandle)
        return 0;

    m_context = GLContext::createContextForWindow(windowHandle, GLContext::sharingContext());
    return m_context.get();
}

void LayerTreeHostGtk::initialize()
{
96
    m_rootLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
97
98
99
100
    m_rootLayer->setDrawsContent(false);
    m_rootLayer->setSize(m_webPage->size());

    // The non-composited contents are a child of the root layer.
101
    m_nonCompositedContentLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
102
103
104
    m_nonCompositedContentLayer->setDrawsContent(true);
    m_nonCompositedContentLayer->setContentsOpaque(m_webPage->drawsBackground() && !m_webPage->drawsTransparentBackground());
    m_nonCompositedContentLayer->setSize(m_webPage->size());
105
    if (m_webPage->corePage()->settings().acceleratedDrawingEnabled())
106
107
108
109
110
111
112
113
114
115
116
117
118
        m_nonCompositedContentLayer->setAcceleratesDrawing(true);

#ifndef NDEBUG
    m_rootLayer->setName("LayerTreeHost root layer");
    m_nonCompositedContentLayer->setName("LayerTreeHost non-composited content");
#endif

    m_rootLayer->addChild(m_nonCompositedContentLayer.get());
    m_nonCompositedContentLayer->setNeedsDisplay();

    m_layerTreeContext.windowHandle = m_webPage->nativeWindowHandle();

    GLContext* context = glContext();
119
    if (!context)
120
121
122
123
        return;

    // The creation of the TextureMapper needs an active OpenGL context.
    context->makeContextCurrent();
124

125
    m_textureMapper = TextureMapperGL::create();
126
    static_cast<TextureMapperGL*>(m_textureMapper.get())->setEnableEdgeDistanceAntialiasing(true);
127
128
    toTextureMapperLayer(m_rootLayer.get())->setTextureMapper(m_textureMapper.get());

129
130
131
132
133
134
    if (m_webPage->hasPageOverlay()) {
        PageOverlayList& pageOverlays = m_webPage->pageOverlays();
        PageOverlayList::iterator end = pageOverlays.end();
        for (PageOverlayList::iterator it = pageOverlays.begin(); it != end; ++it)
            createPageOverlayLayer(it->get());
    }
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

    scheduleLayerFlush();
}

LayerTreeHostGtk::~LayerTreeHostGtk()
{
    ASSERT(!m_isValid);
    ASSERT(!m_rootLayer);
    cancelPendingLayerFlush();
}

const LayerTreeContext& LayerTreeHostGtk::layerTreeContext()
{
    return m_layerTreeContext;
}

void LayerTreeHostGtk::setShouldNotifyAfterNextScheduledLayerFlush(bool notifyAfterScheduledLayerFlush)
{
    m_notifyAfterScheduledLayerFlush = notifyAfterScheduledLayerFlush;
}

void LayerTreeHostGtk::setRootCompositingLayer(GraphicsLayer* graphicsLayer)
{
    m_nonCompositedContentLayer->removeAllChildren();

    // Add the accelerated layer tree hierarchy.
    if (graphicsLayer)
        m_nonCompositedContentLayer->addChild(graphicsLayer);

    scheduleLayerFlush();
}

void LayerTreeHostGtk::invalidate()
{
    ASSERT(m_isValid);

    cancelPendingLayerFlush();
    m_rootLayer = nullptr;
    m_nonCompositedContentLayer = nullptr;
    m_textureMapper = nullptr;

    m_context = nullptr;
    m_isValid = false;
}

180
181
182
void LayerTreeHostGtk::setNonCompositedContentsNeedDisplay()
{
    m_nonCompositedContentLayer->setNeedsDisplay();
183
184
185
186

    PageOverlayLayerMap::iterator end = m_pageOverlayLayers.end();
    for (PageOverlayLayerMap::iterator it = m_pageOverlayLayers.begin(); it != end; ++it)
        it->value->setNeedsDisplay();
187
188
189
190
191

    scheduleLayerFlush();
}

void LayerTreeHostGtk::setNonCompositedContentsNeedDisplayInRect(const IntRect& rect)
192
193
{
    m_nonCompositedContentLayer->setNeedsDisplayInRect(rect);
194
195
196
197

    PageOverlayLayerMap::iterator end = m_pageOverlayLayers.end();
    for (PageOverlayLayerMap::iterator it = m_pageOverlayLayers.begin(); it != end; ++it)
        it->value->setNeedsDisplayInRect(rect);
198
199
200
201

    scheduleLayerFlush();
}

202
void LayerTreeHostGtk::scrollNonCompositedContents(const IntRect& scrollRect)
203
{
204
    setNonCompositedContentsNeedDisplayInRect(scrollRect);
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
}

void LayerTreeHostGtk::sizeDidChange(const IntSize& newSize)
{
    if (m_rootLayer->size() == newSize)
        return;
    m_rootLayer->setSize(newSize);

    // If the newSize exposes new areas of the non-composited content a setNeedsDisplay is needed
    // for those newly exposed areas.
    FloatSize oldSize = m_nonCompositedContentLayer->size();
    m_nonCompositedContentLayer->setSize(newSize);

    if (newSize.width() > oldSize.width()) {
        float height = std::min(static_cast<float>(newSize.height()), oldSize.height());
        m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(oldSize.width(), 0, newSize.width() - oldSize.width(), height));
    }

    if (newSize.height() > oldSize.height())
        m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(0, oldSize.height(), newSize.width(), newSize.height() - oldSize.height()));
    m_nonCompositedContentLayer->setNeedsDisplay();

227
228
229
    PageOverlayLayerMap::iterator end = m_pageOverlayLayers.end();
    for (PageOverlayLayerMap::iterator it = m_pageOverlayLayers.begin(); it != end; ++it)
        it->value->setSize(newSize);
230
231

    compositeLayersToContext(ForResize);
232
233
}

234
void LayerTreeHostGtk::deviceOrPageScaleFactorChanged()
235
236
237
238
239
240
241
242
243
244
{
    // Other layers learn of the scale factor change via WebPage::setDeviceScaleFactor.
    m_nonCompositedContentLayer->deviceOrPageScaleFactorChanged();
}

void LayerTreeHostGtk::forceRepaint()
{
    scheduleLayerFlush();
}

245
void LayerTreeHostGtk::didInstallPageOverlay(PageOverlay* pageOverlay)
246
{
247
    createPageOverlayLayer(pageOverlay);
248
249
250
    scheduleLayerFlush();
}

251
void LayerTreeHostGtk::didUninstallPageOverlay(PageOverlay* pageOverlay)
252
{
253
    destroyPageOverlayLayer(pageOverlay);
254
255
256
    scheduleLayerFlush();
}

257
void LayerTreeHostGtk::setPageOverlayNeedsDisplay(PageOverlay* pageOverlay, const IntRect& rect)
258
{
259
260
261
262
263
    GraphicsLayer* layer = m_pageOverlayLayers.get(pageOverlay);
    if (!layer)
        return;

    layer->setNeedsDisplayInRect(rect);
264
265
266
267
268
269
270
    scheduleLayerFlush();
}

void LayerTreeHostGtk::notifyAnimationStarted(const WebCore::GraphicsLayer*, double time)
{
}

271
void LayerTreeHostGtk::notifyFlushRequired(const WebCore::GraphicsLayer*)
272
273
274
275
276
{
}

void LayerTreeHostGtk::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& graphicsContext, GraphicsLayerPaintingPhase, const IntRect& clipRect)
{
277
    if (graphicsLayer == m_nonCompositedContentLayer.get()) {
278
279
280
281
        m_webPage->drawRect(graphicsContext, clipRect);
        return;
    }

282
283
284
    for (auto& pageOverlayLayer : m_pageOverlayLayers) {
        if (pageOverlayLayer.value.get() == graphicsLayer) {
            m_webPage->drawPageOverlay(pageOverlayLayer.key, graphicsContext, clipRect);
285
286
            break;
        }
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
    }
}

gboolean LayerTreeHostGtk::layerFlushTimerFiredCallback(LayerTreeHostGtk* layerTreeHost)
{
    layerTreeHost->layerFlushTimerFired();
    return FALSE;
}

void LayerTreeHostGtk::layerFlushTimerFired()
{
    ASSERT(m_layerFlushTimerCallbackId);
    m_layerFlushTimerCallbackId = 0;

    flushAndRenderLayers();

303
304
305
306
307
    if (toTextureMapperLayer(m_rootLayer.get())->descendantsOrSelfHaveRunningAnimations() && !m_layerFlushTimerCallbackId) {
        const double targetFPS = 60;
        double nextFlush = std::max((1 / targetFPS) - (currentTime() - m_lastFlushTime), 0.0);
        m_layerFlushTimerCallbackId = g_timeout_add_full(GDK_PRIORITY_EVENTS, nextFlush * 1000.0, reinterpret_cast<GSourceFunc>(layerFlushTimerFiredCallback), this, 0);
    }
308
309
310
311
}

bool LayerTreeHostGtk::flushPendingLayerChanges()
{
312
313
    m_rootLayer->flushCompositingStateForThisLayerOnly();
    m_nonCompositedContentLayer->flushCompositingStateForThisLayerOnly();
314
315
316
317

    PageOverlayLayerMap::iterator end = m_pageOverlayLayers.end();
    for (PageOverlayLayerMap::iterator it = m_pageOverlayLayers.begin(); it != end; ++it)
        it->value->flushCompositingStateForThisLayerOnly();
318

319
    return m_webPage->corePage()->mainFrame().view()->flushCompositingStateIncludingSubframes();
320
321
}

322
void LayerTreeHostGtk::compositeLayersToContext(CompositePurpose purpose)
323
324
325
326
327
328
329
330
331
332
333
{
    GLContext* context = glContext();
    if (!context || !context->makeContextCurrent())
        return;

    // The window size may be out of sync with the page size at this point, and getting
    // the viewport parameters incorrect, means that the content will be misplaced. Thus
    // we set the viewport parameters directly from the window size.
    IntSize contextSize = m_context->defaultFrameBufferSize();
    glViewport(0, 0, contextSize.width(), contextSize.height());

334
335
336
337
338
    if (purpose == ForResize) {
        glClearColor(1, 1, 1, 0);
        glClear(GL_COLOR_BUFFER_BIT);
    }

339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
    m_textureMapper->beginPainting();
    toTextureMapperLayer(m_rootLayer.get())->paint();
    m_textureMapper->endPainting();

    context->swapBuffers();
}

void LayerTreeHostGtk::flushAndRenderLayers()
{
    {
        RefPtr<LayerTreeHostGtk> protect(this);
        m_webPage->layoutIfNeeded();

        if (!m_isValid)
            return;
    }

    GLContext* context = glContext();
    if (!context || !context->makeContextCurrent())
        return;

360
    m_lastFlushTime = currentTime();
361
362
363
364
365
366
367
368
369
370
371
372
373
    if (!flushPendingLayerChanges())
        return;

    // Our model is very simple. We always composite and render the tree immediately after updating it.
    compositeLayersToContext();

    if (m_notifyAfterScheduledLayerFlush) {
        // Let the drawing area know that we've done a flush of the layer changes.
        static_cast<DrawingAreaImpl*>(m_webPage->drawingArea())->layerHostDidFlushLayers();
        m_notifyAfterScheduledLayerFlush = false;
    }
}

374
void LayerTreeHostGtk::createPageOverlayLayer(PageOverlay* pageOverlay)
375
{
376
    std::unique_ptr<GraphicsLayer> layer = GraphicsLayer::create(graphicsLayerFactory(), this);
377
#ifndef NDEBUG
378
    layer->setName("LayerTreeHost page overlay content");
379
380
#endif

381
    layer->setAcceleratesDrawing(m_webPage->corePage()->settings().acceleratedDrawingEnabled());
382
383
    layer->setDrawsContent(true);
    layer->setSize(m_webPage->size());
384
385
    layer->setShowDebugBorder(m_webPage->corePage()->settings().showDebugBorders());
    layer->setShowRepaintCounter(m_webPage->corePage()->settings().showRepaintCounter());
386

387
    m_rootLayer->addChild(layer.get());
388
    m_pageOverlayLayers.add(pageOverlay, std::move(layer));
389
390
}

391
void LayerTreeHostGtk::destroyPageOverlayLayer(PageOverlay* pageOverlay)
392
{
393
    std::unique_ptr<GraphicsLayer> layer = m_pageOverlayLayers.take(pageOverlay);
394
395
396
    ASSERT(layer);

    layer->removeFromParent();
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
}

void LayerTreeHostGtk::scheduleLayerFlush()
{
    if (!m_layerFlushSchedulingEnabled)
        return;

    // We use a GLib timer because otherwise GTK+ event handling during dragging can starve WebCore timers, which have a lower priority.
    if (!m_layerFlushTimerCallbackId)
        m_layerFlushTimerCallbackId = g_timeout_add_full(GDK_PRIORITY_EVENTS, 0, reinterpret_cast<GSourceFunc>(layerFlushTimerFiredCallback), this, 0);
}

void LayerTreeHostGtk::setLayerFlushSchedulingEnabled(bool layerFlushingEnabled)
{
    if (m_layerFlushSchedulingEnabled == layerFlushingEnabled)
        return;

    m_layerFlushSchedulingEnabled = layerFlushingEnabled;

    if (m_layerFlushSchedulingEnabled) {
        scheduleLayerFlush();
        return;
    }

    cancelPendingLayerFlush();
}

424
425
void LayerTreeHostGtk::pageBackgroundTransparencyChanged()
{
426
    m_nonCompositedContentLayer->setContentsOpaque(m_webPage->drawsBackground() && !m_webPage->drawsTransparentBackground());
427
428
}

429
430
431
432
433
434
435
436
437
438
void LayerTreeHostGtk::cancelPendingLayerFlush()
{
    if (!m_layerFlushTimerCallbackId)
        return;

    g_source_remove(m_layerFlushTimerCallbackId);
    m_layerFlushTimerCallbackId = 0;
}

} // namespace WebKit
439
440

#endif