WebCore/page/FrameView.cpp

   1 /*
   2  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
   3  *                     1999 Lars Knoll <knoll@kde.org>
   4  *                     1999 Antti Koivisto <koivisto@kde.org>
   5  *                     2000 Dirk Mueller <mueller@kde.org>
   6  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   7  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
   8  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
   9  * Copyright (C) 2009 Google Inc. All rights reserved.
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Library General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Library General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Library General Public License
  22  * along with this library; see the file COPYING.LIB.  If not, write to
  23  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  24  * Boston, MA 02110-1301, USA.
  25  */
  26
  27 #include "config.h"
  28 #include "FrameView.h"
  29
  30 #include "AXObjectCache.h"
  31 #include "CSSStyleSelector.h"
  32 #include "Chrome.h"
  33 #include "ChromeClient.h"
  34 #include "DocLoader.h"
  35 #include "EventHandler.h"
  36 #include "FloatRect.h"
  37 #include "FocusController.h"
  38 #include "Frame.h"
  39 #include "FrameLoader.h"
  40 #include "FrameLoaderClient.h"
  41 #include "FrameTree.h"
  42 #include "GraphicsContext.h"
  43 #include "HTMLDocument.h"
  44 #include "HTMLFrameElement.h"
  45 #include "HTMLFrameSetElement.h"
  46 #include "HTMLNames.h"
  47 #include "InspectorTimelineAgent.h"
  48 #include "OverflowEvent.h"
  49 #include "RenderEmbeddedObject.h"
  50 #include "RenderLayer.h"
  51 #include "RenderPart.h"
  52 #include "RenderScrollbar.h"
  53 #include "RenderScrollbarPart.h"
  54 #include "RenderTheme.h"
  55 #include "RenderView.h"
  56 #include "Settings.h"
  57 #include "TextResourceDecoder.h"
  58 #include <wtf/CurrentTime.h>
  59
  60 #ifdef ANDROID_INSTRUMENT
  61 #include "FrameTree.h"
  62 #include "TimeCounter.h"
  63 #endif
  64
  65 #if USE(ACCELERATED_COMPOSITING)
  66 #include "RenderLayerCompositor.h"
  67 #endif
  68
  69 #if ENABLE(SVG)
  70 #include "SVGDocument.h"
  71 #include "SVGLocatable.h"
  72 #include "SVGNames.h"
  73 #include "SVGPreserveAspectRatio.h"
  74 #include "SVGSVGElement.h"
  75 #include "SVGViewElement.h"
  76 #include "SVGViewSpec.h"
  77 #endif
  78
  79 #if ENABLE(TILED_BACKING_STORE)
  80 #include "TiledBackingStore.h"
  81 #endif
  82
  83 #if PLATFORM(ANDROID)
  84 #include "WebCoreFrameBridge.h"
  85 #endif
  86
  87 namespace WebCore {
  88
  89 using namespace HTMLNames;
  90
  91 double FrameView::sCurrentPaintTimeStamp = 0.0;
  92
  93 // REPAINT_THROTTLING now chooses default values for throttling parameters.
  94 // Should be removed when applications start using runtime configuration.
  95 #if ENABLE(REPAINT_THROTTLING)
  96 // Normal delay
  97 double FrameView::s_deferredRepaintDelay = 0.025;
  98 // Negative value would mean that first few repaints happen without a delay
  99 double FrameView::s_initialDeferredRepaintDelayDuringLoading = 0;
 100 // The delay grows on each repaint to this maximum value
 101 double FrameView::s_maxDeferredRepaintDelayDuringLoading = 2.5;
 102 // On each repaint the delay increses by this amount
 103 double FrameView::s_deferredRepaintDelayIncrementDuringLoading = 0.5;
 104 #else
 105 // FIXME: Repaint throttling could be good to have on all platform.
 106 // The balance between CPU use and repaint frequency will need some tuning for desktop.
 107 // More hooks may be needed to reset the delay on things like GIF and CSS animations.
 108 double FrameView::s_deferredRepaintDelay = 0;
 109 double FrameView::s_initialDeferredRepaintDelayDuringLoading = 0;
 110 double FrameView::s_maxDeferredRepaintDelayDuringLoading = 0;
 111 double FrameView::s_deferredRepaintDelayIncrementDuringLoading = 0;
 112 #endif
 113
 114 // The maximum number of updateWidgets iterations that should be done before returning.
 115 static const unsigned maxUpdateWidgetsIterations = 2;
 116
 117 struct ScheduledEvent : Noncopyable {
 118     RefPtr<Event> m_event;
 119     RefPtr<Node> m_eventTarget;
 120 };
 121
 122 static inline float parentZoomFactor(Frame* frame)
 123 {
 124     Frame* parent = frame->tree()->parent();
 125     if (!parent)
 126         return 1;
 127     FrameView* parentView = parent->view();
 128     if (!parentView)
 129         return 1;
 130     return parentView->zoomFactor();
 131 }
 132
 133 FrameView::FrameView(Frame* frame)
 134     : m_frame(frame)
 135     , m_canHaveScrollbars(true)
 136     , m_slowRepaintObjectCount(0)
 137     , m_fixedObjectCount(0)
 138     , m_layoutTimer(this, &FrameView::layoutTimerFired)
 139     , m_layoutRoot(0)
 140     , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)
 141     , m_isTransparent(false)
 142     , m_baseBackgroundColor(Color::white)
 143     , m_mediaType("screen")
 144     , m_enqueueEvents(0)
 145     , m_overflowStatusDirty(true)
 146     , m_viewportRenderer(0)
 147     , m_wasScrolledByUser(false)
 148     , m_inProgrammaticScroll(false)
 149     , m_deferredRepaintTimer(this, &FrameView::deferredRepaintTimerFired)
 150     , m_shouldUpdateWhileOffscreen(true)
 151     , m_deferSetNeedsLayouts(0)
 152     , m_setNeedsLayoutWasDeferred(false)
 153     , m_scrollCorner(0)
 154     , m_zoomFactor(parentZoomFactor(frame))
 155 {
 156     init();
 157 }
 158
 159 PassRefPtr<FrameView> FrameView::create(Frame* frame)
 160 {
 161     RefPtr<FrameView> view = adoptRef(new FrameView(frame));
 162     view->show();
 163     return view.release();
 164 }
 165
 166 PassRefPtr<FrameView> FrameView::create(Frame* frame, const IntSize& initialSize)
 167 {
 168     RefPtr<FrameView> view = adoptRef(new FrameView(frame));
 169     view->Widget::setFrameRect(IntRect(view->pos(), initialSize));
 170     view->show();
 171     return view.release();
 172 }
 173
 174 FrameView::~FrameView()
 175 {
 176     if (m_postLayoutTasksTimer.isActive()) {
 177         m_postLayoutTasksTimer.stop();
 178         m_scheduledEvents.clear();
 179         m_enqueueEvents = 0;
 180     }
 181
 182     resetScrollbars();
 183
 184     // Custom scrollbars should already be destroyed at this point
 185     ASSERT(!horizontalScrollbar() || !horizontalScrollbar()->isCustomScrollbar());
 186     ASSERT(!verticalScrollbar() || !verticalScrollbar()->isCustomScrollbar());
 187
 188     setHasHorizontalScrollbar(false); // Remove native scrollbars now before we lose the connection to the HostWindow.
 189     setHasVerticalScrollbar(false);
 190
 191     ASSERT(!m_scrollCorner);
 192     ASSERT(m_scheduledEvents.isEmpty());
 193     ASSERT(!m_enqueueEvents);
 194
 195     if (m_frame) {
 196         ASSERT(m_frame->view() != this || !m_frame->contentRenderer());
 197         RenderPart* renderer = m_frame->ownerRenderer();
 198         if (renderer && renderer->widget() == this)
 199             renderer->setWidget(0);
 200     }
 201 }
 202
 203 void FrameView::reset()
 204 {
 205     m_useSlowRepaints = false;
 206     m_isOverlapped = false;
 207     m_contentIsOpaque = false;
 208     m_borderX = 30;
 209     m_borderY = 30;
 210     m_layoutTimer.stop();
 211     m_layoutRoot = 0;
 212     m_delayedLayout = false;
 213     m_doFullRepaint = true;
 214     m_layoutSchedulingEnabled = true;
 215     m_midLayout = false;
 216     m_layoutCount = 0;
 217     m_nestedLayoutCount = 0;
 218     m_postLayoutTasksTimer.stop();
 219     m_firstLayout = true;
 220     m_firstLayoutCallbackPending = false;
 221     m_wasScrolledByUser = false;
 222     m_lastLayoutSize = IntSize();
 223     m_lastZoomFactor = 1.0f;
 224     m_deferringRepaints = 0;
 225     m_repaintCount = 0;
 226     m_repaintRects.clear();
 227     m_deferredRepaintDelay = s_initialDeferredRepaintDelayDuringLoading;
 228     m_deferredRepaintTimer.stop();
 229     m_lastPaintTime = 0;
 230     m_paintBehavior = PaintBehaviorNormal;
 231     m_isPainting = false;
 232     m_isVisuallyNonEmpty = false;
 233     m_firstVisuallyNonEmptyLayoutCallbackPending = true;
 234     m_maintainScrollPositionAnchor = 0;
 235 }
 236
 237 bool FrameView::isFrameView() const
 238 {
 239     return true;
 240 }
 241
 242 void FrameView::clearFrame()
 243 {
 244     m_frame = 0;
 245 }
 246
 247 void FrameView::resetScrollbars()
 248 {
 249     // Reset the document's scrollbars back to our defaults before we yield the floor.
 250     m_firstLayout = true;
 251     setScrollbarsSuppressed(true);
 252     if (m_canHaveScrollbars)
 253         setScrollbarModes(ScrollbarAuto, ScrollbarAuto);
 254     else
 255         setScrollbarModes(ScrollbarAlwaysOff, ScrollbarAlwaysOff);
 256     setScrollbarsSuppressed(false);
 257 }
 258
 259 void FrameView::init()
 260 {
 261     reset();
 262
 263     m_margins = IntSize(-1, -1); // undefined
 264     m_size = IntSize();
 265
 266     // Propagate the marginwidth/height and scrolling modes to the view.
 267     Element* ownerElement = m_frame && m_frame->document() ? m_frame->document()->ownerElement() : 0;
 268     if (ownerElement && (ownerElement->hasTagName(frameTag) || ownerElement->hasTagName(iframeTag))) {
 269         HTMLFrameElement* frameElt = static_cast<HTMLFrameElement*>(ownerElement);
 270         if (frameElt->scrollingMode() == ScrollbarAlwaysOff)
 271             setCanHaveScrollbars(false);
 272         int marginWidth = frameElt->getMarginWidth();
 273         int marginHeight = frameElt->getMarginHeight();
 274         if (marginWidth != -1)
 275             setMarginWidth(marginWidth);
 276         if (marginHeight != -1)
 277             setMarginHeight(marginHeight);
 278     }
 279 }
 280
 281 void FrameView::detachCustomScrollbars()
 282 {
 283     if (!m_frame)
 284         return;
 285
 286     Scrollbar* horizontalBar = horizontalScrollbar();
 287     if (horizontalBar && horizontalBar->isCustomScrollbar())
 288         setHasHorizontalScrollbar(false);
 289
 290     Scrollbar* verticalBar = verticalScrollbar();
 291     if (verticalBar && verticalBar->isCustomScrollbar())
 292         setHasVerticalScrollbar(false);
 293
 294     if (m_scrollCorner) {
 295         m_scrollCorner->destroy();
 296         m_scrollCorner = 0;
 297     }
 298 }
 299
 300 void FrameView::clear()
 301 {
 302     setCanBlitOnScroll(true);
 303
 304     reset();
 305
 306     if (m_frame) {
 307         if (RenderPart* renderer = m_frame->ownerRenderer())
 308             renderer->viewCleared();
 309     }
 310
 311     setScrollbarsSuppressed(true);
 312 }
 313
 314 bool FrameView::didFirstLayout() const
 315 {
 316     return !m_firstLayout;
 317 }
 318
 319 void FrameView::invalidateRect(const IntRect& rect)
 320 {
 321     if (!parent()) {
 322         if (hostWindow())
 323             hostWindow()->invalidateContentsAndWindow(rect, false /*immediate*/);
 324         return;
 325     }
 326
 327     if (!m_frame)
 328         return;
 329
 330     RenderPart* renderer = m_frame->ownerRenderer();
 331     if (!renderer)
 332         return;
 333
 334     IntRect repaintRect = rect;
 335     repaintRect.move(renderer->borderLeft() + renderer->paddingLeft(),
 336                      renderer->borderTop() + renderer->paddingTop());
 337     renderer->repaintRectangle(repaintRect);
 338 }
 339
 340 void FrameView::setFrameRect(const IntRect& newRect)
 341 {
 342     IntRect oldRect = frameRect();
 343     if (newRect == oldRect)
 344         return;
 345
 346     ScrollView::setFrameRect(newRect);
 347
 348 #if USE(ACCELERATED_COMPOSITING)
 349     if (RenderView* root = m_frame->contentRenderer()) {
 350         if (root->usesCompositing())
 351             root->compositor()->frameViewDidChangeSize();
 352     }
 353 #endif
 354 }
 355
 356 void FrameView::setMarginWidth(int w)
 357 {
 358     // make it update the rendering area when set
 359     m_margins.setWidth(w);
 360 }
 361
 362 void FrameView::setMarginHeight(int h)
 363 {
 364     // make it update the rendering area when set
 365     m_margins.setHeight(h);
 366 }
 367
 368 bool FrameView::avoidScrollbarCreation()
 369 {
 370     ASSERT(m_frame);
 371
 372     // with frame flattening no subframe can have scrollbars
 373     // but we also cannot turn scrollbars of as we determine
 374     // our flattening policy using that.
 375
 376     if (!m_frame->ownerElement())
 377         return false;
 378
 379     if (!m_frame->settings() || m_frame->settings()->frameFlatteningEnabled())
 380         return true;
 381
 382     return false;
 383 }
 384
 385 void FrameView::setCanHaveScrollbars(bool canHaveScrollbars)
 386 {
 387     m_canHaveScrollbars = canHaveScrollbars;
 388     ScrollView::setCanHaveScrollbars(canHaveScrollbars);
 389 }
 390
 391 void FrameView::updateCanHaveScrollbars()
 392 {
 393     ScrollbarMode hMode;
 394     ScrollbarMode vMode;
 395     scrollbarModes(hMode, vMode);
 396     if (hMode == ScrollbarAlwaysOff && vMode == ScrollbarAlwaysOff)
 397         m_canHaveScrollbars = false;
 398     else
 399         m_canHaveScrollbars = true;
 400 }
 401
 402 PassRefPtr<Scrollbar> FrameView::createScrollbar(ScrollbarOrientation orientation)
 403 {
 404     // FIXME: We need to update the scrollbar dynamically as documents change (or as doc elements and bodies get discovered that have custom styles).
 405     Document* doc = m_frame->document();
 406
 407     // Try the <body> element first as a scrollbar source.
 408     Element* body = doc ? doc->body() : 0;
 409     if (body && body->renderer() && body->renderer()->style()->hasPseudoStyle(SCROLLBAR))
 410         return RenderScrollbar::createCustomScrollbar(this, orientation, body->renderer()->enclosingBox());
 411
 412     // If the <body> didn't have a custom style, then the root element might.
 413     Element* docElement = doc ? doc->documentElement() : 0;
 414     if (docElement && docElement->renderer() && docElement->renderer()->style()->hasPseudoStyle(SCROLLBAR))
 415         return RenderScrollbar::createCustomScrollbar(this, orientation, docElement->renderBox());
 416
 417     // If we have an owning iframe/frame element, then it can set the custom scrollbar also.
 418     RenderPart* frameRenderer = m_frame->ownerRenderer();
 419     if (frameRenderer && frameRenderer->style()->hasPseudoStyle(SCROLLBAR))
 420         return RenderScrollbar::createCustomScrollbar(this, orientation, frameRenderer);
 421
 422     // Nobody set a custom style, so we just use a native scrollbar.
 423     return ScrollView::createScrollbar(orientation);
 424 }
 425
 426 void FrameView::setContentsSize(const IntSize& size)
 427 {
 428     if (size == contentsSize())
 429         return;
 430
 431     m_deferSetNeedsLayouts++;
 432
 433     ScrollView::setContentsSize(size);
 434
 435     Page* page = frame() ? frame()->page() : 0;
 436     if (!page)
 437         return;
 438
 439     page->chrome()->contentsSizeChanged(frame(), size); //notify only
 440
 441     m_deferSetNeedsLayouts--;
 442
 443     if (!m_deferSetNeedsLayouts)
 444         m_setNeedsLayoutWasDeferred = false; // FIXME: Find a way to make the deferred layout actually happen.
 445 }
 446
 447 void FrameView::adjustViewSize()
 448 {
 449     ASSERT(m_frame->view() == this);
 450     RenderView* root = m_frame->contentRenderer();
 451     if (!root)
 452         return;
 453
 454     setContentsSize(IntSize(root->rightLayoutOverflow(), root->bottomLayoutOverflow()));
 455 }
 456
 457 void FrameView::applyOverflowToViewport(RenderObject* o, ScrollbarMode& hMode, ScrollbarMode& vMode)
 458 {
 459     // Handle the overflow:hidden/scroll case for the body/html elements.  WinIE treats
 460     // overflow:hidden and overflow:scroll on <body> as applying to the document's
 461     // scrollbars.  The CSS2.1 draft states that HTML UAs should use the <html> or <body> element and XML/XHTML UAs should
 462     // use the root element.
 463     switch (o->style()->overflowX()) {
 464         case OHIDDEN:
 465             hMode = ScrollbarAlwaysOff;
 466             break;
 467         case OSCROLL:
 468             hMode = ScrollbarAlwaysOn;
 469             break;
 470         case OAUTO:
 471             hMode = ScrollbarAuto;
 472             break;
 473         default:
 474             // Don't set it at all.
 475             ;
 476     }
 477
 478      switch (o->style()->overflowY()) {
 479         case OHIDDEN:
 480             vMode = ScrollbarAlwaysOff;
 481             break;
 482         case OSCROLL:
 483             vMode = ScrollbarAlwaysOn;
 484             break;
 485         case OAUTO:
 486             vMode = ScrollbarAuto;
 487             break;
 488         default:
 489             // Don't set it at all.
 490             ;
 491     }
 492
 493     m_viewportRenderer = o;
 494 }
 495
 496 #if USE(ACCELERATED_COMPOSITING)
 497 void FrameView::updateCompositingLayers()
 498 {
 499     RenderView* view = m_frame->contentRenderer();
 500     if (!view)
 501         return;
 502
 503     // This call will make sure the cached hasAcceleratedCompositing is updated from the pref
 504     view->compositor()->cacheAcceleratedCompositingFlags();
 505     view->compositor()->updateCompositingLayers(CompositingUpdateAfterLayoutOrStyleChange);
 506 }
 507
 508 void FrameView::setNeedsOneShotDrawingSynchronization()
 509 {
 510     Page* page = frame() ? frame()->page() : 0;
 511     if (page)
 512         page->chrome()->client()->setNeedsOneShotDrawingSynchronization();
 513 }
 514
 515 #endif // USE(ACCELERATED_COMPOSITING)
 516
 517 bool FrameView::hasCompositedContent() const
 518 {
 519 #if USE(ACCELERATED_COMPOSITING)
 520     if (RenderView* view = m_frame->contentRenderer())
 521         return view->compositor()->inCompositingMode();
 522 #endif
 523     return false;
 524 }
 525
 526 // Sometimes (for plug-ins) we need to eagerly go into compositing mode.
 527 void FrameView::enterCompositingMode()
 528 {
 529 #if USE(ACCELERATED_COMPOSITING)
 530     if (RenderView* view = m_frame->contentRenderer())
 531         view->compositor()->enableCompositingMode();
 532 #endif
 533 }
 534
 535 bool FrameView::isEnclosedInCompositingLayer() const
 536 {
 537 #if USE(ACCELERATED_COMPOSITING)
 538     RenderObject* frameOwnerRenderer = m_frame->ownerRenderer();
 539     return frameOwnerRenderer && frameOwnerRenderer->containerForRepaint();
 540 #else
 541     return false;
 542 #endif
 543 }
 544
 545 bool FrameView::syncCompositingStateRecursive()
 546 {
 547 #if USE(ACCELERATED_COMPOSITING)
 548     ASSERT(m_frame->view() == this);
 549     RenderView* contentRenderer = m_frame->contentRenderer();
 550     if (!contentRenderer)
 551         return true;    // We don't want to keep trying to update layers if we have no renderer.
 552
 553     // If we sync compositing layers when a layout is pending, we may cause painting of compositing
 554     // layer content to occur before layout has happened, which will cause paintContents() to bail.
 555     if (needsLayout())
 556         return false;
 557
 558     if (GraphicsLayer* rootLayer = contentRenderer->compositor()->rootPlatformLayer())
 559         rootLayer->syncCompositingState();
 560
 561     bool allSubframesSynced = true;
 562     const HashSet<RefPtr<Widget> >* viewChildren = children();
 563     HashSet<RefPtr<Widget> >::const_iterator end = viewChildren->end();
 564     for (HashSet<RefPtr<Widget> >::const_iterator current = viewChildren->begin(); current != end; ++current) {
 565         Widget* widget = (*current).get();
 566         if (widget->isFrameView()) {
 567             bool synced = static_cast<FrameView*>(widget)->syncCompositingStateRecursive();
 568             allSubframesSynced &= synced;
 569         }
 570     }
 571     return allSubframesSynced;
 572 #else // USE(ACCELERATED_COMPOSITING)
 573     return true;
 574 #endif
 575 }
 576
 577 bool FrameView::isSoftwareRenderable() const
 578 {
 579 #if USE(ACCELERATED_COMPOSITING)
 580     RenderView* view = m_frame->contentRenderer();
 581     if (!view)
 582         return true;
 583
 584     return !view->compositor()->has3DContent();
 585 #else
 586     return true;
 587 #endif
 588 }
 589
 590 void FrameView::didMoveOnscreen()
 591 {
 592     RenderView* view = m_frame->contentRenderer();
 593     if (view)
 594         view->didMoveOnscreen();
 595 }
 596
 597 void FrameView::willMoveOffscreen()
 598 {
 599     RenderView* view = m_frame->contentRenderer();
 600     if (view)
 601         view->willMoveOffscreen();
 602 }
 603
 604 RenderObject* FrameView::layoutRoot(bool onlyDuringLayout) const
 605 {
 606     return onlyDuringLayout && layoutPending() ? 0 : m_layoutRoot;
 607 }
 608
 609 void FrameView::layout(bool allowSubtree)
 610 {
 611     if (m_midLayout)
 612         return;
 613
 614     m_layoutTimer.stop();
 615     m_delayedLayout = false;
 616     m_setNeedsLayoutWasDeferred = false;
 617
 618     // Protect the view from being deleted during layout (in recalcStyle)
 619     RefPtr<FrameView> protector(this);
 620
 621     if (!m_frame) {
 622         // FIXME: Do we need to set m_size.width here?
 623         // FIXME: Should we set m_size.height here too?
 624         m_size.setWidth(layoutWidth());
 625         return;
 626     }
 627
 628     // we shouldn't enter layout() while painting
 629     ASSERT(!isPainting());
 630     if (isPainting())
 631         return;
 632
 633 #if ENABLE(INSPECTOR)
 634     if (InspectorTimelineAgent* timelineAgent = inspectorTimelineAgent())
 635         timelineAgent->willLayout();
 636 #endif
 637
 638     if (!allowSubtree && m_layoutRoot) {
 639         m_layoutRoot->markContainingBlocksForLayout(false);
 640         m_layoutRoot = 0;
 641     }
 642
 643     ASSERT(m_frame->view() == this);
 644     // This early return should be removed when rdar://5598072 is resolved. In the meantime, there is a
 645     // gigantic CrashTracer because of this issue, and the early return will hopefully cause graceful
 646     // failure instead.
 647     if (m_frame->view() != this)
 648         return;
 649
 650     Document* document = m_frame->document();
 651
 652     m_layoutSchedulingEnabled = false;
 653
 654     if (!m_nestedLayoutCount && m_postLayoutTasksTimer.isActive()) {
 655         // This is a new top-level layout. If there are any remaining tasks from the previous
 656         // layout, finish them now.
 657         m_postLayoutTasksTimer.stop();
 658         performPostLayoutTasks();
 659     }
 660
 661     // Viewport-dependent media queries may cause us to need completely different style information.
 662     // Check that here.
 663     if (document->styleSelector()->affectedByViewportChange())
 664         document->updateStyleSelector();
 665
 666     // Always ensure our style info is up-to-date.  This can happen in situations where
 667     // the layout beats any sort of style recalc update that needs to occur.
 668     if (m_frame->needsReapplyStyles())
 669         m_frame->reapplyStyles();
 670     else if (document->childNeedsStyleRecalc())
 671         document->recalcStyle();
 672
 673     bool subtree = m_layoutRoot;
 674
 675     // If there is only one ref to this view left, then its going to be destroyed as soon as we exit,
 676     // so there's no point to continuing to layout
 677     if (protector->hasOneRef())
 678         return;
 679
 680     RenderObject* root = subtree ? m_layoutRoot : document->renderer();
 681     if (!root) {
 682         // FIXME: Do we need to set m_size here?
 683         m_layoutSchedulingEnabled = true;
 684         return;
 685     }
 686
 687 #ifdef ANDROID_INSTRUMENT
 688     if (!m_frame->tree() || !m_frame->tree()->parent())
 689         android::TimeCounter::start(android::TimeCounter::LayoutTimeCounter);
 690 #endif
 691
 692     m_nestedLayoutCount++;
 693
 694     ScrollbarMode hMode;
 695     ScrollbarMode vMode;
 696     if (m_canHaveScrollbars) {
 697         hMode = ScrollbarAuto;
 698         vMode = ScrollbarAuto;
 699     } else {
 700         hMode = ScrollbarAlwaysOff;
 701         vMode = ScrollbarAlwaysOff;
 702     }
 703
 704     if (!subtree) {
 705         Node* documentElement = document->documentElement();
 706         RenderObject* rootRenderer = documentElement ? documentElement->renderer() : 0;
 707         Node* body = document->body();
 708         if (body && body->renderer()) {
 709             if (body->hasTagName(framesetTag) && m_frame->settings() && !m_frame->settings()->frameFlatteningEnabled()) {
 710 #if !defined(ANDROID_FLATTEN_IFRAME) && !defined(ANDROID_FLATTEN_FRAMESET)
 711                 body->renderer()->setChildNeedsLayout(true);
 712                 vMode = ScrollbarAlwaysOff;
 713                 hMode = ScrollbarAlwaysOff;
 714 #endif
 715             } else if (body->hasTagName(bodyTag)) {
 716                 if (!m_firstLayout && m_size.height() != layoutHeight() && body->renderer()->enclosingBox()->stretchesToViewHeight())
 717                     body->renderer()->setChildNeedsLayout(true);
 718                 // It's sufficient to just check the X overflow,
 719                 // since it's illegal to have visible in only one direction.
 720                 RenderObject* o = rootRenderer->style()->overflowX() == OVISIBLE && document->documentElement()->hasTagName(htmlTag) ? body->renderer() : rootRenderer;
 721                 applyOverflowToViewport(o, hMode, vMode);
 722             }
 723         } else if (rootRenderer) {
 724 #if ENABLE(SVG)
 725             if (documentElement->isSVGElement()) {
 726                 if (!m_firstLayout && (m_size.width() != layoutWidth() || m_size.height() != layoutHeight()))
 727                     rootRenderer->setChildNeedsLayout(true);
 728             } else
 729                 applyOverflowToViewport(rootRenderer, hMode, vMode);
 730 #else
 731             applyOverflowToViewport(rootRenderer, hMode, vMode);
 732 #endif
 733         }
 734 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
 735         if (m_firstLayout && !document->ownerElement())
 736             printf("Elapsed time before first layout: %d\n", document->elapsedTime());
 737 #endif
 738     }
 739
 740     m_doFullRepaint = !subtree && (m_firstLayout || toRenderView(root)->printing());
 741
 742     if (!subtree) {
 743         // Now set our scrollbar state for the layout.
 744         ScrollbarMode currentHMode = horizontalScrollbarMode();
 745         ScrollbarMode currentVMode = verticalScrollbarMode();
 746
 747         if (m_firstLayout || (hMode != currentHMode || vMode != currentVMode)) {
 748             if (m_firstLayout) {
 749                 setScrollbarsSuppressed(true);
 750
 751                 m_firstLayout = false;
 752                 m_firstLayoutCallbackPending = true;
 753                 m_lastLayoutSize = IntSize(width(), height());
 754                 m_lastZoomFactor = root->style()->zoom();
 755
 756                 // Set the initial vMode to AlwaysOn if we're auto.
 757                 if (vMode == ScrollbarAuto)
 758                     setVerticalScrollbarMode(ScrollbarAlwaysOn); // This causes a vertical scrollbar to appear.
 759                 // Set the initial hMode to AlwaysOff if we're auto.
 760                 if (hMode == ScrollbarAuto)
 761                     setHorizontalScrollbarMode(ScrollbarAlwaysOff); // This causes a horizontal scrollbar to disappear.
 762
 763                 setScrollbarModes(hMode, vMode);
 764                 setScrollbarsSuppressed(false, true);
 765             } else
 766                 setScrollbarModes(hMode, vMode);
 767         }
 768
 769         IntSize oldSize = m_size;
 770
 771         m_size = IntSize(layoutWidth(), layoutHeight());
 772
 773         if (oldSize != m_size)
 774             m_doFullRepaint = true;
 775     }
 776
 777     RenderLayer* layer = root->enclosingLayer();
 778
 779     pauseScheduledEvents();
 780
 781     bool disableLayoutState = false;
 782     if (subtree) {
 783         RenderView* view = root->view();
 784         disableLayoutState = view->shouldDisableLayoutStateForSubtree(root);
 785         view->pushLayoutState(root);
 786         if (disableLayoutState)
 787             view->disableLayoutState();
 788     }
 789
 790     m_midLayout = true;
 791     beginDeferredRepaints();
 792     root->layout();
 793     endDeferredRepaints();
 794     m_midLayout = false;
 795
 796     if (subtree) {
 797         RenderView* view = root->view();
 798         view->popLayoutState();
 799         if (disableLayoutState)
 800             view->enableLayoutState();
 801     }
 802     m_layoutRoot = 0;
 803
 804     m_frame->selection()->setNeedsLayout();
 805     m_frame->selection()->updateAppearance();
 806
 807     m_layoutSchedulingEnabled = true;
 808
 809     if (!subtree && !toRenderView(root)->printing())
 810         adjustViewSize();
 811
 812     // Now update the positions of all layers.
 813     beginDeferredRepaints();
 814     IntPoint cachedOffset;
 815     layer->updateLayerPositions((m_doFullRepaint ? RenderLayer::DoFullRepaint : 0)
 816                                 | RenderLayer::CheckForRepaint
 817                                 | RenderLayer::IsCompositingUpdateRoot
 818                                 | RenderLayer::UpdateCompositingLayers,
 819                                 subtree ? 0 : &cachedOffset);
 820     endDeferredRepaints();
 821
 822 #if USE(ACCELERATED_COMPOSITING)
 823     updateCompositingLayers();
 824 #endif
 825
 826     m_layoutCount++;
 827
 828 #if PLATFORM(MAC)
 829     if (AXObjectCache::accessibilityEnabled())
 830         root->document()->axObjectCache()->postNotification(root, AXObjectCache::AXLayoutComplete, true);
 831 #endif
 832 #if ENABLE(DASHBOARD_SUPPORT)
 833     updateDashboardRegions();
 834 #endif
 835
 836 #ifdef ANDROID_INSTRUMENT
 837     if (!m_frame->tree()->parent())
 838         android::TimeCounter::record(android::TimeCounter::LayoutTimeCounter, __FUNCTION__);
 839 #endif
 840     ASSERT(!root->needsLayout());
 841
 842     setCanBlitOnScroll(!useSlowRepaints());
 843
 844     if (document->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))
 845         updateOverflowStatus(layoutWidth() < contentsWidth(),
 846                              layoutHeight() < contentsHeight());
 847
 848     if (!m_postLayoutTasksTimer.isActive()) {
 849         // Calls resumeScheduledEvents()
 850         performPostLayoutTasks();
 851
 852         if (!m_postLayoutTasksTimer.isActive() && needsLayout()) {
 853             // Post-layout widget updates or an event handler made us need layout again.
 854             // Lay out again, but this time defer widget updates and event dispatch until after
 855             // we return.
 856             m_postLayoutTasksTimer.startOneShot(0);
 857             pauseScheduledEvents();
 858             layout();
 859         }
 860     } else {
 861         resumeScheduledEvents();
 862         ASSERT(m_enqueueEvents);
 863     }
 864
 865 #if ENABLE(INSPECTOR)
 866     if (InspectorTimelineAgent* timelineAgent = inspectorTimelineAgent())
 867         timelineAgent->didLayout();
 868 #endif
 869
 870     m_nestedLayoutCount--;
 871 }
 872
 873 void FrameView::addWidgetToUpdate(RenderEmbeddedObject* object)
 874 {
 875     if (!m_widgetUpdateSet)
 876         m_widgetUpdateSet.set(new RenderEmbeddedObjectSet);
 877
 878     m_widgetUpdateSet->add(object);
 879 }
 880
 881 void FrameView::removeWidgetToUpdate(RenderEmbeddedObject* object)
 882 {
 883     if (!m_widgetUpdateSet)
 884         return;
 885
 886     m_widgetUpdateSet->remove(object);
 887 }
 888
 889 void FrameView::setMediaType(const String& mediaType)
 890 {
 891     m_mediaType = mediaType;
 892 }
 893
 894 String FrameView::mediaType() const
 895 {
 896     // See if we have an override type.
 897     String overrideType = m_frame->loader()->client()->overrideMediaType();
 898     if (!overrideType.isNull())
 899         return overrideType;
 900     return m_mediaType;
 901 }
 902
 903 void FrameView::adjustMediaTypeForPrinting(bool printing)
 904 {
 905     if (printing) {
 906         if (m_mediaTypeWhenNotPrinting.isNull())
 907             m_mediaTypeWhenNotPrinting = mediaType();
 908             setMediaType("print");
 909     } else {
 910         if (!m_mediaTypeWhenNotPrinting.isNull())
 911             setMediaType(m_mediaTypeWhenNotPrinting);
 912         m_mediaTypeWhenNotPrinting = String();
 913     }
 914 }
 915
 916 bool FrameView::useSlowRepaints() const
 917 {
 918     return m_useSlowRepaints || m_slowRepaintObjectCount > 0 || (platformWidget() && m_fixedObjectCount > 0) || m_isOverlapped || !m_contentIsOpaque;
 919 }
 920
 921 bool FrameView::useSlowRepaintsIfNotOverlapped() const
 922 {
 923     return m_useSlowRepaints || m_slowRepaintObjectCount > 0 || (platformWidget() && m_fixedObjectCount > 0) || !m_contentIsOpaque;
 924 }
 925
 926 void FrameView::setUseSlowRepaints()
 927 {
 928     m_useSlowRepaints = true;
 929     setCanBlitOnScroll(false);
 930 }
 931
 932 void FrameView::addSlowRepaintObject()
 933 {
 934     if (!m_slowRepaintObjectCount)
 935         setCanBlitOnScroll(false);
 936     m_slowRepaintObjectCount++;
 937 }
 938
 939 void FrameView::removeSlowRepaintObject()
 940 {
 941     ASSERT(m_slowRepaintObjectCount > 0);
 942     m_slowRepaintObjectCount--;
 943     if (!m_slowRepaintObjectCount)
 944         setCanBlitOnScroll(!useSlowRepaints());
 945 }
 946
 947 void FrameView::addFixedObject()
 948 {
 949     if (!m_fixedObjectCount && platformWidget())
 950         setCanBlitOnScroll(false);
 951     ++m_fixedObjectCount;
 952 }
 953
 954 void FrameView::removeFixedObject()
 955 {
 956     ASSERT(m_fixedObjectCount > 0);
 957     --m_fixedObjectCount;
 958     if (!m_fixedObjectCount)
 959         setCanBlitOnScroll(!useSlowRepaints());
 960 }
 961
 962 bool FrameView::scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect)
 963 {
 964     const size_t fixedObjectThreshold = 5;
 965
 966     RenderBlock::PositionedObjectsListHashSet* positionedObjects = 0;
 967     if (RenderView* root = m_frame->contentRenderer())
 968         positionedObjects = root->positionedObjects();
 969
 970     if (!positionedObjects || positionedObjects->isEmpty()) {
 971         hostWindow()->scroll(scrollDelta, rectToScroll, clipRect);
 972         return true;
 973     }
 974
 975     // Get the rects of the fixed objects visible in the rectToScroll
 976     Vector<IntRect, fixedObjectThreshold> subRectToUpdate;
 977     bool updateInvalidatedSubRect = true;
 978     RenderBlock::PositionedObjectsListHashSet::const_iterator end = positionedObjects->end();
 979     for (RenderBlock::PositionedObjectsListHashSet::const_iterator it = positionedObjects->begin(); it != end; ++it) {
 980         RenderBox* renderBox = *it;
 981         if (renderBox->style()->position() != FixedPosition)
 982             continue;
 983         IntRect updateRect = renderBox->layer()->repaintRectIncludingDescendants();
 984         updateRect = contentsToWindow(updateRect);
 985
 986         updateRect.intersect(rectToScroll);
 987         if (!updateRect.isEmpty()) {
 988             if (subRectToUpdate.size() >= fixedObjectThreshold) {
 989                 updateInvalidatedSubRect = false;
 990                 break;
 991             }
 992             subRectToUpdate.append(updateRect);
 993         }
 994     }
 995
 996     // Scroll the view
 997     if (updateInvalidatedSubRect) {
 998         // 1) scroll
 999         hostWindow()->scroll(scrollDelta, rectToScroll, clipRect);
1000
1001         // 2) update the area of fixed objects that has been invalidated
1002         size_t fixObjectsCount = subRectToUpdate.size();
1003         for (size_t i = 0; i < fixObjectsCount; ++i) {
1004             IntRect updateRect = subRectToUpdate[i];
1005             IntRect scrolledRect = updateRect;
1006             scrolledRect.move(scrollDelta);
1007             updateRect.unite(scrolledRect);
1008             updateRect.intersect(rectToScroll);
1009             hostWindow()->invalidateContentsAndWindow(updateRect, false);
1010         }
1011         return true;
1012     }
1013
1014     // the number of fixed objects exceed the threshold, we cannot use the fast path
1015     return false;
1016 }
1017
1018 void FrameView::setIsOverlapped(bool isOverlapped)
1019 {
1020     if (isOverlapped == m_isOverlapped)
1021         return;
1022
1023     m_isOverlapped = isOverlapped;
1024     setCanBlitOnScroll(!useSlowRepaints());
1025
1026 #if USE(ACCELERATED_COMPOSITING)
1027     // Overlap can affect compositing tests, so if it changes, we need to trigger
1028     // a recalcStyle in the parent document.
1029     if (hasCompositedContent()) {
1030         if (Element* ownerElement = m_frame->document()->ownerElement())
1031             ownerElement->setNeedsStyleRecalc(SyntheticStyleChange);
1032     }
1033 #endif
1034 }
1035
1036 void FrameView::setContentIsOpaque(bool contentIsOpaque)
1037 {
1038     if (contentIsOpaque == m_contentIsOpaque)
1039         return;
1040
1041     m_contentIsOpaque = contentIsOpaque;
1042     setCanBlitOnScroll(!useSlowRepaints());
1043 }
1044
1045 void FrameView::restoreScrollbar()
1046 {
1047     setScrollbarsSuppressed(false);
1048 }
1049
1050 bool FrameView::scrollToFragment(const KURL& url)
1051 {
1052     // If our URL has no ref, then we have no place we need to jump to.
1053     // OTOH If CSS target was set previously, we want to set it to 0, recalc
1054     // and possibly repaint because :target pseudo class may have been
1055     // set (see bug 11321).
1056     if (!url.hasFragmentIdentifier() && !m_frame->document()->cssTarget())
1057         return false;
1058
1059     String fragmentIdentifier = url.fragmentIdentifier();
1060     if (scrollToAnchor(fragmentIdentifier))
1061         return true;
1062
1063     // Try again after decoding the ref, based on the document's encoding.
1064     if (TextResourceDecoder* decoder = m_frame->document()->decoder())
1065         return scrollToAnchor(decodeURLEscapeSequences(fragmentIdentifier, decoder->encoding()));
1066
1067     return false;
1068 }
1069
1070 bool FrameView::scrollToAnchor(const String& name)
1071 {
1072     ASSERT(m_frame->document());
1073
1074     if (!m_frame->document()->haveStylesheetsLoaded()) {
1075         m_frame->document()->setGotoAnchorNeededAfterStylesheetsLoad(true);
1076         return false;
1077     }
1078
1079     m_frame->document()->setGotoAnchorNeededAfterStylesheetsLoad(false);
1080
1081     Element* anchorNode = m_frame->document()->findAnchor(name);
1082
1083 #if ENABLE(SVG)
1084     if (m_frame->document()->isSVGDocument()) {
1085         if (name.startsWith("xpointer(")) {
1086             // We need to parse the xpointer reference here
1087         } else if (name.startsWith("svgView(")) {
1088             RefPtr<SVGSVGElement> svg = static_cast<SVGDocument*>(m_frame->document())->rootElement();
1089             if (!svg->currentView()->parseViewSpec(name))
1090                 return false;
1091             svg->setUseCurrentView(true);
1092         } else {
1093             if (anchorNode && anchorNode->hasTagName(SVGNames::viewTag)) {
1094                 RefPtr<SVGViewElement> viewElement = anchorNode->hasTagName(SVGNames::viewTag) ? static_cast<SVGViewElement*>(anchorNode) : 0;
1095                 if (viewElement.get()) {
1096                     RefPtr<SVGSVGElement> svg = static_cast<SVGSVGElement*>(SVGLocatable::nearestViewportElement(viewElement.get()));
1097                     svg->inheritViewAttributes(viewElement.get());
1098                 }
1099             }
1100         }
1101         // FIXME: need to decide which <svg> to focus on, and zoom to that one
1102         // FIXME: need to actually "highlight" the viewTarget(s)
1103     }
1104 #endif
1105
1106     m_frame->document()->setCSSTarget(anchorNode); // Setting to null will clear the current target.
1107
1108     // Implement the rule that "" and "top" both mean top of page as in other browsers.
1109     if (!anchorNode && !(name.isEmpty() || equalIgnoringCase(name, "top")))
1110         return false;
1111
1112 #ifdef ANDROID_SCROLL_ON_GOTO_ANCHOR
1113     // TODO(andreip): check with Grace if this is correct.
1114     android::WebFrame::getWebFrame(m_frame.get())->setUserInitiatedClick(true);
1115 #endif
1116     maintainScrollPositionAtAnchor(anchorNode ? static_cast<Node*>(anchorNode) : m_frame->document());
1117 #ifdef ANDROID_SCROLL_ON_GOTO_ANCHOR
1118     android::WebFrame::getWebFrame(m_frame.get())->setUserInitiatedClick(false);
1119 #endif
1120     return true;
1121 }
1122
1123 void FrameView::maintainScrollPositionAtAnchor(Node* anchorNode)
1124 {
1125     m_maintainScrollPositionAnchor = anchorNode;
1126     if (!m_maintainScrollPositionAnchor)
1127         return;
1128
1129     // We need to update the layout before scrolling, otherwise we could
1130     // really mess things up if an anchor scroll comes at a bad moment.
1131     m_frame->document()->updateStyleIfNeeded();
1132     // Only do a layout if changes have occurred that make it necessary.
1133     if (m_frame->contentRenderer() && m_frame->contentRenderer()->needsLayout())
1134         layout();
1135     else
1136         scrollToAnchor();
1137 }
1138
1139 void FrameView::setScrollPosition(const IntPoint& scrollPoint)
1140 {
1141     bool wasInProgrammaticScroll = m_inProgrammaticScroll;
1142     m_inProgrammaticScroll = true;
1143     m_maintainScrollPositionAnchor = 0;
1144     ScrollView::setScrollPosition(scrollPoint);
1145     m_inProgrammaticScroll = wasInProgrammaticScroll;
1146 }
1147
1148 void FrameView::scrollPositionChangedViaPlatformWidget()
1149 {
1150     scrollPositionChanged();
1151 }
1152
1153 void FrameView::scrollPositionChanged()
1154 {
1155     frame()->eventHandler()->sendScrollEvent();
1156     repaintFixedElementsAfterScrolling();
1157
1158 #if USE(ACCELERATED_COMPOSITING)
1159     if (RenderView* root = m_frame->contentRenderer()) {
1160         if (root->usesCompositing())
1161             root->compositor()->frameViewDidScroll(scrollPosition());
1162     }
1163 #endif
1164 }
1165
1166 void FrameView::repaintFixedElementsAfterScrolling()
1167 {
1168     // For fixed position elements, update widget positions and compositing layers after scrolling,
1169     // but only if we're not inside of layout.
1170     if (!m_nestedLayoutCount && hasFixedObjects()) {
1171         if (RenderView* root = m_frame->contentRenderer()) {
1172             root->updateWidgetPositions();
1173             root->layer()->updateRepaintRectsAfterScroll();
1174 #if USE(ACCELERATED_COMPOSITING)
1175             root->compositor()->updateCompositingLayers(CompositingUpdateOnScroll);
1176 #endif
1177         }
1178     }
1179 }
1180
1181 HostWindow* FrameView::hostWindow() const
1182 {
1183     Page* page = frame() ? frame()->page() : 0;
1184     if (!page)
1185         return 0;
1186     return page->chrome();
1187 }
1188
1189 const unsigned cRepaintRectUnionThreshold = 25;
1190
1191 void FrameView::repaintContentRectangle(const IntRect& r, bool immediate)
1192 {
1193     ASSERT(!m_frame->document()->ownerElement());
1194
1195     double delay = adjustedDeferredRepaintDelay();
1196     if ((m_deferringRepaints || m_deferredRepaintTimer.isActive() || delay) && !immediate) {
1197         IntRect paintRect = r;
1198         if (!paintsEntireContents())
1199             paintRect.intersect(visibleContentRect());
1200 #ifdef ANDROID_CAPTURE_OFFSCREEN_PAINTS
1201         if (r != paintRect)
1202             ScrollView::platformOffscreenContentRectangle(visibleContentRect(), r);
1203 #endif
1204         if (paintRect.isEmpty())
1205             return;
1206         if (m_repaintCount == cRepaintRectUnionThreshold) {
1207             IntRect unionedRect;
1208             for (unsigned i = 0; i < cRepaintRectUnionThreshold; ++i)
1209                 unionedRect.unite(m_repaintRects[i]);
1210             m_repaintRects.clear();
1211             m_repaintRects.append(unionedRect);
1212         }
1213         if (m_repaintCount < cRepaintRectUnionThreshold)
1214             m_repaintRects.append(paintRect);
1215         else
1216             m_repaintRects[0].unite(paintRect);
1217         m_repaintCount++;
1218
1219         if (!m_deferringRepaints && !m_deferredRepaintTimer.isActive())
1220              m_deferredRepaintTimer.startOneShot(delay);
1221         return;
1222     }
1223
1224     if (!immediate && isOffscreen() && !shouldUpdateWhileOffscreen())
1225         return;
1226
1227 #if ENABLE(TILED_BACKING_STORE)
1228     if (frame()->tiledBackingStore()) {
1229         frame()->tiledBackingStore()->invalidate(r);
1230         return;
1231     }
1232 #endif
1233     ScrollView::repaintContentRectangle(r, immediate);
1234 }
1235
1236 void FrameView::visibleContentsResized()
1237 {
1238     // We check to make sure the view is attached to a frame() as this method can
1239     // be triggered before the view is attached by Frame::createView(...) setting
1240     // various values such as setScrollBarModes(...) for example.  An ASSERT is
1241     // triggered when a view is layout before being attached to a frame().
1242     if (!frame()->view())
1243         return;
1244
1245     if (needsLayout())
1246         layout();
1247 }
1248
1249 void FrameView::beginDeferredRepaints()
1250 {
1251     Page* page = m_frame->page();
1252     if (page->mainFrame() != m_frame)
1253         return page->mainFrame()->view()->beginDeferredRepaints();
1254
1255     m_deferringRepaints++;
1256 }
1257
1258
1259 void FrameView::endDeferredRepaints()
1260 {
1261     Page* page = m_frame->page();
1262     if (page->mainFrame() != m_frame)
1263         return page->mainFrame()->view()->endDeferredRepaints();
1264
1265     ASSERT(m_deferringRepaints > 0);
1266
1267     if (--m_deferringRepaints)
1268         return;
1269
1270     if (m_deferredRepaintTimer.isActive())
1271         return;
1272
1273     if (double delay = adjustedDeferredRepaintDelay()) {
1274         m_deferredRepaintTimer.startOneShot(delay);
1275         return;
1276     }
1277
1278     doDeferredRepaints();
1279 }
1280
1281 void FrameView::checkStopDelayingDeferredRepaints()
1282 {
1283     if (!m_deferredRepaintTimer.isActive())
1284         return;
1285
1286     Document* document = m_frame->document();
1287     if (document && (document->parsing() || document->docLoader()->requestCount()))
1288         return;
1289
1290     m_deferredRepaintTimer.stop();
1291
1292     doDeferredRepaints();
1293 }
1294
1295 void FrameView::doDeferredRepaints()
1296 {
1297     ASSERT(!m_deferringRepaints);
1298     if (isOffscreen() && !shouldUpdateWhileOffscreen()) {
1299         m_repaintRects.clear();
1300         m_repaintCount = 0;
1301         return;
1302     }
1303     unsigned size = m_repaintRects.size();
1304     for (unsigned i = 0; i < size; i++) {
1305 #if ENABLE(TILED_BACKING_STORE)
1306         if (frame()->tiledBackingStore()) {
1307             frame()->tiledBackingStore()->invalidate(m_repaintRects[i]);
1308             continue;
1309         }
1310 #endif
1311         ScrollView::repaintContentRectangle(m_repaintRects[i], false);
1312     }
1313     m_repaintRects.clear();
1314     m_repaintCount = 0;
1315
1316     updateDeferredRepaintDelay();
1317 }
1318
1319 void FrameView::updateDeferredRepaintDelay()
1320 {
1321     Document* document = m_frame->document();
1322     if (!document || (!document->parsing() && !document->docLoader()->requestCount())) {
1323         m_deferredRepaintDelay = s_deferredRepaintDelay;
1324         return;
1325     }
1326     if (m_deferredRepaintDelay < s_maxDeferredRepaintDelayDuringLoading) {
1327         m_deferredRepaintDelay += s_deferredRepaintDelayIncrementDuringLoading;
1328         if (m_deferredRepaintDelay > s_maxDeferredRepaintDelayDuringLoading)
1329             m_deferredRepaintDelay = s_maxDeferredRepaintDelayDuringLoading;
1330     }
1331 }
1332
1333 void FrameView::resetDeferredRepaintDelay()
1334 {
1335     m_deferredRepaintDelay = 0;
1336     if (m_deferredRepaintTimer.isActive()) {
1337         m_deferredRepaintTimer.stop();
1338         if (!m_deferringRepaints)
1339             doDeferredRepaints();
1340     }
1341 }
1342
1343 double FrameView::adjustedDeferredRepaintDelay() const
1344 {
1345     if (!m_deferredRepaintDelay)
1346         return 0;
1347     double timeSinceLastPaint = currentTime() - m_lastPaintTime;
1348     return max(0., m_deferredRepaintDelay - timeSinceLastPaint);
1349 }
1350
1351 void FrameView::deferredRepaintTimerFired(Timer<FrameView>*)
1352 {
1353     doDeferredRepaints();
1354 }
1355
1356 void FrameView::layoutTimerFired(Timer<FrameView>*)
1357 {
1358 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1359     if (!m_frame->document()->ownerElement())
1360         printf("Layout timer fired at %d\n", m_frame->document()->elapsedTime());
1361 #endif
1362     layout();
1363 }
1364
1365 void FrameView::scheduleRelayout()
1366 {
1367     // FIXME: We should assert the page is not in the page cache, but that is causing
1368     // too many false assertions.  See <rdar://problem/7218118>.
1369     ASSERT(m_frame->view() == this);
1370
1371     if (m_layoutRoot) {
1372         m_layoutRoot->markContainingBlocksForLayout(false);
1373         m_layoutRoot = 0;
1374     }
1375     if (!m_layoutSchedulingEnabled)
1376         return;
1377     if (!needsLayout())
1378         return;
1379     if (!m_frame->document()->shouldScheduleLayout())
1380         return;
1381
1382 #if defined(ANDROID_FLATTEN_IFRAME) || defined(ANDROID_FLATTEN_FRAMESET)
1383     // This is the Android frame flattening code. The common code below is not
1384     // used as frameSetFlatteningEnabled() is false on Android.
1385     if (m_frame->ownerRenderer())
1386         m_frame->ownerRenderer()->setNeedsLayoutAndPrefWidthsRecalc();
1387 #endif
1388
1389     // When frame flattening is enabled, the contents of the frame affects layout of the parent frames.
1390     // Also invalidate parent frame starting from the owner element of this frame.
1391     if (m_frame->settings() && m_frame->settings()->frameFlatteningEnabled() && m_frame->ownerRenderer()) {
1392         if (m_frame->ownerElement()->hasTagName(iframeTag) || m_frame->ownerElement()->hasTagName(frameTag))
1393             m_frame->ownerRenderer()->setNeedsLayout(true, true);
1394     }
1395
1396     int delay = m_frame->document()->minimumLayoutDelay();
1397     if (m_layoutTimer.isActive() && m_delayedLayout && !delay)
1398         unscheduleRelayout();
1399     if (m_layoutTimer.isActive())
1400         return;
1401
1402     m_delayedLayout = delay != 0;
1403
1404 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1405     if (!m_frame->document()->ownerElement())
1406         printf("Scheduling layout for %d\n", delay);
1407 #endif
1408
1409     m_layoutTimer.startOneShot(delay * 0.001);
1410 }
1411
1412 static bool isObjectAncestorContainerOf(RenderObject* ancestor, RenderObject* descendant)
1413 {
1414     for (RenderObject* r = descendant; r; r = r->container()) {
1415         if (r == ancestor)
1416             return true;
1417     }
1418     return false;
1419 }
1420
1421 void FrameView::scheduleRelayoutOfSubtree(RenderObject* relayoutRoot)
1422 {
1423     ASSERT(m_frame->view() == this);
1424
1425     if (m_frame->contentRenderer() && m_frame->contentRenderer()->needsLayout()) {
1426         if (relayoutRoot)
1427             relayoutRoot->markContainingBlocksForLayout(false);
1428         return;
1429     }
1430
1431     if (layoutPending() || !m_layoutSchedulingEnabled) {
1432         if (m_layoutRoot != relayoutRoot) {
1433             if (isObjectAncestorContainerOf(m_layoutRoot, relayoutRoot)) {
1434                 // Keep the current root
1435                 relayoutRoot->markContainingBlocksForLayout(false, m_layoutRoot);
1436             } else if (m_layoutRoot && isObjectAncestorContainerOf(relayoutRoot, m_layoutRoot)) {
1437                 // Re-root at relayoutRoot
1438                 m_layoutRoot->markContainingBlocksForLayout(false, relayoutRoot);
1439                 m_layoutRoot = relayoutRoot;
1440             } else {
1441                 // Just do a full relayout
1442                 if (m_layoutRoot)
1443                     m_layoutRoot->markContainingBlocksForLayout(false);
1444                 m_layoutRoot = 0;
1445                 relayoutRoot->markContainingBlocksForLayout(false);
1446             }
1447         }
1448     } else if (m_layoutSchedulingEnabled) {
1449         int delay = m_frame->document()->minimumLayoutDelay();
1450         m_layoutRoot = relayoutRoot;
1451         m_delayedLayout = delay != 0;
1452         m_layoutTimer.startOneShot(delay * 0.001);
1453     }
1454 }
1455
1456 bool FrameView::layoutPending() const
1457 {
1458     return m_layoutTimer.isActive();
1459 }
1460
1461 bool FrameView::needsLayout() const
1462 {
1463     // This can return true in cases where the document does not have a body yet.
1464     // Document::shouldScheduleLayout takes care of preventing us from scheduling
1465     // layout in that case.
1466     if (!m_frame)
1467         return false;
1468     RenderView* root = m_frame->contentRenderer();
1469     Document* document = m_frame->document();
1470     return layoutPending()
1471         || (root && root->needsLayout())
1472         || m_layoutRoot
1473         || (document && document->childNeedsStyleRecalc()) // can occur when using WebKit ObjC interface
1474         || m_frame->needsReapplyStyles()
1475         || (m_deferSetNeedsLayouts && m_setNeedsLayoutWasDeferred);
1476 }
1477
1478 void FrameView::setNeedsLayout()
1479 {
1480     if (m_deferSetNeedsLayouts) {
1481         m_setNeedsLayoutWasDeferred = true;
1482         return;
1483     }
1484     RenderView* root = m_frame->contentRenderer();
1485     if (root)
1486         root->setNeedsLayout(true);
1487 }
1488
1489 void FrameView::unscheduleRelayout()
1490 {
1491     if (!m_layoutTimer.isActive())
1492         return;
1493
1494 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1495     if (!m_frame->document()->ownerElement())
1496         printf("Layout timer unscheduled at %d\n", m_frame->document()->elapsedTime());
1497 #endif
1498
1499     m_layoutTimer.stop();
1500     m_delayedLayout = false;
1501 }
1502
1503 bool FrameView::isTransparent() const
1504 {
1505     return m_isTransparent;
1506 }
1507
1508 void FrameView::setTransparent(bool isTransparent)
1509 {
1510     m_isTransparent = isTransparent;
1511 }
1512
1513 Color FrameView::baseBackgroundColor() const
1514 {
1515     return m_baseBackgroundColor;
1516 }
1517
1518 void FrameView::setBaseBackgroundColor(Color bc)
1519 {
1520     if (!bc.isValid())
1521         bc = Color::white;
1522     m_baseBackgroundColor = bc;
1523 }
1524
1525 void FrameView::updateBackgroundRecursively(const Color& backgroundColor, bool transparent)
1526 {
1527     for (Frame* frame = m_frame.get(); frame; frame = frame->tree()->traverseNext(m_frame.get())) {
1528         FrameView* view = frame->view();
1529         if (!view)
1530             continue;
1531
1532         view->setTransparent(transparent);
1533         view->setBaseBackgroundColor(backgroundColor);
1534     }
1535 }
1536
1537 bool FrameView::shouldUpdateWhileOffscreen() const
1538 {
1539     return m_shouldUpdateWhileOffscreen;
1540 }
1541
1542 void FrameView::setShouldUpdateWhileOffscreen(bool shouldUpdateWhileOffscreen)
1543 {
1544     m_shouldUpdateWhileOffscreen = shouldUpdateWhileOffscreen;
1545 }
1546
1547 void FrameView::scheduleEvent(PassRefPtr<Event> event, PassRefPtr<Node> eventTarget)
1548 {
1549     if (!m_enqueueEvents) {
1550         ExceptionCode ec = 0;
1551         eventTarget->dispatchEvent(event, ec);
1552         return;
1553     }
1554
1555     ScheduledEvent* scheduledEvent = new ScheduledEvent;
1556     scheduledEvent->m_event = event;
1557     scheduledEvent->m_eventTarget = eventTarget;
1558     m_scheduledEvents.append(scheduledEvent);
1559 }
1560
1561 void FrameView::pauseScheduledEvents()
1562 {
1563     ASSERT(m_scheduledEvents.isEmpty() || m_enqueueEvents);
1564     m_enqueueEvents++;
1565 }
1566
1567 void FrameView::resumeScheduledEvents()
1568 {
1569     m_enqueueEvents--;
1570     if (!m_enqueueEvents)
1571         dispatchScheduledEvents();
1572     ASSERT(m_scheduledEvents.isEmpty() || m_enqueueEvents);
1573 }
1574
1575 void FrameView::scrollToAnchor()
1576 {
1577     RefPtr<Node> anchorNode = m_maintainScrollPositionAnchor;
1578     if (!anchorNode)
1579         return;
1580
1581     if (!anchorNode->renderer())
1582         return;
1583
1584     IntRect rect;
1585     if (anchorNode != m_frame->document())
1586         rect = anchorNode->getRect();
1587
1588     // Scroll nested layers and frames to reveal the anchor.
1589     // Align to the top and to the closest side (this matches other browsers).
1590     anchorNode->renderer()->enclosingLayer()->scrollRectToVisible(rect, true, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignTopAlways);
1591
1592     if (AXObjectCache::accessibilityEnabled())
1593         m_frame->document()->axObjectCache()->handleScrolledToAnchor(anchorNode.get());
1594
1595     // scrollRectToVisible can call into setScrollPosition(), which resets m_maintainScrollPositionAnchor.
1596     m_maintainScrollPositionAnchor = anchorNode;
1597 }
1598
1599 bool FrameView::updateWidgets()
1600 {
1601     if (m_nestedLayoutCount > 1 || !m_widgetUpdateSet || m_widgetUpdateSet->isEmpty())
1602         return true;
1603
1604     size_t size = m_widgetUpdateSet->size();
1605
1606     Vector<RenderEmbeddedObject*> objects;
1607     objects.reserveCapacity(size);
1608
1609     RenderEmbeddedObjectSet::const_iterator end = m_widgetUpdateSet->end();
1610     for (RenderEmbeddedObjectSet::const_iterator it = m_widgetUpdateSet->begin(); it != end; ++it) {
1611         objects.uncheckedAppend(*it);
1612         (*it)->ref();
1613     }
1614
1615     for (size_t i = 0; i < size; ++i) {
1616         RenderEmbeddedObject* object = objects[i];
1617
1618         // The object may have been destroyed, but our manual ref() keeps the object from being deleted.
1619         object->updateWidget(false);
1620         object->updateWidgetPosition();
1621
1622         m_widgetUpdateSet->remove(object);
1623     }
1624
1625     RenderArena* arena = m_frame->document()->renderArena();
1626     for (size_t i = 0; i < size; ++i)
1627         objects[i]->deref(arena);
1628
1629     return m_widgetUpdateSet->isEmpty();
1630 }
1631
1632 void FrameView::performPostLayoutTasks()
1633 {
1634     if (m_firstLayoutCallbackPending) {
1635         m_firstLayoutCallbackPending = false;
1636         m_frame->loader()->didFirstLayout();
1637     }
1638
1639     if (m_isVisuallyNonEmpty && m_firstVisuallyNonEmptyLayoutCallbackPending) {
1640         m_firstVisuallyNonEmptyLayoutCallbackPending = false;
1641         m_frame->loader()->didFirstVisuallyNonEmptyLayout();
1642     }
1643
1644     RenderView* root = m_frame->contentRenderer();
1645
1646     root->updateWidgetPositions();
1647
1648     for (unsigned i = 0; i < maxUpdateWidgetsIterations; i++) {
1649         if (updateWidgets())
1650             break;
1651     }
1652
1653     scrollToAnchor();
1654
1655     resumeScheduledEvents();
1656
1657     if (!root->printing()) {
1658         IntSize currentSize = IntSize(width(), height());
1659         float currentZoomFactor = root->style()->zoom();
1660         bool resized = !m_firstLayout && (currentSize != m_lastLayoutSize || currentZoomFactor != m_lastZoomFactor);
1661         m_lastLayoutSize = currentSize;
1662         m_lastZoomFactor = currentZoomFactor;
1663         if (resized)
1664             m_frame->eventHandler()->sendResizeEvent();
1665     }
1666 }
1667
1668 void FrameView::postLayoutTimerFired(Timer<FrameView>*)
1669 {
1670     performPostLayoutTasks();
1671 }
1672
1673 void FrameView::updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow)
1674 {
1675     if (!m_viewportRenderer)
1676         return;
1677
1678     if (m_overflowStatusDirty) {
1679         m_horizontalOverflow = horizontalOverflow;
1680         m_verticalOverflow = verticalOverflow;
1681         m_overflowStatusDirty = false;
1682         return;
1683     }
1684
1685     bool horizontalOverflowChanged = (m_horizontalOverflow != horizontalOverflow);
1686     bool verticalOverflowChanged = (m_verticalOverflow != verticalOverflow);
1687
1688     if (horizontalOverflowChanged || verticalOverflowChanged) {
1689         m_horizontalOverflow = horizontalOverflow;
1690         m_verticalOverflow = verticalOverflow;
1691
1692         scheduleEvent(OverflowEvent::create(horizontalOverflowChanged, horizontalOverflow,
1693             verticalOverflowChanged, verticalOverflow),
1694             m_viewportRenderer->node());
1695     }
1696
1697 }
1698
1699 void FrameView::dispatchScheduledEvents()
1700 {
1701     if (m_scheduledEvents.isEmpty())
1702         return;
1703
1704     Vector<ScheduledEvent*> scheduledEventsCopy = m_scheduledEvents;
1705     m_scheduledEvents.clear();
1706
1707     Vector<ScheduledEvent*>::iterator end = scheduledEventsCopy.end();
1708     for (Vector<ScheduledEvent*>::iterator it = scheduledEventsCopy.begin(); it != end; ++it) {
1709         ScheduledEvent* scheduledEvent = *it;
1710
1711         ExceptionCode ec = 0;
1712
1713         // Only dispatch events to nodes that are in the document
1714         if (scheduledEvent->m_eventTarget->inDocument())
1715             scheduledEvent->m_eventTarget->dispatchEvent(scheduledEvent->m_event, ec);
1716
1717         delete scheduledEvent;
1718     }
1719 }
1720
1721 IntRect FrameView::windowClipRect(bool clipToContents) const
1722 {
1723     ASSERT(m_frame->view() == this);
1724
1725     // Set our clip rect to be our contents.
1726     IntRect clipRect = contentsToWindow(visibleContentRect(!clipToContents));
1727     if (!m_frame || !m_frame->document() || !m_frame->document()->ownerElement())
1728         return clipRect;
1729
1730     // Take our owner element and get the clip rect from the enclosing layer.
1731     Element* elt = m_frame->document()->ownerElement();
1732     RenderLayer* layer = elt->renderer()->enclosingLayer();
1733     // FIXME: layer should never be null, but sometimes seems to be anyway.
1734     if (!layer)
1735         return clipRect;
1736     FrameView* parentView = elt->document()->view();
1737     clipRect.intersect(parentView->windowClipRectForLayer(layer, true));
1738     return clipRect;
1739 }
1740
1741 IntRect FrameView::windowClipRectForLayer(const RenderLayer* layer, bool clipToLayerContents) const
1742 {
1743     // If we have no layer, just return our window clip rect.
1744     if (!layer)
1745         return windowClipRect();
1746
1747     // Apply the clip from the layer.
1748     IntRect clipRect;
1749     if (clipToLayerContents)
1750         clipRect = layer->childrenClipRect();
1751     else
1752         clipRect = layer->selfClipRect();
1753     clipRect = contentsToWindow(clipRect);
1754     return intersection(clipRect, windowClipRect());
1755 }
1756
1757 bool FrameView::isActive() const
1758 {
1759     Page* page = frame()->page();
1760     return page && page->focusController()->isActive();
1761 }
1762
1763 void FrameView::valueChanged(Scrollbar* bar)
1764 {
1765     // Figure out if we really moved.
1766     IntSize offset = scrollOffset();
1767     ScrollView::valueChanged(bar);
1768     if (offset != scrollOffset())
1769         scrollPositionChanged();
1770     frame()->loader()->client()->didChangeScrollOffset();
1771 }
1772
1773 void FrameView::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
1774 {
1775     // Add in our offset within the FrameView.
1776     IntRect dirtyRect = rect;
1777     dirtyRect.move(scrollbar->x(), scrollbar->y());
1778     invalidateRect(dirtyRect);
1779 }
1780
1781 void FrameView::getTickmarks(Vector<IntRect>& tickmarks) const
1782 {
1783     tickmarks = frame()->document()->renderedRectsForMarkers(DocumentMarker::TextMatch);
1784 }
1785
1786 IntRect FrameView::windowResizerRect() const
1787 {
1788     Page* page = frame() ? frame()->page() : 0;
1789     if (!page)
1790         return IntRect();
1791     return page->chrome()->windowResizerRect();
1792 }
1793
1794 #if ENABLE(DASHBOARD_SUPPORT)
1795 void FrameView::updateDashboardRegions()
1796 {
1797     Document* document = m_frame->document();
1798     if (!document->hasDashboardRegions())
1799         return;
1800     Vector<DashboardRegionValue> newRegions;
1801     document->renderBox()->collectDashboardRegions(newRegions);
1802     if (newRegions == document->dashboardRegions())
1803         return;
1804     document->setDashboardRegions(newRegions);
1805     Page* page = m_frame->page();
1806     if (!page)
1807         return;
1808     page->chrome()->client()->dashboardRegionsChanged();
1809 }
1810 #endif
1811
1812 void FrameView::invalidateScrollCorner()
1813 {
1814     invalidateRect(scrollCornerRect());
1815 }
1816
1817 void FrameView::updateScrollCorner()
1818 {
1819     RenderObject* renderer = 0;
1820     RefPtr<RenderStyle> cornerStyle;
1821
1822     if (!scrollCornerRect().isEmpty()) {
1823         // Try the <body> element first as a scroll corner source.
1824         Document* doc = m_frame->document();
1825         Element* body = doc ? doc->body() : 0;
1826         if (body && body->renderer()) {
1827             renderer = body->renderer();
1828             cornerStyle = renderer->getUncachedPseudoStyle(SCROLLBAR_CORNER, renderer->style());
1829         }
1830
1831         if (!cornerStyle) {
1832             // If the <body> didn't have a custom style, then the root element might.
1833             Element* docElement = doc ? doc->documentElement() : 0;
1834             if (docElement && docElement->renderer()) {
1835                 renderer = docElement->renderer();
1836                 cornerStyle = renderer->getUncachedPseudoStyle(SCROLLBAR_CORNER, renderer->style());
1837             }
1838         }
1839
1840         if (!cornerStyle) {
1841             // If we have an owning iframe/frame element, then it can set the custom scrollbar also.
1842             if (RenderPart* renderer = m_frame->ownerRenderer())
1843                 cornerStyle = renderer->getUncachedPseudoStyle(SCROLLBAR_CORNER, renderer->style());
1844         }
1845     }
1846
1847     if (cornerStyle) {
1848         if (!m_scrollCorner)
1849             m_scrollCorner = new (renderer->renderArena()) RenderScrollbarPart(renderer->document());
1850         m_scrollCorner->setStyle(cornerStyle.release());
1851         invalidateRect(scrollCornerRect());
1852     } else if (m_scrollCorner) {
1853         m_scrollCorner->destroy();
1854         m_scrollCorner = 0;
1855     }
1856 }
1857
1858 void FrameView::paintScrollCorner(GraphicsContext* context, const IntRect& cornerRect)
1859 {
1860     if (context->updatingControlTints()) {
1861         updateScrollCorner();
1862         return;
1863     }
1864
1865     if (m_scrollCorner) {
1866         m_scrollCorner->paintIntoRect(context, cornerRect.x(), cornerRect.y(), cornerRect);
1867         return;
1868     }
1869
1870     ScrollView::paintScrollCorner(context, cornerRect);
1871 }
1872
1873 bool FrameView::hasCustomScrollbars() const
1874 {
1875     const HashSet<RefPtr<Widget> >* viewChildren = children();
1876     HashSet<RefPtr<Widget> >::const_iterator end = viewChildren->end();
1877     for (HashSet<RefPtr<Widget> >::const_iterator current = viewChildren->begin(); current != end; ++current) {
1878         Widget* widget = current->get();
1879         if (widget->isFrameView()) {
1880             if (static_cast<FrameView*>(widget)->hasCustomScrollbars())
1881                 return true;
1882         } else if (widget->isScrollbar()) {
1883             Scrollbar* scrollbar = static_cast<Scrollbar*>(widget);
1884             if (scrollbar->isCustomScrollbar())
1885                 return true;
1886         }
1887     }
1888
1889     return false;
1890 }
1891
1892 void FrameView::updateControlTints()
1893 {
1894     // This is called when control tints are changed from aqua/graphite to clear and vice versa.
1895     // We do a "fake" paint, and when the theme gets a paint call, it can then do an invalidate.
1896     // This is only done if the theme supports control tinting. It's up to the theme and platform
1897     // to define when controls get the tint and to call this function when that changes.
1898
1899     // Optimize the common case where we bring a window to the front while it's still empty.
1900     if (!m_frame || m_frame->loader()->url().isEmpty())
1901         return;
1902
1903     if ((m_frame->contentRenderer() && m_frame->contentRenderer()->theme()->supportsControlTints()) || hasCustomScrollbars())  {
1904         if (needsLayout())
1905             layout();
1906         PlatformGraphicsContext* const noContext = 0;
1907         GraphicsContext context(noContext);
1908         context.setUpdatingControlTints(true);
1909         if (platformWidget())
1910             paintContents(&context, visibleContentRect());
1911         else
1912             paint(&context, frameRect());
1913     }
1914 }
1915
1916 bool FrameView::wasScrolledByUser() const
1917 {
1918     return m_wasScrolledByUser;
1919 }
1920
1921 void FrameView::setWasScrolledByUser(bool wasScrolledByUser)
1922 {
1923     if (m_inProgrammaticScroll)
1924         return;
1925     m_maintainScrollPositionAnchor = 0;
1926     m_wasScrolledByUser = wasScrolledByUser;
1927 }
1928
1929 void FrameView::paintContents(GraphicsContext* p, const IntRect& rect)
1930 {
1931     if (!frame())
1932         return;
1933
1934 #if ENABLE(INSPECTOR)
1935     if (InspectorTimelineAgent* timelineAgent = inspectorTimelineAgent())
1936         timelineAgent->willPaint(rect);
1937 #endif
1938
1939     Document* document = frame()->document();
1940
1941 #ifndef NDEBUG
1942     bool fillWithRed;
1943     if (document->printing())
1944         fillWithRed = false; // Printing, don't fill with red (can't remember why).
1945     else if (document->ownerElement())
1946         fillWithRed = false; // Subframe, don't fill with red.
1947     else if (isTransparent())
1948         fillWithRed = false; // Transparent, don't fill with red.
1949     else if (m_paintBehavior & PaintBehaviorSelectionOnly)
1950         fillWithRed = false; // Selections are transparent, don't fill with red.
1951     else if (m_nodeToDraw)
1952         fillWithRed = false; // Element images are transparent, don't fill with red.
1953     else
1954         fillWithRed = true;
1955
1956     if (fillWithRed)
1957         p->fillRect(rect, Color(0xFF, 0, 0), DeviceColorSpace);
1958 #endif
1959
1960     bool isTopLevelPainter = !sCurrentPaintTimeStamp;
1961     if (isTopLevelPainter)
1962         sCurrentPaintTimeStamp = currentTime();
1963
1964     RenderView* contentRenderer = frame()->contentRenderer();
1965     if (!contentRenderer) {
1966         LOG_ERROR("called Frame::paint with nil renderer");
1967         return;
1968     }
1969
1970     ASSERT(!needsLayout());
1971     if (needsLayout())
1972         return;
1973
1974 #if USE(ACCELERATED_COMPOSITING)
1975     if (!p->paintingDisabled()) {
1976         if (GraphicsLayer* rootLayer = contentRenderer->compositor()->rootPlatformLayer())
1977             rootLayer->syncCompositingState();
1978     }
1979 #endif
1980
1981     ASSERT(!m_isPainting);
1982
1983     m_isPainting = true;
1984
1985     // m_nodeToDraw is used to draw only one element (and its descendants)
1986     RenderObject* eltRenderer = m_nodeToDraw ? m_nodeToDraw->renderer() : 0;
1987
1988     PaintBehavior oldPaintBehavior = m_paintBehavior;
1989     if (m_paintBehavior == PaintBehaviorNormal)
1990         document->invalidateRenderedRectsForMarkersInRect(rect);
1991
1992     if (document->printing())
1993         m_paintBehavior |= PaintBehaviorFlattenCompositingLayers;
1994
1995     contentRenderer->layer()->paint(p, rect, m_paintBehavior, eltRenderer);
1996
1997     m_paintBehavior = oldPaintBehavior;
1998
1999     m_isPainting = false;
2000     m_lastPaintTime = currentTime();
2001
2002 #if ENABLE(DASHBOARD_SUPPORT)
2003     // Regions may have changed as a result of the visibility/z-index of element changing.
2004     if (document->dashboardRegionsDirty())
2005         updateDashboardRegions();
2006 #endif
2007
2008     if (isTopLevelPainter)
2009         sCurrentPaintTimeStamp = 0;
2010
2011 #if ENABLE(INSPECTOR)
2012     if (InspectorTimelineAgent* timelineAgent = inspectorTimelineAgent())
2013         timelineAgent->didPaint();
2014 #endif
2015 }
2016
2017 void FrameView::setPaintBehavior(PaintBehavior behavior)
2018 {
2019     m_paintBehavior = behavior;
2020 }
2021
2022 PaintBehavior FrameView::paintBehavior() const
2023 {
2024     return m_paintBehavior;
2025 }
2026
2027 bool FrameView::isPainting() const
2028 {
2029     return m_isPainting;
2030 }
2031
2032 void FrameView::setNodeToDraw(Node* node)
2033 {
2034     m_nodeToDraw = node;
2035 }
2036
2037 void FrameView::layoutIfNeededRecursive()
2038 {
2039     // We have to crawl our entire tree looking for any FrameViews that need
2040     // layout and make sure they are up to date.
2041     // Mac actually tests for intersection with the dirty region and tries not to
2042     // update layout for frames that are outside the dirty region.  Not only does this seem
2043     // pointless (since those frames will have set a zero timer to layout anyway), but
2044     // it is also incorrect, since if two frames overlap, the first could be excluded from the dirty
2045     // region but then become included later by the second frame adding rects to the dirty region
2046     // when it lays out.
2047
2048     if (needsLayout())
2049         layout();
2050
2051     const HashSet<RefPtr<Widget> >* viewChildren = children();
2052     HashSet<RefPtr<Widget> >::const_iterator end = viewChildren->end();
2053     for (HashSet<RefPtr<Widget> >::const_iterator current = viewChildren->begin(); current != end; ++current) {
2054         Widget* widget = (*current).get();
2055         if (widget->isFrameView())
2056             static_cast<FrameView*>(widget)->layoutIfNeededRecursive();
2057     }
2058
2059     // layoutIfNeededRecursive is called when we need to make sure layout is up-to-date before
2060     // painting, so we need to flush out any deferred repaints too.
2061     flushDeferredRepaints();
2062 }
2063
2064 void FrameView::flushDeferredRepaints()
2065 {
2066     if (!m_deferredRepaintTimer.isActive())
2067         return;
2068     m_deferredRepaintTimer.stop();
2069     doDeferredRepaints();
2070 }
2071
2072 void FrameView::forceLayout(bool allowSubtree)
2073 {
2074     layout(allowSubtree);
2075     // We cannot unschedule a pending relayout, since the force can be called with
2076     // a tiny rectangle from a drawRect update.  By unscheduling we in effect
2077     // "validate" and stop the necessary full repaint from occurring.  Basically any basic
2078     // append/remove DHTML is broken by this call.  For now, I have removed the optimization
2079     // until we have a better invalidation stategy. -dwh
2080     //unscheduleRelayout();
2081 }
2082
2083 void FrameView::forceLayoutWithPageWidthRange(float minPageWidth, float maxPageWidth, bool _adjustViewSize)
2084 {
2085     // Dumping externalRepresentation(m_frame->renderer()).ascii() is a good trick to see
2086     // the state of things before and after the layout
2087     RenderView *root = toRenderView(m_frame->document()->renderer());
2088     if (root) {
2089         // This magic is basically copied from khtmlview::print
2090         int pageW = (int)ceilf(minPageWidth);
2091         root->setWidth(pageW);
2092         root->setNeedsLayoutAndPrefWidthsRecalc();
2093         forceLayout();
2094
2095         // If we don't fit in the minimum page width, we'll lay out again. If we don't fit in the
2096         // maximum page width, we will lay out to the maximum page width and clip extra content.
2097         // FIXME: We are assuming a shrink-to-fit printing implementation.  A cropping
2098         // implementation should not do this!
2099         int rightmostPos = root->rightmostPosition();
2100         if (rightmostPos > minPageWidth) {
2101             pageW = std::min(rightmostPos, (int)ceilf(maxPageWidth));
2102             root->setWidth(pageW);
2103             root->setNeedsLayoutAndPrefWidthsRecalc();
2104             forceLayout();
2105         }
2106     }
2107
2108     if (_adjustViewSize)
2109         adjustViewSize();
2110 }
2111
2112 void FrameView::adjustPageHeight(float *newBottom, float oldTop, float oldBottom, float /*bottomLimit*/)
2113 {
2114     RenderView* root = m_frame->contentRenderer();
2115     if (root) {
2116         // Use a context with painting disabled.
2117         GraphicsContext context((PlatformGraphicsContext*)0);
2118         root->setTruncatedAt((int)floorf(oldBottom));
2119         IntRect dirtyRect(0, (int)floorf(oldTop), root->rightLayoutOverflow(), (int)ceilf(oldBottom - oldTop));
2120         root->layer()->paint(&context, dirtyRect);
2121         *newBottom = root->bestTruncatedAt();
2122         if (*newBottom == 0)
2123             *newBottom = oldBottom;
2124     } else
2125         *newBottom = oldBottom;
2126 }
2127
2128 IntRect FrameView::convertFromRenderer(const RenderObject* renderer, const IntRect& rendererRect) const
2129 {
2130     IntRect rect = renderer->localToAbsoluteQuad(FloatRect(rendererRect)).enclosingBoundingBox();
2131
2132     // Convert from page ("absolute") to FrameView coordinates.
2133     rect.move(-scrollX(), -scrollY());
2134
2135     return rect;
2136 }
2137
2138 IntRect FrameView::convertToRenderer(const RenderObject* renderer, const IntRect& viewRect) const
2139 {
2140     IntRect rect = viewRect;
2141
2142     // Convert from FrameView coords into page ("absolute") coordinates.
2143     rect.move(scrollX(), scrollY());
2144
2145     // FIXME: we don't have a way to map an absolute rect down to a local quad, so just
2146     // move the rect for now.
2147     rect.setLocation(roundedIntPoint(renderer->absoluteToLocal(rect.location(), false, true /* use transforms */)));
2148     return rect;
2149 }
2150
2151 IntPoint FrameView::convertFromRenderer(const RenderObject* renderer, const IntPoint& rendererPoint) const
2152 {
2153     IntPoint point = roundedIntPoint(renderer->localToAbsolute(rendererPoint, false, true /* use transforms */));
2154
2155     // Convert from page ("absolute") to FrameView coordinates.
2156     point.move(-scrollX(), -scrollY());
2157     return point;
2158 }
2159
2160 IntPoint FrameView::convertToRenderer(const RenderObject* renderer, const IntPoint& viewPoint) const
2161 {
2162     IntPoint point = viewPoint;
2163
2164     // Convert from FrameView coords into page ("absolute") coordinates.
2165     point += IntSize(scrollX(), scrollY());
2166
2167     return roundedIntPoint(renderer->absoluteToLocal(point, false, true /* use transforms */));
2168 }
2169
2170 IntRect FrameView::convertToContainingView(const IntRect& localRect) const
2171 {
2172     if (const ScrollView* parentScrollView = parent()) {
2173         if (parentScrollView->isFrameView()) {
2174             const FrameView* parentView = static_cast<const FrameView*>(parentScrollView);
2175             // Get our renderer in the parent view
2176             RenderPart* renderer = m_frame->ownerRenderer();
2177             if (!renderer)
2178                 return localRect;
2179
2180             IntRect rect(localRect);
2181             // Add borders and padding??
2182             rect.move(renderer->borderLeft() + renderer->paddingLeft(),
2183                       renderer->borderTop() + renderer->paddingTop());
2184             return parentView->convertFromRenderer(renderer, rect);
2185         }
2186
2187         return Widget::convertToContainingView(localRect);
2188     }
2189
2190     return localRect;
2191 }
2192
2193 IntRect FrameView::convertFromContainingView(const IntRect& parentRect) const
2194 {
2195     if (const ScrollView* parentScrollView = parent()) {
2196         if (parentScrollView->isFrameView()) {
2197             const FrameView* parentView = static_cast<const FrameView*>(parentScrollView);
2198
2199             // Get our renderer in the parent view
2200             RenderPart* renderer = m_frame->ownerRenderer();
2201             if (!renderer)
2202                 return parentRect;
2203
2204             IntRect rect = parentView->convertToRenderer(renderer, parentRect);
2205             // Subtract borders and padding
2206             rect.move(-renderer->borderLeft() - renderer->paddingLeft(),
2207                       -renderer->borderTop() - renderer->paddingTop());
2208             return rect;
2209         }
2210
2211         return Widget::convertFromContainingView(parentRect);
2212     }
2213
2214     return parentRect;
2215 }
2216
2217 IntPoint FrameView::convertToContainingView(const IntPoint& localPoint) const
2218 {
2219     if (const ScrollView* parentScrollView = parent()) {
2220         if (parentScrollView->isFrameView()) {
2221             const FrameView* parentView = static_cast<const FrameView*>(parentScrollView);
2222
2223             // Get our renderer in the parent view
2224             RenderPart* renderer = m_frame->ownerRenderer();
2225             if (!renderer)
2226                 return localPoint;
2227
2228             IntPoint point(localPoint);
2229
2230             // Add borders and padding
2231             point.move(renderer->borderLeft() + renderer->paddingLeft(),
2232                        renderer->borderTop() + renderer->paddingTop());
2233             return parentView->convertFromRenderer(renderer, point);
2234         }
2235
2236         return Widget::convertToContainingView(localPoint);
2237     }
2238
2239     return localPoint;
2240 }
2241
2242 IntPoint FrameView::convertFromContainingView(const IntPoint& parentPoint) const
2243 {
2244     if (const ScrollView* parentScrollView = parent()) {
2245         if (parentScrollView->isFrameView()) {
2246             const FrameView* parentView = static_cast<const FrameView*>(parentScrollView);
2247
2248             // Get our renderer in the parent view
2249             RenderPart* renderer = m_frame->ownerRenderer();
2250             if (!renderer)
2251                 return parentPoint;
2252
2253             IntPoint point = parentView->convertToRenderer(renderer, parentPoint);
2254             // Subtract borders and padding
2255             point.move(-renderer->borderLeft() - renderer->paddingLeft(),
2256                        -renderer->borderTop() - renderer->paddingTop());
2257             return point;
2258         }
2259
2260         return Widget::convertFromContainingView(parentPoint);
2261     }
2262
2263     return parentPoint;
2264 }
2265
2266 bool FrameView::shouldApplyTextZoom() const
2267 {
2268     if (m_zoomFactor == 1)
2269         return false;
2270     if (!m_frame)
2271         return false;
2272     Page* page = m_frame->page();
2273     return page && page->settings()->zoomMode() == ZoomTextOnly;
2274 }
2275
2276 bool FrameView::shouldApplyPageZoom() const
2277 {
2278     if (m_zoomFactor == 1)
2279         return false;
2280     if (!m_frame)
2281         return false;
2282     Page* page = m_frame->page();
2283     return page && page->settings()->zoomMode() == ZoomPage;
2284 }
2285
2286 void FrameView::setZoomFactor(float percent, ZoomMode mode)
2287 {
2288     if (!m_frame)
2289         return;
2290
2291     Page* page = m_frame->page();
2292     if (!page)
2293         return;
2294
2295     if (m_zoomFactor == percent && page->settings()->zoomMode() == mode)
2296         return;
2297
2298     Document* document = m_frame->document();
2299     if (!document)
2300         return;
2301
2302 #if ENABLE(SVG)
2303     // Respect SVGs zoomAndPan="disabled" property in standalone SVG documents.
2304     // FIXME: How to handle compound documents + zoomAndPan="disabled"? Needs SVG WG clarification.
2305     if (document->isSVGDocument()) {
2306         if (!static_cast<SVGDocument*>(document)->zoomAndPanEnabled())
2307             return;
2308         if (document->renderer())
2309             document->renderer()->setNeedsLayout(true);
2310     }
2311 #endif
2312
2313     if (mode == ZoomPage) {
2314         // Update the scroll position when doing a full page zoom, so the content stays in relatively the same position.
2315         IntPoint scrollPosition = this->scrollPosition();
2316         float percentDifference = (percent / m_zoomFactor);
2317         setScrollPosition(IntPoint(scrollPosition.x() * percentDifference, scrollPosition.y() * percentDifference));
2318     }
2319
2320     m_zoomFactor = percent;
2321     page->settings()->setZoomMode(mode);
2322
2323     document->recalcStyle(Node::Force);
2324
2325     for (Frame* child = m_frame->tree()->firstChild(); child; child = child->tree()->nextSibling()) {
2326         if (FrameView* childView = child->view())
2327             childView->setZoomFactor(m_zoomFactor, mode);
2328     }
2329
2330     if (document->renderer() && document->renderer()->needsLayout() && didFirstLayout())
2331         layout();
2332 }
2333
2334
2335 // Normal delay
2336 void FrameView::setRepaintThrottlingDeferredRepaintDelay(double p)
2337 {
2338     s_deferredRepaintDelay = p;
2339 }
2340
2341 // Negative value would mean that first few repaints happen without a delay
2342 void FrameView::setRepaintThrottlingnInitialDeferredRepaintDelayDuringLoading(double p)
2343 {
2344     s_initialDeferredRepaintDelayDuringLoading = p;
2345 }
2346
2347 // The delay grows on each repaint to this maximum value
2348 void FrameView::setRepaintThrottlingMaxDeferredRepaintDelayDuringLoading(double p)
2349 {
2350     s_maxDeferredRepaintDelayDuringLoading = p;
2351 }
2352
2353 // On each repaint the delay increases by this amount
2354 void FrameView::setRepaintThrottlingDeferredRepaintDelayIncrementDuringLoading(double p)
2355 {
2356     s_deferredRepaintDelayIncrementDuringLoading = p;
2357 }
2358
2359 } // namespace WebCore