Remove CHECK_FAST_PATH_SLOW_PATH_EQUALITY

third_party/WebKit/Source/core/layout/PaintInvalidationState.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/PaintInvalidationState.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 31 matching lines @@
       clipped_(false),
       clipped_for_absolute_position_(false),
       cached_offsets_enabled_(true),
       cached_offsets_for_absolute_position_enabled_(true),
       paint_invalidation_container_(
           &layout_view.ContainerForPaintInvalidation()),
       paint_invalidation_container_for_stacked_contents_(
           paint_invalidation_container_),
       container_for_absolute_position_(layout_view),
       pending_delayed_paint_invalidations_(pending_delayed_paint_invalidations),
-      painting_layer_(*layout_view.Layer())
-#ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
-      ,
-      m_canCheckFastPathSlowPathEquality(layoutView ==
-                                         m_paintInvalidationContainer)
-#endif
-{
+      painting_layer_(*layout_view.Layer()) {
   DCHECK(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
 
   if (!SupportsCachedOffsets(layout_view)) {
     cached_offsets_enabled_ = false;
     return;
   }
 
   FloatPoint point = layout_view.LocalToAncestorPoint(
       FloatPoint(), paint_invalidation_container_,
       kTraverseDocumentBoundaries | kInputIsInFrameCoordinates);
@@ skipping 22 matching lines @@
       paint_invalidation_container_(parent_state.paint_invalidation_container_),
       paint_invalidation_container_for_stacked_contents_(
           parent_state.paint_invalidation_container_for_stacked_contents_),
       container_for_absolute_position_(
           current_object.CanContainAbsolutePositionObjects()
               ? current_object
               : parent_state.container_for_absolute_position_),
       svg_transform_(parent_state.svg_transform_),
       pending_delayed_paint_invalidations_(
           parent_state.pending_delayed_paint_invalidations_),
-      painting_layer_(parent_state.ChildPaintingLayer(current_object))
-#ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
-      ,
-      m_canCheckFastPathSlowPathEquality(
-          parentState.m_canCheckFastPathSlowPathEquality)
-#endif
-{
+      painting_layer_(parent_state.ChildPaintingLayer(current_object)) {
   DCHECK(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
   DCHECK_EQ(&painting_layer_, current_object.PaintingLayer());
 
   if (current_object == parent_state.current_object_) {
 // Sometimes we create a new PaintInvalidationState from parentState on the same
 // object (e.g. LayoutView, and the HorriblySlowRectMapping cases in
 // LayoutBlock::invalidatePaintOfSubtreesIfNeeded()).
 // TODO(wangxianzhu): Avoid this for
 // RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled().
 #if DCHECK_IS_ON()
@@ skipping 97 matching lines @@
         // offset to adjust m_paintOffsetForAbsolutePosition.
         UpdateForCurrentObject(parent_state);
         paint_offset_for_absolute_position_ -= paint_offset_;
         if (clipped_for_absolute_position_)
           clip_rect_for_absolute_position_.Move(-paint_offset_);
       }
     }
 
     clipped_ = false;  // Will be updated in updateForChildren().
     paint_offset_ = LayoutSize();
-#ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
-    m_canCheckFastPathSlowPathEquality = true;
-#endif
     return;
   }
 
   UpdateForCurrentObject(parent_state);
 }
 
 PaintLayer& PaintInvalidationState::ChildPaintingLayer(
     const LayoutObject& child) const {
   if (child.HasLayer() && ToLayoutBoxModelObject(child).HasSelfPaintingLayer())
     return *ToLayoutBoxModelObject(child).Layer();
@@ skipping 31 matching lines @@
     if (paint_invalidation_container_->IsBox()) {
       const LayoutBox* box = ToLayoutBox(paint_invalidation_container_);
       if (box->HasOverflowClip())
         fixed_offset.Move(box->ScrolledContentOffset());
     }
     paint_offset_ = LayoutSize(fixed_offset.X(), fixed_offset.Y());
     // In the above way to get paint offset, we can't get accurate clip rect, so
     // just assume no clip. Clip on fixed-position is rare, in case that
     // paintInvalidationContainer crosses frame boundary and the LayoutView is
     // clipped by something in owner document.
-    if (clipped_) {
-      clipped_ = false;
-#ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
-      m_canCheckFastPathSlowPathEquality = false;
-#endif
-    }
+    clipped_ = false;
     return;
   }
 
   if (position == EPosition::kAbsolute) {
     cached_offsets_enabled_ = cached_offsets_for_absolute_position_enabled_;
     if (!cached_offsets_enabled_)
       return;
 
     paint_offset_ = paint_offset_for_absolute_position_;
     clipped_ = clipped_for_absolute_position_;
@@ skipping 139 matching lines @@
   // visual rect change for layout caused invalidation.
   if (current_object_.IsText())
     return visual_rect_location;
 
   FloatPoint point;
   if (paint_invalidation_container_ != &current_object_) {
     if (cached_offsets_enabled_) {
       if (current_object_.IsSVGChild())
         point = svg_transform_.MapPoint(point);
       point += FloatPoint(paint_offset_);
-#ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
-      DCHECK_EQ(point, slowLocalOriginToAncestorPoint(
-                           m_currentObject, m_paintInvalidationContainer,
-                           FloatPoint()));
-#endif
     } else {
       point = SlowLocalToAncestorPoint(
           current_object_, *paint_invalidation_container_, FloatPoint());
     }
   }
 
   PaintLayer::MapPointInPaintInvalidationContainerToBacking(
       *paint_invalidation_container_, point);
 
   point.Move(current_object_.ScrollAdjustmentForPaintInvalidation(
@@ skipping 17 matching lines @@
 
 LayoutRect PaintInvalidationState::ComputeVisualRectInBackingForSVG() const {
   LayoutRect rect;
   if (cached_offsets_enabled_) {
     FloatRect svg_rect = SVGLayoutSupport::LocalVisualRect(current_object_);
     rect = SVGLayoutSupport::TransformVisualRect(current_object_,
                                                  svg_transform_, svg_rect);
     rect.Move(paint_offset_);
     if (clipped_)
       rect.Intersect(clip_rect_);
-#ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
-    LayoutRect slowPathRect = SVGLayoutSupport::visualRectInAncestorSpace(
-        m_currentObject, *m_paintInvalidationContainer);
-    assertFastPathAndSlowPathRectsEqual(rect, slowPathRect);
-#endif
   } else {
     // TODO(wangxianzhu): Sometimes m_cachedOffsetsEnabled==false doesn't mean
     // we can't use cached m_svgTransform. We can use hybrid fast path (for SVG)
     // and slow path (for things above the SVGRoot).
     rect = SVGLayoutSupport::VisualRectInAncestorSpace(
         current_object_, *paint_invalidation_container_);
   }
 
   PaintLayer::MapRectInPaintInvalidationContainerToBacking(
       *paint_invalidation_container_, rect);
@@ skipping 25 matching lines @@
   }
 }
 
 void PaintInvalidationState::MapLocalRectToPaintInvalidationContainer(
     LayoutRect& rect) const {
 #if DCHECK_IS_ON()
   DCHECK(!did_update_for_children_);
 #endif
 
   if (cached_offsets_enabled_) {
-#ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
-    LayoutRect slowPathRect(rect);
-    slowMapToVisualRectInAncestorSpace(
-        m_currentObject, *m_paintInvalidationContainer, slowPathRect);
-#endif
     rect.Move(paint_offset_);
     if (clipped_)
       rect.Intersect(clip_rect_);
-#ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
-    assertFastPathAndSlowPathRectsEqual(rect, slowPathRect);
-#endif
   } else {
     SlowMapToVisualRectInAncestorSpace(current_object_,
                                        *paint_invalidation_container_, rect);
   }
 }
 
 void PaintInvalidationState::MapLocalRectToVisualRectInBacking(
     LayoutRect& rect) const {
   MapLocalRectToPaintInvalidationContainer(rect);
 
@@ skipping 16 matching lines @@
     clip_rect_ = clip_rect;
     clipped_ = true;
   }
 }
 
 PaintLayer& PaintInvalidationState::PaintingLayer() const {
   DCHECK_EQ(&painting_layer_, current_object_.PaintingLayer());
   return painting_layer_;
 }
 
-#ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
-
-static bool mayHaveBeenSaturated(LayoutUnit value) {
-  // This is not accurate, just to avoid too big values.
-  return value.abs() >= LayoutUnit::max() / 2;
-}
-
-static bool mayHaveBeenSaturated(const LayoutRect& rect) {
-  return mayHaveBeenSaturated(rect.x()) || mayHaveBeenSaturated(rect.y()) ||
-         mayHaveBeenSaturated(rect.width()) ||
-         mayHaveBeenSaturated(rect.height());
-}
-
-void PaintInvalidationState::assertFastPathAndSlowPathRectsEqual(
-    const LayoutRect& fastPathRect,
-    const LayoutRect& slowPathRect) const {
-  if (!m_canCheckFastPathSlowPathEquality)
-    return;
-
-  // TODO(crbug.com/597903): Fast path and slow path should generate equal empty
-  // rects.
-  if (fastPathRect.isEmpty() && slowPathRect.isEmpty())
-    return;
-
-  if (fastPathRect == slowPathRect)
-    return;
-
-  // LayoutUnit uses saturated arithmetic operations. If any interim or final
-  // result is saturated, the same operations in different order produce
-  // different results. Don't compare results if any of them may have been
-  // saturated.
-  if (mayHaveBeenSaturated(fastPathRect) || mayHaveBeenSaturated(slowPathRect))
-    return;
-
-  // Tolerate the difference between the two paths when crossing frame
-  // boundaries.
-  if (m_currentObject.view() != m_paintInvalidationContainer->view()) {
-    LayoutRect inflatedFastPathRect = fastPathRect;
-    inflatedFastPathRect.inflate(1);
-    if (inflatedFastPathRect.contains(slowPathRect))
-      return;
-    LayoutRect inflatedSlowPathRect = slowPathRect;
-    inflatedSlowPathRect.inflate(1);
-    if (inflatedSlowPathRect.contains(fastPathRect))
-      return;
-  }
-
-  LOG(ERROR) << "Fast path visual rect differs from slow path: fast: "
-             << fastPathRect.toString()
-             << " vs slow: " << slowPathRect.toString();
-  showLayoutTree(&m_currentObject);
-
-  NOTREACHED();
-}
-
-#endif  // CHECK_FAST_PATH_SLOW_PATH_EQUALITY
-
 PaintInvalidatorContextAdapter::PaintInvalidatorContextAdapter(
     const PaintInvalidationState& paint_invalidation_state)
     : PaintInvalidatorContext(nullptr),
       paint_invalidation_state_(paint_invalidation_state) {
   forced_subtree_invalidation_flags =
       paint_invalidation_state.forced_subtree_invalidation_flags_;
   paint_invalidation_container =
       &paint_invalidation_state.PaintInvalidationContainer();
   painting_layer = &paint_invalidation_state.PaintingLayer();
 }
 
 void PaintInvalidatorContextAdapter::MapLocalRectToVisualRectInBacking(
     const LayoutObject& object,
     LayoutRect& rect) const {
   DCHECK_EQ(&object, &paint_invalidation_state_.CurrentObject());
   paint_invalidation_state_.MapLocalRectToVisualRectInBacking(rect);
 }
 
 }  // namespace blink