Source/WebCore/platform/graphics/android/GLWebViewState.cpp

   1 /*
   2  * Copyright 2010, The Android Open Source Project
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *  * Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  *  * Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "GLWebViewState.h"
  28
  29 #if USE(ACCELERATED_COMPOSITING)
  30
  31 #include "BaseLayerAndroid.h"
  32 #include "ClassTracker.h"
  33 #include "GLUtils.h"
  34 #include "ImagesManager.h"
  35 #include "LayerAndroid.h"
  36 #include "ScrollableLayerAndroid.h"
  37 #include "SkPath.h"
  38 #include "TilesManager.h"
  39 #include "TilesTracker.h"
  40 #include "TreeManager.h"
  41 #include <wtf/CurrentTime.h>
  42
  43 #include <pthread.h>
  44
  45 #include <cutils/log.h>
  46 #include <wtf/text/CString.h>
  47
  48 #undef XLOGC
  49 #define XLOGC(...) android_printLog(ANDROID_LOG_DEBUG, "GLWebViewState", __VA_ARGS__)
  50
  51 #ifdef DEBUG
  52
  53 #undef XLOG
  54 #define XLOG(...) android_printLog(ANDROID_LOG_DEBUG, "GLWebViewState", __VA_ARGS__)
  55
  56 #else
  57
  58 #undef XLOG
  59 #define XLOG(...)
  60
  61 #endif // DEBUG
  62
  63 #define FIRST_TILED_PAGE_ID 1
  64 #define SECOND_TILED_PAGE_ID 2
  65
  66 #define FRAMERATE_CAP 0.01666 // We cap at 60 fps
  67
  68 // log warnings if scale goes outside this range
  69 #define MIN_SCALE_WARNING 0.1
  70 #define MAX_SCALE_WARNING 10
  71
  72 namespace WebCore {
  73
  74 using namespace android;
  75
  76 GLWebViewState::GLWebViewState()
  77     : m_zoomManager(this)
  78     , m_currentPictureCounter(0)
  79     , m_usePageA(true)
  80     , m_frameworkInval(0, 0, 0, 0)
  81     , m_frameworkLayersInval(0, 0, 0, 0)
  82     , m_isScrolling(false)
  83     , m_goingDown(true)
  84     , m_goingLeft(false)
  85     , m_expandedTileBoundsX(0)
  86     , m_expandedTileBoundsY(0)
  87     , m_highEndGfx(false)
  88     , m_scale(1)
  89     , m_layersRenderingMode(kAllTextures)
  90 {
  91     m_viewport.setEmpty();
  92     m_futureViewportTileBounds.setEmpty();
  93     m_viewportTileBounds.setEmpty();
  94     m_preZoomBounds.setEmpty();
  95
  96     m_tiledPageA = new TiledPage(FIRST_TILED_PAGE_ID, this);
  97     m_tiledPageB = new TiledPage(SECOND_TILED_PAGE_ID, this);
  98
  99 #ifdef DEBUG_COUNT
 100     ClassTracker::instance()->increment("GLWebViewState");
 101 #endif
 102 #ifdef MEASURES_PERF
 103     m_timeCounter = 0;
 104     m_totalTimeCounter = 0;
 105     m_measurePerfs = false;
 106 #endif
 107 }
 108
 109 GLWebViewState::~GLWebViewState()
 110 {
 111     // Take care of the transfer queue such that Tex Gen thread will not stuck
 112     TilesManager::instance()->unregisterGLWebViewState(this);
 113
 114     // We have to destroy the two tiled pages first as their destructor
 115     // may depend on the existence of this GLWebViewState and some of its
 116     // instance variables in order to complete.
 117     // Explicitely, currently we need to have the m_paintingBaseLayer around
 118     // in order to complete any pending paint operations (the tiled pages
 119     // will remove any pending operations, and wait if one is underway).
 120     delete m_tiledPageA;
 121     delete m_tiledPageB;
 122 #ifdef DEBUG_COUNT
 123     ClassTracker::instance()->decrement("GLWebViewState");
 124 #endif
 125
 126 }
 127
 128 void GLWebViewState::setBaseLayer(BaseLayerAndroid* layer, const SkRegion& inval,
 129                                   bool showVisualIndicator, bool isPictureAfterFirstLayout)
 130 {
 131     if (!layer || isPictureAfterFirstLayout) {
 132         // TODO: move this into TreeManager
 133         m_zoomManager.swapPages(); // reset zoom state
 134         m_tiledPageA->discardTextures();
 135         m_tiledPageB->discardTextures();
 136         m_layersRenderingMode = kAllTextures;
 137     }
 138     if (layer) {
 139         XLOG("new base layer %p, (inval region empty %d) with child %p", layer, inval.isEmpty(), layer->getChild(0));
 140         layer->setState(this);
 141         layer->markAsDirty(inval); // TODO: set in webview.cpp
 142     }
 143     m_treeManager.updateWithTree(layer, isPictureAfterFirstLayout);
 144     m_glExtras.setDrawExtra(0);
 145
 146 #ifdef MEASURES_PERF
 147     if (m_measurePerfs && !showVisualIndicator)
 148         dumpMeasures();
 149     m_measurePerfs = showVisualIndicator;
 150 #endif
 151
 152     TilesManager::instance()->setShowVisualIndicator(showVisualIndicator);
 153 }
 154
 155 void GLWebViewState::scrollLayer(int layerId, int x, int y)
 156 {
 157     m_treeManager.updateScrollableLayer(layerId, x, y);
 158
 159     // TODO: only inval the area of the scrolled layer instead of
 160     // doing a fullInval()
 161     if (m_layersRenderingMode == kSingleSurfaceRendering)
 162         fullInval();
 163 }
 164
 165 void GLWebViewState::invalRegion(const SkRegion& region)
 166 {
 167     if (m_layersRenderingMode == kSingleSurfaceRendering) {
 168         // TODO: do the union of both layers tree to compute
 169         //the minimum inval instead of doing a fullInval()
 170         fullInval();
 171         return;
 172     }
 173     SkRegion::Iterator iterator(region);
 174     while (!iterator.done()) {
 175         SkIRect r = iterator.rect();
 176         IntRect ir(r.fLeft, r.fTop, r.width(), r.height());
 177         inval(ir);
 178         iterator.next();
 179     }
 180 }
 181
 182 void GLWebViewState::inval(const IntRect& rect)
 183 {
 184     m_currentPictureCounter++;
 185     if (!rect.isEmpty()) {
 186         // find which tiles fall within the invalRect and mark them as dirty
 187         m_tiledPageA->invalidateRect(rect, m_currentPictureCounter);
 188         m_tiledPageB->invalidateRect(rect, m_currentPictureCounter);
 189         if (m_frameworkInval.isEmpty())
 190             m_frameworkInval = rect;
 191         else
 192             m_frameworkInval.unite(rect);
 193         XLOG("intermediate invalRect(%d, %d, %d, %d) after unite with rect %d %d %d %d", m_frameworkInval.x(),
 194              m_frameworkInval.y(), m_frameworkInval.width(), m_frameworkInval.height(),
 195              rect.x(), rect.y(), rect.width(), rect.height());
 196     }
 197     TilesManager::instance()->getProfiler()->nextInval(rect, zoomManager()->currentScale());
 198 }
 199
 200 unsigned int GLWebViewState::paintBaseLayerContent(SkCanvas* canvas)
 201 {
 202     m_treeManager.drawCanvas(canvas, m_layersRenderingMode == kSingleSurfaceRendering);
 203     return m_currentPictureCounter;
 204 }
 205
 206 TiledPage* GLWebViewState::sibling(TiledPage* page)
 207 {
 208     return (page == m_tiledPageA) ? m_tiledPageB : m_tiledPageA;
 209 }
 210
 211 TiledPage* GLWebViewState::frontPage()
 212 {
 213     android::Mutex::Autolock lock(m_tiledPageLock);
 214     return m_usePageA ? m_tiledPageA : m_tiledPageB;
 215 }
 216
 217 TiledPage* GLWebViewState::backPage()
 218 {
 219     android::Mutex::Autolock lock(m_tiledPageLock);
 220     return m_usePageA ? m_tiledPageB : m_tiledPageA;
 221 }
 222
 223 void GLWebViewState::swapPages()
 224 {
 225     android::Mutex::Autolock lock(m_tiledPageLock);
 226     m_usePageA ^= true;
 227     TiledPage* oldPage = m_usePageA ? m_tiledPageB : m_tiledPageA;
 228     zoomManager()->swapPages();
 229     oldPage->discardTextures();
 230 }
 231
 232 int GLWebViewState::baseContentWidth()
 233 {
 234     return m_treeManager.baseContentWidth();
 235 }
 236 int GLWebViewState::baseContentHeight()
 237 {
 238     return m_treeManager.baseContentHeight();
 239 }
 240
 241 void GLWebViewState::setViewport(SkRect& viewport, float scale)
 242 {
 243     if ((m_viewport == viewport) &&
 244         (zoomManager()->futureScale() == scale))
 245         return;
 246
 247     m_goingDown = m_viewport.fTop - viewport.fTop <= 0;
 248     m_goingLeft = m_viewport.fLeft - viewport.fLeft >= 0;
 249     m_viewport = viewport;
 250
 251     XLOG("New VIEWPORT %.2f - %.2f %.2f - %.2f (w: %2.f h: %.2f scale: %.2f currentScale: %.2f futureScale: %.2f)",
 252          m_viewport.fLeft, m_viewport.fTop, m_viewport.fRight, m_viewport.fBottom,
 253          m_viewport.width(), m_viewport.height(), scale,
 254          zoomManager()->currentScale(), zoomManager()->futureScale());
 255
 256     const float invTileContentWidth = scale / TilesManager::tileWidth();
 257     const float invTileContentHeight = scale / TilesManager::tileHeight();
 258
 259     m_viewportTileBounds.set(
 260             static_cast<int>(floorf(viewport.fLeft * invTileContentWidth)),
 261             static_cast<int>(floorf(viewport.fTop * invTileContentHeight)),
 262             static_cast<int>(ceilf(viewport.fRight * invTileContentWidth)),
 263             static_cast<int>(ceilf(viewport.fBottom * invTileContentHeight)));
 264
 265     // allocate max possible number of tiles visible with this viewport
 266     int viewMaxTileX = static_cast<int>(ceilf((viewport.width()-1) * invTileContentWidth)) + 1;
 267     int viewMaxTileY = static_cast<int>(ceilf((viewport.height()-1) * invTileContentHeight)) + 1;
 268
 269     int maxTextureCount = (viewMaxTileX + m_expandedTileBoundsX * 2) *
 270         (viewMaxTileY + m_expandedTileBoundsY * 2) * (m_highEndGfx ? 4 : 2);
 271
 272     TilesManager::instance()->setMaxTextureCount(maxTextureCount);
 273     m_tiledPageA->updateBaseTileSize();
 274     m_tiledPageB->updateBaseTileSize();
 275 }
 276
 277 #ifdef MEASURES_PERF
 278 void GLWebViewState::dumpMeasures()
 279 {
 280     for (int i = 0; i < m_timeCounter; i++) {
 281         XLOGC("%d delay: %d ms", m_totalTimeCounter + i,
 282              static_cast<int>(m_delayTimes[i]*1000));
 283         m_delayTimes[i] = 0;
 284     }
 285     m_totalTimeCounter += m_timeCounter;
 286     m_timeCounter = 0;
 287 }
 288 #endif // MEASURES_PERF
 289
 290 void GLWebViewState::resetFrameworkInval()
 291 {
 292     m_frameworkInval.setX(0);
 293     m_frameworkInval.setY(0);
 294     m_frameworkInval.setWidth(0);
 295     m_frameworkInval.setHeight(0);
 296 }
 297
 298 void GLWebViewState::addDirtyArea(const IntRect& rect)
 299 {
 300     if (rect.isEmpty())
 301         return;
 302
 303     IntRect inflatedRect = rect;
 304     inflatedRect.inflate(8);
 305     if (m_frameworkLayersInval.isEmpty())
 306         m_frameworkLayersInval = inflatedRect;
 307     else
 308         m_frameworkLayersInval.unite(inflatedRect);
 309 }
 310
 311 void GLWebViewState::resetLayersDirtyArea()
 312 {
 313     m_frameworkLayersInval.setX(0);
 314     m_frameworkLayersInval.setY(0);
 315     m_frameworkLayersInval.setWidth(0);
 316     m_frameworkLayersInval.setHeight(0);
 317 }
 318
 319 void GLWebViewState::drawBackground(Color& backgroundColor)
 320 {
 321     if (TilesManager::instance()->invertedScreen()) {
 322         float color = 1.0 - ((((float) backgroundColor.red() / 255.0) +
 323                       ((float) backgroundColor.green() / 255.0) +
 324                       ((float) backgroundColor.blue() / 255.0)) / 3.0);
 325         glClearColor(color, color, color, 1);
 326     } else {
 327         glClearColor((float)backgroundColor.red() / 255.0,
 328                      (float)backgroundColor.green() / 255.0,
 329                      (float)backgroundColor.blue() / 255.0, 1);
 330     }
 331     glClear(GL_COLOR_BUFFER_BIT);
 332 }
 333
 334 double GLWebViewState::setupDrawing(IntRect& viewRect, SkRect& visibleRect,
 335                                     IntRect& webViewRect, int titleBarHeight,
 336                                     IntRect& screenClip, float scale)
 337 {
 338     int left = viewRect.x();
 339     int top = viewRect.y();
 340     int width = viewRect.width();
 341     int height = viewRect.height();
 342
 343     ShaderProgram* shader = TilesManager::instance()->shader();
 344     if (shader->program() == -1) {
 345         XLOG("Reinit shader");
 346         shader->init();
 347     }
 348     shader->setViewport(visibleRect, scale);
 349     shader->setViewRect(viewRect);
 350     shader->setWebViewRect(webViewRect);
 351     shader->setTitleBarHeight(titleBarHeight);
 352     shader->setScreenClip(screenClip);
 353     shader->resetBlending();
 354
 355     shader->calculateAnimationDelta();
 356
 357     glViewport(left + shader->getAnimationDeltaX(),
 358                top - shader->getAnimationDeltaY(),
 359                width, height);
 360
 361     double currentTime = WTF::currentTime();
 362
 363     setViewport(visibleRect, scale);
 364     m_zoomManager.processNewScale(currentTime, scale);
 365
 366     return currentTime;
 367 }
 368
 369 bool GLWebViewState::setLayersRenderingMode(TexturesResult& nbTexturesNeeded)
 370 {
 371     bool invalBase = false;
 372
 373     if (!nbTexturesNeeded.full)
 374         TilesManager::instance()->setMaxLayerTextureCount(0);
 375     else
 376         TilesManager::instance()->setMaxLayerTextureCount((2*nbTexturesNeeded.full)+1);
 377
 378     int maxTextures = TilesManager::instance()->maxLayerTextureCount();
 379     LayersRenderingMode layersRenderingMode = m_layersRenderingMode;
 380
 381     if (m_layersRenderingMode == kSingleSurfaceRendering) {
 382         // only switch out of SingleSurface mode, if we have 2x needed textures
 383         // to avoid changing too often
 384         maxTextures /= 2;
 385     }
 386
 387     m_layersRenderingMode = kSingleSurfaceRendering;
 388     if (nbTexturesNeeded.fixed < maxTextures)
 389         m_layersRenderingMode = kFixedLayers;
 390     if (nbTexturesNeeded.scrollable < maxTextures)
 391         m_layersRenderingMode = kScrollableAndFixedLayers;
 392     if (nbTexturesNeeded.clipped < maxTextures)
 393         m_layersRenderingMode = kClippedTextures;
 394     if (nbTexturesNeeded.full < maxTextures)
 395         m_layersRenderingMode = kAllTextures;
 396
 397     if (!maxTextures && !nbTexturesNeeded.full)
 398         m_layersRenderingMode = kAllTextures;
 399
 400     if (m_layersRenderingMode < layersRenderingMode
 401         && m_layersRenderingMode != kAllTextures)
 402         invalBase = true;
 403
 404     if (m_layersRenderingMode > layersRenderingMode
 405         && m_layersRenderingMode != kClippedTextures)
 406         invalBase = true;
 407
 408 #ifdef DEBUG
 409     if (m_layersRenderingMode != layersRenderingMode) {
 410         char* mode[] = { "kAllTextures", "kClippedTextures",
 411             "kScrollableAndFixedLayers", "kFixedLayers", "kSingleSurfaceRendering" };
 412         XLOGC("Change from mode %s to %s -- We need textures: fixed: %d,"
 413               " scrollable: %d, clipped: %d, full: %d, max textures: %d",
 414               static_cast<char*>(mode[layersRenderingMode]),
 415               static_cast<char*>(mode[m_layersRenderingMode]),
 416               nbTexturesNeeded.fixed,
 417               nbTexturesNeeded.scrollable,
 418               nbTexturesNeeded.clipped,
 419               nbTexturesNeeded.full, maxTextures);
 420     }
 421 #endif
 422
 423     // For now, anything below kClippedTextures is equivalent
 424     // to kSingleSurfaceRendering
 425     // TODO: implement the other rendering modes
 426     if (m_layersRenderingMode > kClippedTextures)
 427         m_layersRenderingMode = kSingleSurfaceRendering;
 428
 429     // update the base surface if needed
 430     if (m_layersRenderingMode != layersRenderingMode
 431         && invalBase) {
 432         m_tiledPageA->discardTextures();
 433         m_tiledPageB->discardTextures();
 434         fullInval();
 435         return true;
 436     }
 437     return false;
 438 }
 439
 440 void GLWebViewState::fullInval()
 441 {
 442     // TODO -- use base layer's size.
 443     IntRect ir(0, 0, 1E6, 1E6);
 444     inval(ir);
 445 }
 446
 447 bool GLWebViewState::drawGL(IntRect& rect, SkRect& viewport, IntRect* invalRect,
 448                             IntRect& webViewRect, int titleBarHeight,
 449                             IntRect& clip, float scale,
 450                             bool* treesSwappedPtr, bool* newTreeHasAnimPtr)
 451 {
 452     m_scale = scale;
 453     TilesManager::instance()->getProfiler()->nextFrame(viewport.fLeft,
 454                                                        viewport.fTop,
 455                                                        viewport.fRight,
 456                                                        viewport.fBottom,
 457                                                        scale);
 458     TilesManager::instance()->incDrawGLCount();
 459
 460 #ifdef DEBUG
 461     TilesManager::instance()->getTilesTracker()->clear();
 462 #endif
 463
 464     float viewWidth = (viewport.fRight - viewport.fLeft) * TILE_PREFETCH_RATIO;
 465     float viewHeight = (viewport.fBottom - viewport.fTop) * TILE_PREFETCH_RATIO;
 466     bool useMinimalMemory = TilesManager::instance()->useMinimalMemory();
 467     bool useHorzPrefetch = useMinimalMemory ? 0 : viewWidth < baseContentWidth();
 468     bool useVertPrefetch = useMinimalMemory ? 0 : viewHeight < baseContentHeight();
 469     m_expandedTileBoundsX = (useHorzPrefetch) ? TILE_PREFETCH_DISTANCE : 0;
 470     m_expandedTileBoundsY = (useVertPrefetch) ? TILE_PREFETCH_DISTANCE : 0;
 471
 472     XLOG("drawGL, rect(%d, %d, %d, %d), viewport(%.2f, %.2f, %.2f, %.2f)",
 473          rect.x(), rect.y(), rect.width(), rect.height(),
 474          viewport.fLeft, viewport.fTop, viewport.fRight, viewport.fBottom);
 475
 476     resetLayersDirtyArea();
 477
 478     // when adding or removing layers, use the the paintingBaseLayer's tree so
 479     // that content that moves to the base layer from a layer is synchronized
 480
 481     if (scale < MIN_SCALE_WARNING || scale > MAX_SCALE_WARNING)
 482         XLOGC("WARNING, scale seems corrupted before update: %e", scale);
 483
 484     // Here before we draw, update the BaseTile which has updated content.
 485     // Inside this function, just do GPU blits from the transfer queue into
 486     // the BaseTiles' texture.
 487     TilesManager::instance()->transferQueue()->updateDirtyBaseTiles();
 488
 489     // Upload any pending ImageTexture
 490     // Return true if we still have some images to upload.
 491     // TODO: upload as many textures as possible within a certain time limit
 492     bool ret = ImagesManager::instance()->prepareTextures(this);
 493
 494     if (scale < MIN_SCALE_WARNING || scale > MAX_SCALE_WARNING)
 495         XLOGC("WARNING, scale seems corrupted after update: %e", scale);
 496
 497     // gather the textures we can use
 498     TilesManager::instance()->gatherLayerTextures();
 499
 500     double currentTime = setupDrawing(rect, viewport, webViewRect, titleBarHeight, clip, scale);
 501
 502
 503     TexturesResult nbTexturesNeeded;
 504     bool fastSwap = isScrolling() || m_layersRenderingMode == kSingleSurfaceRendering;
 505     ret |= m_treeManager.drawGL(currentTime, rect, viewport,
 506                                 scale, fastSwap,
 507                                 treesSwappedPtr, newTreeHasAnimPtr,
 508                                 &nbTexturesNeeded);
 509     if (!ret)
 510         resetFrameworkInval();
 511
 512     int nbTexturesForImages = ImagesManager::instance()->nbTextures();
 513     XLOG("*** We have %d textures for images, %d full, %d clipped, total %d / %d",
 514           nbTexturesForImages, nbTexturesNeeded.full, nbTexturesNeeded.clipped,
 515           nbTexturesNeeded.full + nbTexturesForImages,
 516           nbTexturesNeeded.clipped + nbTexturesForImages);
 517     nbTexturesNeeded.full += nbTexturesForImages;
 518     nbTexturesNeeded.clipped += nbTexturesForImages;
 519     ret |= setLayersRenderingMode(nbTexturesNeeded);
 520
 521     FloatRect extrasclip(0, 0, rect.width(), rect.height());
 522     TilesManager::instance()->shader()->clip(extrasclip);
 523
 524     m_glExtras.drawGL(webViewRect, viewport, titleBarHeight);
 525
 526     glBindBuffer(GL_ARRAY_BUFFER, 0);
 527
 528     // Clean up GL textures for video layer.
 529     TilesManager::instance()->videoLayerManager()->deleteUnusedTextures();
 530     ret |= TilesManager::instance()->invertedScreenSwitch();
 531
 532     if (ret) {
 533         // ret==true && empty inval region means we've inval'd everything,
 534         // but don't have new content. Keep redrawing full view (0,0,0,0)
 535         // until tile generation catches up and we swap pages.
 536         bool fullScreenInval = m_frameworkInval.isEmpty();
 537
 538         if (TilesManager::instance()->invertedScreenSwitch()) {
 539             fullScreenInval = true;
 540             TilesManager::instance()->setInvertedScreenSwitch(false);
 541         }
 542
 543         if (!fullScreenInval) {
 544             FloatRect frameworkInval = TilesManager::instance()->shader()->rectInInvScreenCoord(
 545                     m_frameworkInval);
 546             // Inflate the invalidate rect to avoid precision lost.
 547             frameworkInval.inflate(1);
 548             IntRect inval(frameworkInval.x(), frameworkInval.y(),
 549                     frameworkInval.width(), frameworkInval.height());
 550
 551             inval.unite(m_frameworkLayersInval);
 552
 553             invalRect->setX(inval.x());
 554             invalRect->setY(inval.y());
 555             invalRect->setWidth(inval.width());
 556             invalRect->setHeight(inval.height());
 557
 558             XLOG("invalRect(%d, %d, %d, %d)", inval.x(),
 559                     inval.y(), inval.width(), inval.height());
 560
 561             if (!invalRect->intersects(rect)) {
 562                 // invalidate is occurring offscreen, do full inval to guarantee redraw
 563                 fullScreenInval = true;
 564             }
 565         }
 566
 567         if (fullScreenInval) {
 568             invalRect->setX(0);
 569             invalRect->setY(0);
 570             invalRect->setWidth(0);
 571             invalRect->setHeight(0);
 572         }
 573     } else {
 574         resetFrameworkInval();
 575     }
 576
 577 #ifdef MEASURES_PERF
 578     if (m_measurePerfs) {
 579         m_delayTimes[m_timeCounter++] = delta;
 580         if (m_timeCounter >= MAX_MEASURES_PERF)
 581             dumpMeasures();
 582     }
 583 #endif
 584
 585 #ifdef DEBUG
 586     TilesManager::instance()->getTilesTracker()->showTrackTextures();
 587     ImagesManager::instance()->showImages();
 588 #endif
 589
 590     return ret;
 591 }
 592
 593 } // namespace WebCore
 594
 595 #endif // USE(ACCELERATED_COMPOSITING)