Update from https://crrev.com/316786

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"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/render_surface.h"
 #include "cc/layers/render_surface_impl.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 template <typename LayerType>
 OcclusionTracker<LayerType>::OcclusionTracker(
     const gfx::Rect& screen_space_clip_rect)
-    : screen_space_clip_rect_(screen_space_clip_rect),
-      occluding_screen_space_rects_(NULL),
-      non_occluding_screen_space_rects_(NULL) {}
+    : screen_space_clip_rect_(screen_space_clip_rect) {
+}
 
 template <typename LayerType>
-OcclusionTracker<LayerType>::~OcclusionTracker() {}
+OcclusionTracker<LayerType>::~OcclusionTracker() {
+}
 
 template <typename LayerType>
 Occlusion OcclusionTracker<LayerType>::GetCurrentOcclusionForLayer(
     const gfx::Transform& draw_transform) const {
   DCHECK(!stack_.empty());
   const StackObject& back = stack_.back();
   return Occlusion(draw_transform,
                    back.occlusion_from_outside_target,
                    back.occlusion_from_inside_target);
 }
 
 template <typename LayerType>
+Occlusion
+OcclusionTracker<LayerType>::GetCurrentOcclusionForContributingSurface(
+    const gfx::Transform& draw_transform) const {
+  DCHECK(!stack_.empty());
+  if (stack_.size() < 2)
+    return Occlusion();
+  // A contributing surface doesn't get occluded by things inside its own
+  // surface, so only things outside the surface can occlude it. That occlusion
+  // is found just below the top of the stack (if it exists).
+  const StackObject& second_last = stack_[stack_.size() - 2];
+  return Occlusion(draw_transform, second_last.occlusion_from_outside_target,
+                   second_last.occlusion_from_inside_target);
+}
+
+template <typename LayerType>
 void OcclusionTracker<LayerType>::EnterLayer(
     const LayerIteratorPosition<LayerType>& layer_iterator) {
   LayerType* render_target = layer_iterator.target_render_surface_layer;
 
   if (layer_iterator.represents_itself)
     EnterRenderTarget(render_target);
   else if (layer_iterator.represents_target_render_surface)
     FinishedRenderTarget(render_target);
 }
 
@@ skipping 282 matching lines @@
   SimpleEnclosedRegion old_occlusion_from_outside_target_in_new_target =
       TransformSurfaceOpaqueRegion<typename LayerType::RenderSurfaceType>(
           stack_[last_index].occlusion_from_outside_target,
           false,
           gfx::Rect(),
           old_surface->draw_transform());
 
   gfx::Rect unoccluded_surface_rect;
   gfx::Rect unoccluded_replica_rect;
   if (old_target->background_filters().HasFilterThatMovesPixels()) {
-    unoccluded_surface_rect = UnoccludedContributingSurfaceContentRect(
-        old_surface->content_rect(), old_surface->draw_transform());
+    Occlusion surface_occlusion = GetCurrentOcclusionForContributingSurface(
+        old_surface->draw_transform());
+    unoccluded_surface_rect =
+        surface_occlusion.GetUnoccludedContentRect(old_surface->content_rect());
     if (old_target->has_replica()) {
-      unoccluded_replica_rect = UnoccludedContributingSurfaceContentRect(
-          old_surface->content_rect(),
+      Occlusion replica_occlusion = GetCurrentOcclusionForContributingSurface(
           old_surface->replica_draw_transform());
+      unoccluded_replica_rect = replica_occlusion.GetUnoccludedContentRect(
+          old_surface->content_rect());
     }
   }
 
   if (surface_will_be_at_top_after_pop) {
     // Merge the top of the stack down.
     stack_[last_index - 1].occlusion_from_inside_target.Union(
         old_occlusion_from_inside_target_in_new_target);
     // TODO(danakj): Strictly this should subtract the inside target occlusion
     // before union.
     if (new_target->parent()) {
@@ skipping 81 matching lines @@
 
   for (size_t i = 0; i < opaque_contents.GetRegionComplexity(); ++i) {
     gfx::Rect transformed_rect =
         MathUtil::MapEnclosedRectWith2dAxisAlignedTransform(
             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.
-    bool clipped;
-    gfx::QuadF screen_space_quad = MathUtil::MapQuad(
-        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());
-    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()) {
-    gfx::Rect transformed_rect =
-        MathUtil::MapEnclosedRectWith2dAxisAlignedTransform(
-            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(
-        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());
-    non_occluding_screen_space_rects_->push_back(screen_space_rect);
-  }
-}
-
-template <typename LayerType>
-gfx::Rect OcclusionTracker<LayerType>::UnoccludedContributingSurfaceContentRect(
-    const gfx::Rect& content_rect,
-    const gfx::Transform& draw_transform) const {
-  if (content_rect.IsEmpty())
-    return content_rect;
-
-  // A contributing surface doesn't get occluded by things inside its own
-  // surface, so only things outside the surface can occlude it. That occlusion
-  // is found just below the top of the stack (if it exists).
-  bool has_occlusion = stack_.size() > 1;
-  if (!has_occlusion)
-    return content_rect;
-
-  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);
-  bool ok = draw_transform.GetInverse(&inverse_draw_transform);
-  DCHECK(ok);
-
-  // Take the ToEnclosingRect 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());
-  unoccluded_rect_in_target_surface.Subtract(
-      second_last.occlusion_from_outside_target.bounds());
-
-  if (unoccluded_rect_in_target_surface.IsEmpty())
-    return gfx::Rect();
-
-  gfx::Rect unoccluded_rect = MathUtil::ProjectEnclosingClippedRect(
-      inverse_draw_transform, unoccluded_rect_in_target_surface);
-  unoccluded_rect.Intersect(content_rect);
-
-  return unoccluded_rect;
 }
 
 template <typename LayerType>
 Region OcclusionTracker<LayerType>::ComputeVisibleRegionInScreen() const {
   DCHECK(!stack_.back().target->parent());
   const SimpleEnclosedRegion& occluded =
       stack_.back().occlusion_from_inside_target;
   Region visible_region(screen_space_clip_rect_);
   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