cc: Stop converting Rect to QuadF to map to an enclosed rect.

cc/trees/occlusion_tracker.cc

 // Copyright 2012 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 "cc/trees/occlusion_tracker.h"
 
 #include <algorithm>
 
 #include "cc/base/math_util.h"
 #include "cc/base/region.h"
@@ skipping 66 matching lines @@
   // Verify that rects within the |surface| will remain rects in its target
   // surface after applying |transform|. If this is true, then apply |transform|
   // to each rect within |region| in order to transform the entire Region.
 
   // TODO(danakj): Find a rect interior to each transformed quad.
   if (!transform.Preserves2dAxisAlignment())
     return SimpleEnclosedRegion();
 
   SimpleEnclosedRegion transformed_region;
   for (size_t i = 0; i < region.GetRegionComplexity(); ++i) {
-    bool clipped;
-    gfx::QuadF transformed_quad =
-        MathUtil::MapQuad(transform, gfx::QuadF(region.GetRect(i)), &clipped);
+    // NonClippedRect is okay because we checked Preserves2dAxisAlignment above.
     gfx::Rect transformed_rect =
-        gfx::ToEnclosedRect(transformed_quad.BoundingBox());
-    DCHECK(!clipped);  // We only map if the transform preserves axis alignment.
+        MathUtil::MapEnclosedNonClippedRect(transform, region.GetRect(i));
     if (have_clip_rect)
       transformed_rect.Intersect(clip_rect_in_new_target);
     transformed_region.Union(transformed_rect);
   }
   return transformed_region;
 }
 
 static inline bool LayerOpacityKnown(const Layer* layer) {
   return !layer->draw_opacity_is_animating();
 }
@@ skipping 322 matching lines @@
   gfx::Rect clip_rect_in_target = ScreenSpaceClipRectInTargetSurface(
       layer->render_target()->render_surface(), screen_space_clip_rect_);
   if (layer->is_clipped()) {
     clip_rect_in_target.Intersect(layer->clip_rect());
   } else {
     clip_rect_in_target.Intersect(
         layer->render_target()->render_surface()->content_rect());
   }
 
   for (size_t i = 0; i < opaque_contents.GetRegionComplexity(); ++i) {
-    bool clipped;
-    gfx::QuadF transformed_quad =
-        MathUtil::MapQuad(layer->draw_transform(),
-                          gfx::QuadF(opaque_contents.GetRect(i)),
-                          &clipped);
-    gfx::Rect transformed_rect =
-        gfx::ToEnclosedRect(transformed_quad.BoundingBox());
-    DCHECK(!clipped);  // We only map if the transform preserves axis alignment.
+    // NonClippedRect is okay because we checked Preserves2dAxisAlignment above.
+    gfx::Rect transformed_rect = MathUtil::MapEnclosedNonClippedRect(
+        layer->draw_transform(), opaque_contents.GetRect(i));
     transformed_rect.Intersect(clip_rect_in_target);
     if (transformed_rect.width() < minimum_tracking_size_.width() &&
         transformed_rect.height() < minimum_tracking_size_.height())
       continue;
     stack_.back().occlusion_from_inside_target.Union(transformed_rect);
 
     if (!occluding_screen_space_rects_)
       continue;
 
     // Save the occluding area in screen space for debug visualization.
-    gfx::QuadF screen_space_quad = MathUtil::MapQuad(
+    gfx::Rect screen_space_rect = MathUtil::MapEnclosedClippedRect(
         layer->render_target()->render_surface()->screen_space_transform(),
-        gfx::QuadF(transformed_rect), &clipped);
-    // TODO(danakj): Store the quad in the debug info instead of the bounding
-    // box.
-    gfx::Rect screen_space_rect =
-        gfx::ToEnclosedRect(screen_space_quad.BoundingBox());
+        transformed_rect);
     occluding_screen_space_rects_->push_back(screen_space_rect);
   }
 
   if (!non_occluding_screen_space_rects_)
     return;
 
   Region non_opaque_contents(gfx::Rect(layer->content_bounds()));
   non_opaque_contents.Subtract(opaque_contents);
 
   for (Region::Iterator non_opaque_content_rects(non_opaque_contents);
        non_opaque_content_rects.has_rect();
        non_opaque_content_rects.next()) {
-    // We've already checked for clipping in the MapQuad call above, these calls
-    // should not clip anything further.
-    gfx::Rect transformed_rect = gfx::ToEnclosedRect(
-        MathUtil::MapClippedRect(layer->draw_transform(),
-                                 gfx::RectF(non_opaque_content_rects.rect())));
+    // NonClippedRect is okay because we checked Preserves2dAxisAlignment above.
+    gfx::Rect transformed_rect = MathUtil::MapEnclosedNonClippedRect(
+        layer->draw_transform(), non_opaque_content_rects.rect());
     transformed_rect.Intersect(clip_rect_in_target);
     if (transformed_rect.IsEmpty())
       continue;
 
-    bool clipped;
-    gfx::QuadF screen_space_quad = MathUtil::MapQuad(
+    gfx::Rect screen_space_rect = MathUtil::MapEnclosedClippedRect(
         layer->render_target()->render_surface()->screen_space_transform(),
-        gfx::QuadF(transformed_rect),
-        &clipped);
-    // TODO(danakj): Store the quad in the debug info instead of the bounding
-    // box.
-    gfx::Rect screen_space_rect =
-        gfx::ToEnclosedRect(screen_space_quad.BoundingBox());
+        transformed_rect);
     non_occluding_screen_space_rects_->push_back(screen_space_rect);
   }
 }
 
 template <typename LayerType>
 bool OcclusionTracker<LayerType>::Occluded(
     const LayerType* render_target,
     const gfx::Rect& content_rect,
     const gfx::Transform& draw_transform) const {
   DCHECK(!stack_.empty());
@@ skipping 13 matching lines @@
   const StackObject& back = stack_.back();
   if (back.occlusion_from_inside_target.IsEmpty() &&
       back.occlusion_from_outside_target.IsEmpty()) {
     return false;
   }
 
   gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
   if (!draw_transform.GetInverse(&inverse_draw_transform))
     return false;
 
-  // Take the ToEnclosingRect at each step, as we want to contain any unoccluded
+  // Take the EnclosingRect at each step, as we want to contain any unoccluded
   // partial pixels in the resulting Rect.
   gfx::Rect unoccluded_rect_in_target_surface =
       MathUtil::MapEnclosingClippedRect(draw_transform, content_rect);
   DCHECK_LE(back.occlusion_from_inside_target.GetRegionComplexity(), 1u);
   DCHECK_LE(back.occlusion_from_outside_target.GetRegionComplexity(), 1u);
   // These subtract operations are more lossy than if we did both operations at
   // once.
   unoccluded_rect_in_target_surface.Subtract(
       stack_.back().occlusion_from_inside_target.bounds());
   unoccluded_rect_in_target_surface.Subtract(
@@ skipping 13 matching lines @@
   const StackObject& back = stack_.back();
   if (back.occlusion_from_inside_target.IsEmpty() &&
       back.occlusion_from_outside_target.IsEmpty()) {
     return content_rect;
   }
 
   gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
   if (!draw_transform.GetInverse(&inverse_draw_transform))
     return content_rect;
 
-  // Take the ToEnclosingRect at each step, as we want to contain any unoccluded
+  // Take the EnclosingRect at each step, as we want to contain any unoccluded
   // partial pixels in the resulting Rect.
   gfx::Rect unoccluded_rect_in_target_surface =
       MathUtil::MapEnclosingClippedRect(draw_transform, content_rect);
   DCHECK_LE(back.occlusion_from_inside_target.GetRegionComplexity(), 1u);
   DCHECK_LE(back.occlusion_from_outside_target.GetRegionComplexity(), 1u);
   // These subtract operations are more lossy than if we did both operations at
   // once.
   unoccluded_rect_in_target_surface.Subtract(
       back.occlusion_from_inside_target.bounds());
   unoccluded_rect_in_target_surface.Subtract(
@@ skipping 25 matching lines @@
 
   const StackObject& second_last = stack_[stack_.size() - 2];
   if (second_last.occlusion_from_inside_target.IsEmpty() &&
       second_last.occlusion_from_outside_target.IsEmpty())
     return content_rect;
 
   gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
   if (!draw_transform.GetInverse(&inverse_draw_transform))
     return content_rect;
 
-  // Take the ToEnclosingRect at each step, as we want to contain any unoccluded
+  // Take the EnclosingRect at each step, as we want to contain any unoccluded
   // partial pixels in the resulting Rect.
   gfx::Rect unoccluded_rect_in_target_surface =
       MathUtil::MapEnclosingClippedRect(draw_transform, content_rect);
   DCHECK_LE(second_last.occlusion_from_inside_target.GetRegionComplexity(), 1u);
   DCHECK_LE(second_last.occlusion_from_outside_target.GetRegionComplexity(),
             1u);
   // These subtract operations are more lossy than if we did both operations at
   // once.
   unoccluded_rect_in_target_surface.Subtract(
       second_last.occlusion_from_inside_target.bounds());
@@ skipping 19 matching lines @@
   for (size_t i = 0; i < occluded.GetRegionComplexity(); ++i)
     visible_region.Subtract(occluded.GetRect(i));
   return visible_region;
 }
 
 // Instantiate (and export) templates here for the linker.
 template class OcclusionTracker<Layer>;
 template class OcclusionTracker<LayerImpl>;
 
 }  // namespace cc