Compute rounded-ness of visual rects

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.cpp

 // Copyright 2015 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 "platform/graphics/compositing/PaintArtifactCompositor.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include "cc/layers/content_layer_client.h"
@@ skipping 339 matching lines @@
       propertyTreeState(firstPaintChunk.properties.propertyTreeState),
       isForeign(chunkIsForeign) {
   paintChunks.push_back(&firstPaintChunk);
 }
 
 void PaintArtifactCompositor::PendingLayer::merge(const PendingLayer& guest) {
   DCHECK(!isForeign && !guest.isForeign);
   DCHECK_EQ(backfaceHidden, guest.backfaceHidden);
 
   paintChunks.appendVector(guest.paintChunks);
-  FloatRect guestBoundsInHome = guest.bounds;
+  FloatClipRect guestBoundsInHome(guest.bounds);
   GeometryMapper::localToAncestorVisualRect(
       guest.propertyTreeState, propertyTreeState, guestBoundsInHome);
   FloatRect oldBounds = bounds;
-  bounds.unite(guestBoundsInHome);
+  bounds.unite(guestBoundsInHome.rect());
   if (bounds != oldBounds)
     knownToBeOpaque = false;
   // TODO(crbug.com/701991): Upgrade GeometryMapper.
   // If we knew the new bounds is enclosed by the mapped opaque region of
   // the guest layer, we can deduce the merged layer being opaque too.
 }
 
 static bool canUpcastTo(const PropertyTreeState& guest,
                         const PropertyTreeState& home);
 bool PaintArtifactCompositor::PendingLayer::canMerge(
     const PendingLayer& guest) const {
   if (isForeign || guest.isForeign)
     return false;
   if (backfaceHidden != guest.backfaceHidden)
     return false;
   if (propertyTreeState.effect() != guest.propertyTreeState.effect())
     return false;
   return canUpcastTo(guest.propertyTreeState, propertyTreeState);
 }
 
 void PaintArtifactCompositor::PendingLayer::upcast(
     const PropertyTreeState& newState) {
   DCHECK(!isForeign);
+  FloatClipRect floatClipRect(bounds);
   GeometryMapper::localToAncestorVisualRect(propertyTreeState, newState,
-                                            bounds);
+                                            floatClipRect);
+  bounds = floatClipRect.rect();
 
   propertyTreeState = newState;
   // TODO(crbug.com/701991): Upgrade GeometryMapper.
   // A local visual rect mapped to an ancestor space may become a polygon
   // (e.g. consider transformed clip), also effects may affect the opaque
   // region. To determine whether the layer is still opaque, we need to
   // query conservative opaque rect after mapping to an ancestor space,
   // which is not supported by GeometryMapper yet.
   knownToBeOpaque = false;
 }
@@ skipping 46 matching lines @@
   }
   return nullptr;
 }
 
 bool PaintArtifactCompositor::mightOverlap(const PendingLayer& layerA,
                                            const PendingLayer& layerB) {
   PropertyTreeState rootPropertyTreeState(TransformPaintPropertyNode::root(),
                                           ClipPaintPropertyNode::root(),
                                           EffectPaintPropertyNode::root());
 
-  FloatRect boundsA = layerA.bounds;
+  FloatClipRect boundsA(layerA.bounds);
   GeometryMapper::localToAncestorVisualRect(layerA.propertyTreeState,
                                             rootPropertyTreeState, boundsA);
-  FloatRect boundsB = layerB.bounds;
+  FloatClipRect boundsB(layerB.bounds);
   GeometryMapper::localToAncestorVisualRect(layerB.propertyTreeState,
                                             rootPropertyTreeState, boundsB);
 
-  return boundsA.intersects(boundsB);
+  return boundsA.rect().intersects(boundsB.rect());
 }
 
 bool PaintArtifactCompositor::canDecompositeEffect(
     const EffectPaintPropertyNode* effect,
     const PendingLayer& layer) {
   // If the effect associated with the layer is deeper than than the effect
   // we are attempting to decomposite, than implies some previous decision
   // did not allow to decomposite intermediate effects.
   if (layer.propertyTreeState.effect() != effect)
     return false;
@@ skipping 187 matching lines @@
 #ifndef NDEBUG
 void PaintArtifactCompositor::showDebugData() {
   LOG(ERROR) << layersAsJSON(LayerTreeIncludesDebugInfo)
                     ->toPrettyJSONString()
                     .utf8()
                     .data();
 }
 #endif
 
 }  // namespace blink