cc: Unify the occlusion access by adding an ability to scale transform.

cc/trees/occlusion.cc

 // 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 "cc/trees/occlusion.h"
 
 #include "cc/base/math_util.h"
 #include "ui/gfx/rect.h"
 
 namespace cc {
 
 Occlusion::Occlusion() {
 }
 
 Occlusion::Occlusion(const gfx::Transform& draw_transform,
                      const SimpleEnclosedRegion& occlusion_from_outside_target,
                      const SimpleEnclosedRegion& occlusion_from_inside_target)
     : draw_transform_(draw_transform),
       occlusion_from_outside_target_(occlusion_from_outside_target),
       occlusion_from_inside_target_(occlusion_from_inside_target) {
 }
 
+Occlusion Occlusion::GetOcclusionWithScaledDrawTransform(SkMScalar x,
+                                                         SkMScalar y) {
+  gfx::Transform scaled_transform = draw_transform_;
+  scaled_transform.Scale(x, y);

[danakj, 2014/10/05 17:27:38]

Rather than doing these matrix multiplies twice you could just pass an alternate
transform in that has already been constructed. This is essentially a scoped use
of the original occlusion with a different transform. 

[vmpstr, 2014/10/06 15:44:51]

I think this is a great idea. I think I'll add something along the lines of
GetOcclusionWith{,Custom,Alternative,Different}DrawTransform. 

I started replacing the occlusion tracker with occlusion passed in layers, and I
found that delegated layer impl basically uses a quad transform (you probably
know this...), and so I do need this functionality anyway.

+  return Occlusion(scaled_transform,
+                   occlusion_from_outside_target_,
+                   occlusion_from_inside_target_);
+}
+
+bool Occlusion::HasOcclusion() const {
+  return !occlusion_from_inside_target_.IsEmpty() ||
+         !occlusion_from_outside_target_.IsEmpty();
+}
+
 bool Occlusion::IsOccluded(const gfx::Rect& content_rect) const {
   if (content_rect.IsEmpty())
     return true;
 
-  if (occlusion_from_inside_target_.IsEmpty() &&
-      occlusion_from_outside_target_.IsEmpty()) {
+  if (!HasOcclusion())
     return false;
-  }
 
   gfx::Rect unoccluded_rect_in_target_surface =
       GetUnoccludedRectInTargetSurface(content_rect);
   return unoccluded_rect_in_target_surface.IsEmpty();
 }
 
 gfx::Rect Occlusion::GetUnoccludedContentRect(
     const gfx::Rect& content_rect) const {
   if (content_rect.IsEmpty())
     return content_rect;
 
-  if (occlusion_from_inside_target_.IsEmpty() &&
-      occlusion_from_outside_target_.IsEmpty()) {
+  if (!HasOcclusion())
     return content_rect;
-  }
 
   gfx::Rect unoccluded_rect_in_target_surface =
       GetUnoccludedRectInTargetSurface(content_rect);
   if (unoccluded_rect_in_target_surface.IsEmpty())
     return gfx::Rect();
 
   gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
   bool ok = draw_transform_.GetInverse(&inverse_draw_transform);
   DCHECK(ok);
 
@@ skipping 16 matching lines @@
   // once.
   unoccluded_rect_in_target_surface.Subtract(
       occlusion_from_inside_target_.bounds());
   unoccluded_rect_in_target_surface.Subtract(
       occlusion_from_outside_target_.bounds());
 
   return unoccluded_rect_in_target_surface;
 }
 
 }  // namespace cc