cc: Remove impl_transform_is_unknown argument from OcclusionTracker.

cc/trees/occlusion_tracker_unittest.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 "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/layers/layer.h"
@@ skipping 55 matching lines @@
   void SetOpaqueContentsRect(const gfx::Rect& opaque_contents_rect) {
     override_opaque_contents_rect_ = true;
     opaque_contents_rect_ = opaque_contents_rect;
   }
 
  private:
   bool override_opaque_contents_rect_;
   gfx::Rect opaque_contents_rect_;
 };
 
-static inline bool LayerImplDrawTransformIsUnknown(const Layer* layer) {
-  return layer->draw_transform_is_animating();
-}
-static inline bool LayerImplDrawTransformIsUnknown(const LayerImpl* layer) {
-  return false;
-}
-
 template <typename LayerType>
 class TestOcclusionTrackerWithClip : public TestOcclusionTracker<LayerType> {
  public:
   TestOcclusionTrackerWithClip(const gfx::Rect& viewport_rect,
                                bool record_metrics_for_frame)
       : TestOcclusionTracker<LayerType>(viewport_rect,
                                         record_metrics_for_frame) {}
   explicit TestOcclusionTrackerWithClip(const gfx::Rect& viewport_rect)
       : TestOcclusionTracker<LayerType>(viewport_rect, false) {}
 
   bool OccludedLayer(const LayerType* layer,
                      const gfx::Rect& content_rect) const {
     DCHECK(layer->visible_content_rect().Contains(content_rect));
-    return this->Occluded(layer->render_target(),
-                          content_rect,
-                          layer->draw_transform(),
-                          LayerImplDrawTransformIsUnknown(layer));
+    return this->Occluded(
+        layer->render_target(), content_rect, layer->draw_transform());
   }
 
   // Gives an unoccluded sub-rect of |content_rect| in the content space of the
   // layer. Simple wrapper around UnoccludedContentRect.
   gfx::Rect UnoccludedLayerContentRect(const LayerType* layer,
                                        const gfx::Rect& content_rect) const {
     DCHECK(layer->visible_content_rect().Contains(content_rect));
     return this->UnoccludedContentRect(
-        layer->render_target(),
-        content_rect,
-        layer->draw_transform(),
-        LayerImplDrawTransformIsUnknown(layer));
+        layer->render_target(), content_rect, layer->draw_transform());
   }
 };
 
 struct OcclusionTrackerTestMainThreadTypes {
   typedef Layer LayerType;
   typedef FakeLayerTreeHost HostType;
   typedef RenderSurface RenderSurfaceType;
   typedef TestContentLayer ContentLayerType;
   typedef scoped_refptr<Layer> LayerPtrType;
   typedef scoped_refptr<ContentLayerType> ContentLayerPtrType;
@@ skipping 499 matching lines @@
 
     // This checks cases where the quads don't match their "containing"
     // layers, e.g. in terms of transforms or clip rect. This is typical for
     // DelegatedRendererLayer.
 
     gfx::Transform quad_transform;
     quad_transform.Translate(30.0, 30.0);
 
     EXPECT_TRUE(occlusion.UnoccludedContentRect(parent,
                                                 gfx::Rect(0, 0, 10, 10),
-                                                quad_transform,
-                                                false).IsEmpty());
-    EXPECT_RECT_EQ(gfx::Rect(0, 0, 10, 10),
-                   occlusion.UnoccludedContentRect(parent,
-                                                   gfx::Rect(0, 0, 10, 10),
-                                                   quad_transform,
-                                                   true));
+                                                quad_transform).IsEmpty());
     EXPECT_RECT_EQ(gfx::Rect(40, 40, 10, 10),
-                   occlusion.UnoccludedContentRect(parent,
-                                                   gfx::Rect(40, 40, 10, 10),
-                                                   quad_transform,
-                                                   false));
+                   occlusion.UnoccludedContentRect(
+                       parent, gfx::Rect(40, 40, 10, 10), quad_transform));
     EXPECT_RECT_EQ(gfx::Rect(40, 30, 5, 10),
-                   occlusion.UnoccludedContentRect(parent,
-                                                   gfx::Rect(35, 30, 10, 10),
-                                                   quad_transform,
-                                                   false));
+                   occlusion.UnoccludedContentRect(
+                       parent, gfx::Rect(35, 30, 10, 10), quad_transform));
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestQuadsMismatchLayer);
 
 template <class Types>
 class OcclusionTrackerTestRotatedChild : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestRotatedChild(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
@@ skipping 1784 matching lines @@
         gfx::Rect(0, 0, 1000, 1000));
 
     this->VisitLayer(surface2, &occlusion);
     this->EnterContributingSurface(surface2, &occlusion);
 
     EXPECT_EQ(gfx::Rect(0, 0, 50, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     this->LeaveContributingSurface(surface2, &occlusion);
     this->EnterLayer(surface_child2, &occlusion);
-
     // surface_child2 is moving in screen space but not relative to its target,
     // so occlusion should happen in its target space only.  It also means that
     // things occluding from outside the target (e.g. surface2) cannot occlude
     // this layer.
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
-
-    EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 300),
-                   occlusion.UnoccludedLayerContentRect(
-                       surface_child2, gfx::Rect(0, 0, 100, 300)));
-    EXPECT_FALSE(
-        occlusion.OccludedLayer(surface_child, gfx::Rect(0, 0, 50, 300)));
+    EXPECT_EQ(gfx::Rect().ToString(),
+              occlusion.occlusion_from_inside_target().ToString());
 
     this->LeaveLayer(surface_child2, &occlusion);
     this->EnterLayer(surface_child, &occlusion);
-    EXPECT_FALSE(
-        occlusion.OccludedLayer(surface_child, gfx::Rect(0, 0, 100, 300)));
+    // surface_child2 added to the occlusion since it is not moving relative
+    // to its target.
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
-    EXPECT_RECT_EQ(gfx::Rect(100, 0, 200, 300),
-                   occlusion.UnoccludedLayerContentRect(
-                       surface, gfx::Rect(0, 0, 300, 300)));
-
-    // The surface_child is occluded by the surface_child2, but is moving
-    // relative its target, so it can't be occluded.
-    EXPECT_RECT_EQ(gfx::Rect(0, 0, 200, 300),
-                   occlusion.UnoccludedLayerContentRect(
-                       surface_child, gfx::Rect(0, 0, 200, 300)));
-    EXPECT_FALSE(
-        occlusion.OccludedLayer(surface_child, gfx::Rect(0, 0, 50, 300)));
 
     this->LeaveLayer(surface_child, &occlusion);
-    this->EnterLayer(surface, &occlusion);
-    // The surface_child is moving in screen space but not relative to its
-    // target, so occlusion should happen from within the target only.
+    // surface_child is moving relative to its target, so it does not add
+    // occlusion.
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
-    EXPECT_RECT_EQ(gfx::Rect(100, 0, 200, 300),
-                   occlusion.UnoccludedLayerContentRect(
-                       surface, gfx::Rect(0, 0, 300, 300)));
+
+    this->EnterLayer(surface, &occlusion);
+    EXPECT_EQ(gfx::Rect().ToString(),
+              occlusion.occlusion_from_outside_target().ToString());
+    EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(),
+              occlusion.occlusion_from_inside_target().ToString());
 
     this->LeaveLayer(surface, &occlusion);
     // The surface's owning layer is moving in screen space but not relative to
-    // its target, so occlusion should happen within the target only.
+    // its target, so it adds to the occlusion.
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 300, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
-    EXPECT_RECT_EQ(gfx::Rect(0, 0, 0, 0),
-                   occlusion.UnoccludedLayerContentRect(
-                       surface, gfx::Rect(0, 0, 300, 300)));
 
     this->EnterContributingSurface(surface, &occlusion);
-    // The contributing |surface| is animating so it can't be occluded.
-    EXPECT_RECT_EQ(gfx::Rect(0, 0, 300, 300),
-                   occlusion.UnoccludedContributingSurfaceContentRect(
-                       surface, false, gfx::Rect(0, 0, 300, 300)));
     this->LeaveContributingSurface(surface, &occlusion);
+    // The |surface| is moving in the screen and in its target, so all occlusion
+    // within the surface is lost when leaving it. Only the |surface2| occlusion
+    // is left.
+    EXPECT_EQ(gfx::Rect().ToString(),
+              occlusion.occlusion_from_outside_target().ToString());
+    EXPECT_EQ(gfx::Rect(0, 0, 50, 300).ToString(),
+              occlusion.occlusion_from_inside_target().ToString());
 
-    this->EnterLayer(layer, &occlusion);
-    // The |surface| is moving in the screen and in its target, so all occlusion
-    // within the surface is lost when leaving it.
-    EXPECT_RECT_EQ(gfx::Rect(50, 0, 250, 300),
-                   occlusion.UnoccludedLayerContentRect(
-                       parent, gfx::Rect(0, 0, 300, 300)));
-    this->LeaveLayer(layer, &occlusion);
-
-    this->EnterLayer(parent, &occlusion);
+    this->VisitLayer(layer, &occlusion);
     // The |layer| is animating in the screen and in its target, so no occlusion
     // is added.
-    EXPECT_RECT_EQ(gfx::Rect(50, 0, 250, 300),
-                   occlusion.UnoccludedLayerContentRect(
-                       parent, gfx::Rect(0, 0, 300, 300)));
+    EXPECT_EQ(gfx::Rect().ToString(),
+              occlusion.occlusion_from_outside_target().ToString());
+    EXPECT_EQ(gfx::Rect(0, 0, 50, 300).ToString(),
+              occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationTranslateOnMainThread);
 
 template <class Types>
 class OcclusionTrackerTestSurfaceOcclusionTranslatesToParent
     : public OcclusionTrackerTest<Types> {
  protected:
   explicit OcclusionTrackerTestSurfaceOcclusionTranslatesToParent(
@@ skipping 1226 matching lines @@
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestEmptyEventLayerDoesNotOcclude)
 
 }  // namespace
 }  // namespace cc