Remove assumption that null containerForRepaint assumes RenderView

Source/core/rendering/RenderObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 1316 matching lines @@
 
 void RenderObject::paint(PaintInfo&, const LayoutPoint&)
 {
 }
 
 RenderLayerModelObject* RenderObject::containerForRepaint() const
 {
     if (!isRooted())
         return 0;
 
-    // FIXME: Repaint container should never be null when we're rooted. crbug.com/363699
     RenderLayerModelObject* repaintContainer = 0;
 
-    RenderView* v = view();
-    if (v->usesCompositing()) {
+    RenderView* renderView = view();
+    if (renderView->usesCompositing()) {
         // FIXME: CompositingState is not necessarily up to date for many callers of this function.
         DisableCompositingQueryAsserts disabler;
 
         if (RenderLayer* compositingLayer = enclosingLayer()->enclosingCompositingLayerForRepaint())
             repaintContainer = compositingLayer->renderer();
     }
 
     if (document().view()->hasSoftwareFilters()) {
         if (RenderLayer* enclosingFilterLayer = enclosingLayer()->enclosingFilterLayer())
             return enclosingFilterLayer->renderer();
     }
 
     // If we have a flow thread, then we need to do individual repaints within the RenderRegions instead.
     // Return the flow thread as a repaint container in order to create a chokepoint that allows us to change
     // repainting to do individual region repaints.
     if (RenderFlowThread* parentRenderFlowThread = flowThreadContainingBlock()) {
         // If we have already found a repaint container then we will repaint into that container only if it is part of the same
         // flow thread. Otherwise we will need to catch the repaint call and send it to the flow thread.
         if (!repaintContainer || repaintContainer->flowThreadContainingBlock() != parentRenderFlowThread)
             repaintContainer = parentRenderFlowThread;
     }
-    return repaintContainer;
+    return repaintContainer ? repaintContainer : renderView;
 }
 
 template<typename T> PassRefPtr<JSONValue> jsonObjectForRect(const T& rect)
 {
     RefPtr<JSONObject> object = JSONObject::create();
     object->setNumber("x", rect.x());
     object->setNumber("y", rect.y());
     object->setNumber("width", rect.width());
     object->setNumber("height", rect.height());
     return object.release();
 }
 
 static PassRefPtr<JSONValue> jsonObjectForRepaintInfo(const IntRect& rect, const String& invalidationReason)
 {
     RefPtr<JSONObject> object = JSONObject::create();
     object->setValue("rect", jsonObjectForRect(rect));
     object->setString("invalidation_reason", invalidationReason);
     return object.release();
 }
 
 void RenderObject::repaintUsingContainer(const RenderLayerModelObject* repaintContainer, const IntRect& r, InvalidationReason invalidationReason) const
 {
     if (r.isEmpty())
         return;
 
+    ASSERT(isRooted());
+
     TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"), "RenderObject::repaintUsingContainer()",
         "object", this->debugName().ascii(),
         "info", TracedValue::fromJSONValue(jsonObjectForRepaintInfo(r, invalidationReasonToString(invalidationReason))));
 
-    // FIXME: Repaint container should never be null. crbug.com/363699
-    if (!repaintContainer) {
-        view()->repaintViewRectangle(r);
-        return;
-    }
-
     // FIXME: Don't read compositing state here since we do this in the middle of recalc/layout.
     DisableCompositingQueryAsserts disabler;
     if (repaintContainer->compositingState() == PaintsIntoGroupedBacking) {
         ASSERT(repaintContainer->groupedMapping());
         ASSERT(repaintContainer->layer());
 
         // Not clean, but if squashing layer does not yet exist here (e.g. repaint invalidation coming from within recomputing compositing requirements)
         // then it's ok to just exit here, since the squashing layer will get repainted when it is newly created.
         if (!repaintContainer->groupedMapping()->squashingLayer())
             return;
@@ skipping 49 matching lines @@
     if (!isRooted())
         return;
 
     if (view()->document().printing())
         return; // Don't repaint if we're printing.
 
     // FIXME: really, we're in the repaint phase here, and the following queries are legal.
     // Until those states are fully fledged, I'll just disable the ASSERTS.
     DisableCompositingQueryAsserts disabler;
     RenderLayerModelObject* repaintContainer = containerForRepaint();
-    repaintUsingContainer(repaintContainer ? repaintContainer : view(), pixelSnappedIntRect(clippedOverflowRectForRepaint(repaintContainer)), InvalidationRepaint);
+    repaintUsingContainer(repaintContainer, pixelSnappedIntRect(clippedOverflowRectForRepaint(repaintContainer)), InvalidationRepaint);
 }
 
 void RenderObject::repaintRectangle(const LayoutRect& r) const
 {
     if (!isRooted())
         return;
 
     if (view()->document().printing())
         return; // Don't repaint if we're printing.
 
     LayoutRect dirtyRect(r);
 
     if (!RuntimeEnabledFeatures::repaintAfterLayoutEnabled()) {
         // FIXME: layoutDelta needs to be applied in parts before/after transforms and
         // repaint containers. https://bugs.webkit.org/show_bug.cgi?id=23308
         dirtyRect.move(view()->layoutDelta());
     }
 
     RenderLayerModelObject* repaintContainer = containerForRepaint();
     computeRectForRepaint(repaintContainer, dirtyRect);
-    repaintUsingContainer(repaintContainer ? repaintContainer : view(), pixelSnappedIntRect(dirtyRect), InvalidationRepaintRectangle);
+    repaintUsingContainer(repaintContainer, pixelSnappedIntRect(dirtyRect), InvalidationRepaintRectangle);
 }
 
 IntRect RenderObject::pixelSnappedAbsoluteClippedOverflowRect() const
 {
     return pixelSnappedIntRect(absoluteClippedOverflowRect());
 }
 
 const char* RenderObject::invalidationReasonToString(InvalidationReason reason) const
 {
     switch (reason) {
@@ skipping 86 matching lines @@
     if (invalidationReason == InvalidationIncremental && newBounds.location() != oldBounds.location())
         invalidationReason = InvalidationBoundsChange;
 
     // If the size is zero on one of our bounds then we know we're going to have
     // to do a full invalidation of either old bounds or new bounds. If we fall
     // into the incremental invalidation we'll issue two invalidations instead
     // of one.
     if (invalidationReason == InvalidationIncremental && (oldBounds.size().isZero() || newBounds.size().isZero()))
         invalidationReason = InvalidationBoundsChange;
 
-    // FIXME: Repaint container should never be null. crbug.com/363699
-    if (!repaintContainer)
-        repaintContainer = v;
+    ASSERT(repaintContainer);
 
     if (invalidationReason != InvalidationIncremental) {
         repaintUsingContainer(repaintContainer, pixelSnappedIntRect(oldBounds), invalidationReason);
         if (newBounds != oldBounds)
             repaintUsingContainer(repaintContainer, pixelSnappedIntRect(newBounds), invalidationReason);
         return true;
     }
 
     LayoutUnit deltaLeft = newBounds.x() - oldBounds.x();
     if (deltaLeft > 0)
@@ skipping 1813 matching lines @@
 {
     if (object1) {
         const WebCore::RenderObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showRenderTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif