cc/trees/occlusion_tracker.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/trees/occlusion_tracker.h"
   6
   7 #include <algorithm>
   8
   9 #include "cc/base/math_util.h"
  10 #include "cc/debug/overdraw_metrics.h"
  11 #include "cc/layers/layer.h"
  12 #include "cc/layers/layer_impl.h"
  13 #include "cc/layers/render_surface.h"
  14 #include "cc/layers/render_surface_impl.h"
  15 #include "ui/gfx/quad_f.h"
  16 #include "ui/gfx/rect_conversions.h"
  17
  18 namespace cc {
  19
  20 template <typename LayerType, typename RenderSurfaceType>
  21 OcclusionTrackerBase<LayerType, RenderSurfaceType>::OcclusionTrackerBase(
  22     gfx::Rect screen_space_clip_rect, bool record_metrics_for_frame)
  23     : screen_space_clip_rect_(screen_space_clip_rect),
  24       overdraw_metrics_(OverdrawMetrics::Create(record_metrics_for_frame)),
  25       prevent_occlusion_(false),
  26       occluding_screen_space_rects_(NULL),
  27       non_occluding_screen_space_rects_(NULL) {}
  28
  29 template <typename LayerType, typename RenderSurfaceType>
  30 OcclusionTrackerBase<LayerType, RenderSurfaceType>::~OcclusionTrackerBase() {}
  31
  32 template <typename LayerType, typename RenderSurfaceType>
  33 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::EnterLayer(
  34     const LayerIteratorPosition<LayerType>& layer_iterator,
  35     bool prevent_occlusion) {
  36   LayerType* render_target = layer_iterator.target_render_surface_layer;
  37
  38   if (layer_iterator.represents_itself)
  39     EnterRenderTarget(render_target);
  40   else if (layer_iterator.represents_target_render_surface)
  41     FinishedRenderTarget(render_target);
  42
  43   prevent_occlusion_ = prevent_occlusion;
  44 }
  45
  46 template <typename LayerType, typename RenderSurfaceType>
  47 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::LeaveLayer(
  48     const LayerIteratorPosition<LayerType>& layer_iterator) {
  49   LayerType* render_target = layer_iterator.target_render_surface_layer;
  50
  51   if (layer_iterator.represents_itself)
  52     MarkOccludedBehindLayer(layer_iterator.current_layer);
  53   // TODO(danakj): This should be done when entering the contributing surface,
  54   // but in a way that the surface's own occlusion won't occlude itself.
  55   else if (layer_iterator.represents_contributing_render_surface)
  56     LeaveToRenderTarget(render_target);
  57
  58   prevent_occlusion_ = false;
  59 }
  60
  61 template <typename RenderSurfaceType>
  62 static gfx::Rect ScreenSpaceClipRectInTargetSurface(
  63     const RenderSurfaceType* target_surface, gfx::Rect screen_space_clip_rect) {
  64   gfx::Transform inverse_screen_space_transform(
  65       gfx::Transform::kSkipInitialization);
  66   if (!target_surface->screen_space_transform().GetInverse(
  67           &inverse_screen_space_transform))
  68     return target_surface->content_rect();
  69
  70   return gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
  71       inverse_screen_space_transform, screen_space_clip_rect));
  72 }
  73
  74 template <typename RenderSurfaceType>
  75 static Region TransformSurfaceOpaqueRegion(const Region& region,
  76                                            bool have_clip_rect,
  77                                            gfx::Rect clip_rect_in_new_target,
  78                                            const gfx::Transform& transform) {
  79   if (region.IsEmpty())
  80     return Region();
  81
  82   // Verify that rects within the |surface| will remain rects in its target
  83   // surface after applying |transform|. If this is true, then apply |transform|
  84   // to each rect within |region| in order to transform the entire Region.
  85
  86   // TODO(danakj): Find a rect interior to each transformed quad.
  87   if (!transform.Preserves2dAxisAlignment())
  88     return Region();
  89
  90   // TODO(danakj): If the Region is too complex, degrade gracefully here by
  91   // skipping rects in it.
  92   Region transformed_region;
  93   for (Region::Iterator rects(region); rects.has_rect(); rects.next()) {
  94     bool clipped;
  95     gfx::QuadF transformed_quad =
  96         MathUtil::MapQuad(transform, gfx::QuadF(rects.rect()), &clipped);
  97     gfx::Rect transformed_rect =
  98         gfx::ToEnclosedRect(transformed_quad.BoundingBox());
  99     DCHECK(!clipped);  // We only map if the transform preserves axis alignment.
 100     if (have_clip_rect)
 101       transformed_rect.Intersect(clip_rect_in_new_target);
 102     transformed_region.Union(transformed_rect);
 103   }
 104   return transformed_region;
 105 }
 106
 107 static inline bool LayerOpacityKnown(const Layer* layer) {
 108   return !layer->draw_opacity_is_animating();
 109 }
 110 static inline bool LayerOpacityKnown(const LayerImpl* layer) {
 111   return true;
 112 }
 113 static inline bool LayerTransformsToTargetKnown(const Layer* layer) {
 114   return !layer->draw_transform_is_animating();
 115 }
 116 static inline bool LayerTransformsToTargetKnown(const LayerImpl* layer) {
 117   return true;
 118 }
 119
 120 static inline bool SurfaceOpacityKnown(const RenderSurface* rs) {
 121   return !rs->draw_opacity_is_animating();
 122 }
 123 static inline bool SurfaceOpacityKnown(const RenderSurfaceImpl* rs) {
 124   return true;
 125 }
 126 static inline bool SurfaceTransformsToTargetKnown(const RenderSurface* rs) {
 127   return !rs->target_surface_transforms_are_animating();
 128 }
 129 static inline bool SurfaceTransformsToTargetKnown(const RenderSurfaceImpl* rs) {
 130   return true;
 131 }
 132 static inline bool SurfaceTransformsToScreenKnown(const RenderSurface* rs) {
 133   return !rs->screen_space_transforms_are_animating();
 134 }
 135 static inline bool SurfaceTransformsToScreenKnown(const RenderSurfaceImpl* rs) {
 136   return true;
 137 }
 138
 139 static inline bool LayerIsInUnsorted3dRenderingContext(const Layer* layer) {
 140   return layer->parent() && layer->parent()->preserves_3d();
 141 }
 142 static inline bool LayerIsInUnsorted3dRenderingContext(const LayerImpl* layer) {
 143   return false;
 144 }
 145
 146 template <typename LayerType>
 147 static inline bool LayerIsHidden(const LayerType* layer) {
 148   return layer->hide_layer_and_subtree() ||
 149          (layer->parent() && LayerIsHidden(layer->parent()));
 150 }
 151
 152 template <typename LayerType, typename RenderSurfaceType>
 153 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::EnterRenderTarget(
 154     const LayerType* new_target) {
 155   if (!stack_.empty() && stack_.back().target == new_target)
 156     return;
 157
 158   const LayerType* old_target = NULL;
 159   const RenderSurfaceType* old_ancestor_that_moves_pixels = NULL;
 160   if (!stack_.empty()) {
 161     old_target = stack_.back().target;
 162     old_ancestor_that_moves_pixels =
 163         old_target->render_surface()->nearest_ancestor_that_moves_pixels();
 164   }
 165   const RenderSurfaceType* new_ancestor_that_moves_pixels =
 166       new_target->render_surface()->nearest_ancestor_that_moves_pixels();
 167
 168   stack_.push_back(StackObject(new_target));
 169
 170   // We copy the screen occlusion into the new RenderSurface subtree, but we
 171   // never copy in the occlusion from inside the target, since we are looking
 172   // at a new RenderSurface target.
 173
 174   // If we are entering a subtree that is going to move pixels around, then the
 175   // occlusion we've computed so far won't apply to the pixels we're drawing
 176   // here in the same way. We discard the occlusion thus far to be safe, and
 177   // ensure we don't cull any pixels that are moved such that they become
 178   //  visible.
 179   bool entering_subtree_that_moves_pixels =
 180       new_ancestor_that_moves_pixels &&
 181       new_ancestor_that_moves_pixels != old_ancestor_that_moves_pixels;
 182
 183   bool have_transform_from_screen_to_new_target = false;
 184   gfx::Transform inverse_new_target_screen_space_transform(
 185       // Note carefully, not used if screen space transform is uninvertible.
 186       gfx::Transform::kSkipInitialization);
 187   if (SurfaceTransformsToScreenKnown(new_target->render_surface())) {
 188     have_transform_from_screen_to_new_target =
 189         new_target->render_surface()->screen_space_transform().GetInverse(
 190             &inverse_new_target_screen_space_transform);
 191   }
 192
 193   bool entering_root_target = new_target->parent() == NULL;
 194
 195   bool copy_outside_occlusion_forward =
 196       stack_.size() > 1 &&
 197       !entering_subtree_that_moves_pixels &&
 198       have_transform_from_screen_to_new_target &&
 199       !entering_root_target;
 200   if (!copy_outside_occlusion_forward)
 201     return;
 202
 203   int last_index = stack_.size() - 1;
 204   gfx::Transform old_target_to_new_target_transform(
 205       inverse_new_target_screen_space_transform,
 206       old_target->render_surface()->screen_space_transform());
 207   stack_[last_index].occlusion_from_outside_target =
 208       TransformSurfaceOpaqueRegion<RenderSurfaceType>(
 209           stack_[last_index - 1].occlusion_from_outside_target,
 210           false,
 211           gfx::Rect(),
 212           old_target_to_new_target_transform);
 213   stack_[last_index].occlusion_from_outside_target.Union(
 214       TransformSurfaceOpaqueRegion<RenderSurfaceType>(
 215           stack_[last_index - 1].occlusion_from_inside_target,
 216           false,
 217           gfx::Rect(),
 218           old_target_to_new_target_transform));
 219 }
 220
 221 template <typename LayerType, typename RenderSurfaceType>
 222 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::FinishedRenderTarget(
 223     const LayerType* finished_target) {
 224   // Make sure we know about the target surface.
 225   EnterRenderTarget(finished_target);
 226
 227   RenderSurfaceType* surface = finished_target->render_surface();
 228
 229   // Readbacks always happen on render targets so we only need to check
 230   // for readbacks here.
 231   bool target_is_only_for_copy_request =
 232       finished_target->HasCopyRequest() && LayerIsHidden(finished_target);
 233
 234   // If the occlusion within the surface can not be applied to things outside of
 235   // the surface's subtree, then clear the occlusion here so it won't be used.
 236   // TODO(senorblanco):  Make this smarter for SkImageFilter case:  once
 237   // SkImageFilters can report affectsOpacity(), call that.
 238   if (finished_target->mask_layer() ||
 239       !SurfaceOpacityKnown(surface) ||
 240       surface->draw_opacity() < 1 ||
 241       target_is_only_for_copy_request ||
 242       finished_target->filters().HasFilterThatAffectsOpacity() ||
 243       finished_target->filter()) {
 244     stack_.back().occlusion_from_outside_target.Clear();
 245     stack_.back().occlusion_from_inside_target.Clear();
 246   } else if (!SurfaceTransformsToTargetKnown(surface)) {
 247     stack_.back().occlusion_from_inside_target.Clear();
 248     stack_.back().occlusion_from_outside_target.Clear();
 249   }
 250 }
 251
 252 template <typename LayerType>
 253 static void ReduceOcclusionBelowSurface(LayerType* contributing_layer,
 254                                         gfx::Rect surface_rect,
 255                                         const gfx::Transform& surface_transform,
 256                                         LayerType* render_target,
 257                                         Region* occlusion_from_inside_target) {
 258   if (surface_rect.IsEmpty())
 259     return;
 260
 261   gfx::Rect affected_area_in_target = gfx::ToEnclosingRect(
 262       MathUtil::MapClippedRect(surface_transform, gfx::RectF(surface_rect)));
 263   if (contributing_layer->render_surface()->is_clipped()) {
 264     affected_area_in_target.Intersect(
 265         contributing_layer->render_surface()->clip_rect());
 266   }
 267   if (affected_area_in_target.IsEmpty())
 268     return;
 269
 270   int outset_top, outset_right, outset_bottom, outset_left;
 271   contributing_layer->background_filters().GetOutsets(
 272       &outset_top, &outset_right, &outset_bottom, &outset_left);
 273
 274   // The filter can move pixels from outside of the clip, so allow affected_area
 275   // to expand outside the clip.
 276   affected_area_in_target.Inset(
 277       -outset_left, -outset_top, -outset_right, -outset_bottom);
 278
 279   gfx::Rect FilterOutsetsInTarget(-outset_left,
 280                                   -outset_top,
 281                                   outset_left + outset_right,
 282                                   outset_top + outset_bottom);
 283
 284   Region affected_occlusion = IntersectRegions(*occlusion_from_inside_target,
 285                                                affected_area_in_target);
 286   Region::Iterator affected_occlusion_rects(affected_occlusion);
 287
 288   occlusion_from_inside_target->Subtract(affected_area_in_target);
 289   for (; affected_occlusion_rects.has_rect(); affected_occlusion_rects.next()) {
 290     gfx::Rect occlusion_rect = affected_occlusion_rects.rect();
 291
 292     // Shrink the rect by expanding the non-opaque pixels outside the rect.
 293
 294     // The left outset of the filters moves pixels on the right side of
 295     // the occlusion_rect into it, shrinking its right edge.
 296     int shrink_left =
 297         occlusion_rect.x() == affected_area_in_target.x() ? 0 : outset_right;
 298     int shrink_top =
 299         occlusion_rect.y() == affected_area_in_target.y() ? 0 : outset_bottom;
 300     int shrink_right =
 301         occlusion_rect.right() == affected_area_in_target.right() ?
 302         0 : outset_left;
 303     int shrink_bottom =
 304         occlusion_rect.bottom() == affected_area_in_target.bottom() ?
 305         0 : outset_top;
 306
 307     occlusion_rect.Inset(shrink_left, shrink_top, shrink_right, shrink_bottom);
 308
 309     occlusion_from_inside_target->Union(occlusion_rect);
 310   }
 311 }
 312
 313 template <typename LayerType, typename RenderSurfaceType>
 314 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::LeaveToRenderTarget(
 315     const LayerType* new_target) {
 316   int last_index = stack_.size() - 1;
 317   bool surface_will_be_at_top_after_pop =
 318       stack_.size() > 1 && stack_[last_index - 1].target == new_target;
 319
 320   // We merge the screen occlusion from the current RenderSurfaceImpl subtree
 321   // out to its parent target RenderSurfaceImpl. The target occlusion can be
 322   // merged out as well but needs to be transformed to the new target.
 323
 324   const LayerType* old_target = stack_[last_index].target;
 325   const RenderSurfaceType* old_surface = old_target->render_surface();
 326
 327   Region old_occlusion_from_inside_target_in_new_target =
 328       TransformSurfaceOpaqueRegion<RenderSurfaceType>(
 329           stack_[last_index].occlusion_from_inside_target,
 330           old_surface->is_clipped(),
 331           old_surface->clip_rect(),
 332           old_surface->draw_transform());
 333   if (old_target->has_replica() && !old_target->replica_has_mask()) {
 334     old_occlusion_from_inside_target_in_new_target.Union(
 335         TransformSurfaceOpaqueRegion<RenderSurfaceType>(
 336             stack_[last_index].occlusion_from_inside_target,
 337             old_surface->is_clipped(),
 338             old_surface->clip_rect(),
 339             old_surface->replica_draw_transform()));
 340   }
 341
 342   Region old_occlusion_from_outside_target_in_new_target =
 343       TransformSurfaceOpaqueRegion<RenderSurfaceType>(
 344           stack_[last_index].occlusion_from_outside_target,
 345           false,
 346           gfx::Rect(),
 347           old_surface->draw_transform());
 348
 349   gfx::Rect unoccluded_surface_rect;
 350   gfx::Rect unoccluded_replica_rect;
 351   if (old_target->background_filters().HasFilterThatMovesPixels()) {
 352     unoccluded_surface_rect = UnoccludedContributingSurfaceContentRect(
 353         old_target, false, old_surface->content_rect(), NULL);
 354     if (old_target->has_replica()) {
 355       unoccluded_replica_rect = UnoccludedContributingSurfaceContentRect(
 356           old_target, true, old_surface->content_rect(), NULL);
 357     }
 358   }
 359
 360   if (surface_will_be_at_top_after_pop) {
 361     // Merge the top of the stack down.
 362     stack_[last_index - 1].occlusion_from_inside_target.Union(
 363         old_occlusion_from_inside_target_in_new_target);
 364     // TODO(danakj): Strictly this should subtract the inside target occlusion
 365     // before union.
 366     if (new_target->parent()) {
 367       stack_[last_index - 1].occlusion_from_outside_target.Union(
 368           old_occlusion_from_outside_target_in_new_target);
 369     }
 370     stack_.pop_back();
 371   } else {
 372     // Replace the top of the stack with the new pushed surface.
 373     stack_.back().target = new_target;
 374     stack_.back().occlusion_from_inside_target =
 375         old_occlusion_from_inside_target_in_new_target;
 376     if (new_target->parent()) {
 377       stack_.back().occlusion_from_outside_target =
 378           old_occlusion_from_outside_target_in_new_target;
 379     } else {
 380       stack_.back().occlusion_from_outside_target.Clear();
 381     }
 382   }
 383
 384   if (!old_target->background_filters().HasFilterThatMovesPixels())
 385     return;
 386
 387   ReduceOcclusionBelowSurface(old_target,
 388                               unoccluded_surface_rect,
 389                               old_surface->draw_transform(),
 390                               new_target,
 391                               &stack_.back().occlusion_from_inside_target);
 392   ReduceOcclusionBelowSurface(old_target,
 393                               unoccluded_surface_rect,
 394                               old_surface->draw_transform(),
 395                               new_target,
 396                               &stack_.back().occlusion_from_outside_target);
 397
 398   if (!old_target->has_replica())
 399     return;
 400   ReduceOcclusionBelowSurface(old_target,
 401                               unoccluded_replica_rect,
 402                               old_surface->replica_draw_transform(),
 403                               new_target,
 404                               &stack_.back().occlusion_from_inside_target);
 405   ReduceOcclusionBelowSurface(old_target,
 406                               unoccluded_replica_rect,
 407                               old_surface->replica_draw_transform(),
 408                               new_target,
 409                               &stack_.back().occlusion_from_outside_target);
 410 }
 411
 412 template <typename LayerType, typename RenderSurfaceType>
 413 void OcclusionTrackerBase<LayerType, RenderSurfaceType>::
 414     MarkOccludedBehindLayer(const LayerType* layer) {
 415   DCHECK(!stack_.empty());
 416   DCHECK_EQ(layer->render_target(), stack_.back().target);
 417   if (stack_.empty())
 418     return;
 419
 420   if (!LayerOpacityKnown(layer) || layer->draw_opacity() < 1)
 421     return;
 422
 423   if (LayerIsInUnsorted3dRenderingContext(layer))
 424     return;
 425
 426   if (!LayerTransformsToTargetKnown(layer))
 427     return;
 428
 429   Region opaque_contents = layer->VisibleContentOpaqueRegion();
 430   if (opaque_contents.IsEmpty())
 431     return;
 432
 433   DCHECK(layer->visible_content_rect().Contains(opaque_contents.bounds()));
 434
 435   // TODO(danakj): Find a rect interior to each transformed quad.
 436   if (!layer->draw_transform().Preserves2dAxisAlignment())
 437     return;
 438
 439   gfx::Rect clip_rect_in_target = ScreenSpaceClipRectInTargetSurface(
 440       layer->render_target()->render_surface(), screen_space_clip_rect_);
 441   if (layer->is_clipped()) {
 442     clip_rect_in_target.Intersect(layer->clip_rect());
 443   } else {
 444     clip_rect_in_target.Intersect(
 445         layer->render_target()->render_surface()->content_rect());
 446   }
 447
 448   for (Region::Iterator opaque_content_rects(opaque_contents);
 449        opaque_content_rects.has_rect();
 450        opaque_content_rects.next()) {
 451     bool clipped;
 452     gfx::QuadF transformed_quad = MathUtil::MapQuad(
 453         layer->draw_transform(),
 454         gfx::QuadF(opaque_content_rects.rect()),
 455         &clipped);
 456     gfx::Rect transformed_rect =
 457         gfx::ToEnclosedRect(transformed_quad.BoundingBox());
 458     DCHECK(!clipped);  // We only map if the transform preserves axis alignment.
 459     transformed_rect.Intersect(clip_rect_in_target);
 460     if (transformed_rect.width() < minimum_tracking_size_.width() &&
 461         transformed_rect.height() < minimum_tracking_size_.height())
 462       continue;
 463     stack_.back().occlusion_from_inside_target.Union(transformed_rect);
 464
 465     if (!occluding_screen_space_rects_)
 466       continue;
 467
 468     // Save the occluding area in screen space for debug visualization.
 469     gfx::QuadF screen_space_quad = MathUtil::MapQuad(
 470         layer->render_target()->render_surface()->screen_space_transform(),
 471         gfx::QuadF(transformed_rect), &clipped);
 472     // TODO(danakj): Store the quad in the debug info instead of the bounding
 473     // box.
 474     gfx::Rect screen_space_rect =
 475         gfx::ToEnclosedRect(screen_space_quad.BoundingBox());
 476     occluding_screen_space_rects_->push_back(screen_space_rect);
 477   }
 478
 479   if (!non_occluding_screen_space_rects_)
 480     return;
 481
 482   Region non_opaque_contents =
 483       SubtractRegions(gfx::Rect(layer->content_bounds()), opaque_contents);
 484   for (Region::Iterator non_opaque_content_rects(non_opaque_contents);
 485        non_opaque_content_rects.has_rect();
 486        non_opaque_content_rects.next()) {
 487     // We've already checked for clipping in the MapQuad call above, these calls
 488     // should not clip anything further.
 489     gfx::Rect transformed_rect = gfx::ToEnclosedRect(
 490         MathUtil::MapClippedRect(layer->draw_transform(),
 491                                  gfx::RectF(non_opaque_content_rects.rect())));
 492     transformed_rect.Intersect(clip_rect_in_target);
 493     if (transformed_rect.IsEmpty())
 494       continue;
 495
 496     bool clipped;
 497     gfx::QuadF screen_space_quad = MathUtil::MapQuad(
 498         layer->render_target()->render_surface()->screen_space_transform(),
 499         gfx::QuadF(transformed_rect),
 500         &clipped);
 501     // TODO(danakj): Store the quad in the debug info instead of the bounding
 502     // box.
 503     gfx::Rect screen_space_rect =
 504         gfx::ToEnclosedRect(screen_space_quad.BoundingBox());
 505     non_occluding_screen_space_rects_->push_back(screen_space_rect);
 506   }
 507 }
 508
 509 template <typename LayerType, typename RenderSurfaceType>
 510 bool OcclusionTrackerBase<LayerType, RenderSurfaceType>::Occluded(
 511     const LayerType* render_target,
 512     gfx::Rect content_rect,
 513     const gfx::Transform& draw_transform,
 514     bool impl_draw_transform_is_unknown,
 515     bool is_clipped,
 516     gfx::Rect clip_rect_in_target,
 517     bool* has_occlusion_from_outside_target_surface) const {
 518   if (has_occlusion_from_outside_target_surface)
 519     *has_occlusion_from_outside_target_surface = false;
 520   if (prevent_occlusion_)
 521     return false;
 522
 523   DCHECK(!stack_.empty());
 524   if (stack_.empty())
 525     return false;
 526   if (content_rect.IsEmpty())
 527     return true;
 528   if (impl_draw_transform_is_unknown)
 529     return false;
 530
 531   // For tests with no render target.
 532   if (!render_target)
 533     return false;
 534
 535   DCHECK_EQ(render_target->render_target(), render_target);
 536   DCHECK(render_target->render_surface());
 537   DCHECK_EQ(render_target, stack_.back().target);
 538
 539   gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
 540   if (!draw_transform.GetInverse(&inverse_draw_transform))
 541     return false;
 542
 543   // Take the ToEnclosingRect at each step, as we want to contain any unoccluded
 544   // partial pixels in the resulting Rect.
 545   Region unoccluded_region_in_target_surface = gfx::ToEnclosingRect(
 546       MathUtil::MapClippedRect(draw_transform, gfx::RectF(content_rect)));
 547   // Layers can't clip across surfaces, so count this as internal occlusion.
 548   if (is_clipped)
 549     unoccluded_region_in_target_surface.Intersect(clip_rect_in_target);
 550   unoccluded_region_in_target_surface.Subtract(
 551       stack_.back().occlusion_from_inside_target);
 552   gfx::RectF unoccluded_rect_in_target_surface_without_outside_occlusion =
 553       unoccluded_region_in_target_surface.bounds();
 554   unoccluded_region_in_target_surface.Subtract(
 555       stack_.back().occlusion_from_outside_target);
 556
 557   // Treat other clipping as occlusion from outside the surface.
 558   // TODO(danakj): Clip to visibleContentRect?
 559   unoccluded_region_in_target_surface.Intersect(
 560       render_target->render_surface()->content_rect());
 561   unoccluded_region_in_target_surface.Intersect(
 562       ScreenSpaceClipRectInTargetSurface(render_target->render_surface(),
 563                                          screen_space_clip_rect_));
 564
 565   gfx::RectF unoccluded_rect_in_target_surface =
 566       unoccluded_region_in_target_surface.bounds();
 567
 568   if (has_occlusion_from_outside_target_surface) {
 569     // Check if the unoccluded rect shrank when applying outside occlusion.
 570     *has_occlusion_from_outside_target_surface = !gfx::SubtractRects(
 571         unoccluded_rect_in_target_surface_without_outside_occlusion,
 572         unoccluded_rect_in_target_surface).IsEmpty();
 573   }
 574
 575   return unoccluded_rect_in_target_surface.IsEmpty();
 576 }
 577
 578 template <typename LayerType, typename RenderSurfaceType>
 579 gfx::Rect OcclusionTrackerBase<LayerType, RenderSurfaceType>::
 580     UnoccludedContentRect(
 581         const LayerType* render_target,
 582         gfx::Rect content_rect,
 583         const gfx::Transform& draw_transform,
 584         bool impl_draw_transform_is_unknown,
 585         bool is_clipped,
 586         gfx::Rect clip_rect_in_target,
 587         bool* has_occlusion_from_outside_target_surface) const {
 588   if (has_occlusion_from_outside_target_surface)
 589     *has_occlusion_from_outside_target_surface = false;
 590   if (prevent_occlusion_)
 591     return content_rect;
 592
 593   DCHECK(!stack_.empty());
 594   if (stack_.empty())
 595     return content_rect;
 596   if (content_rect.IsEmpty())
 597     return content_rect;
 598   if (impl_draw_transform_is_unknown)
 599     return content_rect;
 600
 601   // For tests with no render target.
 602   if (!render_target)
 603     return content_rect;
 604
 605   DCHECK_EQ(render_target->render_target(), render_target);
 606   DCHECK(render_target->render_surface());
 607   DCHECK_EQ(render_target, stack_.back().target);
 608
 609   gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
 610   if (!draw_transform.GetInverse(&inverse_draw_transform))
 611     return content_rect;
 612
 613   // Take the ToEnclosingRect at each step, as we want to contain any unoccluded
 614   // partial pixels in the resulting Rect.
 615   Region unoccluded_region_in_target_surface = gfx::ToEnclosingRect(
 616       MathUtil::MapClippedRect(draw_transform, gfx::RectF(content_rect)));
 617   // Layers can't clip across surfaces, so count this as internal occlusion.
 618   if (is_clipped)
 619     unoccluded_region_in_target_surface.Intersect(clip_rect_in_target);
 620   unoccluded_region_in_target_surface.Subtract(
 621       stack_.back().occlusion_from_inside_target);
 622   gfx::RectF unoccluded_rect_in_target_surface_without_outside_occlusion =
 623       unoccluded_region_in_target_surface.bounds();
 624   unoccluded_region_in_target_surface.Subtract(
 625       stack_.back().occlusion_from_outside_target);
 626
 627   // Treat other clipping as occlusion from outside the surface.
 628   // TODO(danakj): Clip to visibleContentRect?
 629   unoccluded_region_in_target_surface.Intersect(
 630       render_target->render_surface()->content_rect());
 631   unoccluded_region_in_target_surface.Intersect(
 632       ScreenSpaceClipRectInTargetSurface(render_target->render_surface(),
 633                                          screen_space_clip_rect_));
 634
 635   gfx::RectF unoccluded_rect_in_target_surface =
 636       unoccluded_region_in_target_surface.bounds();
 637   gfx::Rect unoccluded_rect = gfx::ToEnclosingRect(
 638       MathUtil::ProjectClippedRect(inverse_draw_transform,
 639                                    unoccluded_rect_in_target_surface));
 640   unoccluded_rect.Intersect(content_rect);
 641
 642   if (has_occlusion_from_outside_target_surface) {
 643     // Check if the unoccluded rect shrank when applying outside occlusion.
 644     *has_occlusion_from_outside_target_surface = !gfx::SubtractRects(
 645         unoccluded_rect_in_target_surface_without_outside_occlusion,
 646         unoccluded_rect_in_target_surface).IsEmpty();
 647   }
 648
 649   return unoccluded_rect;
 650 }
 651
 652 template <typename LayerType, typename RenderSurfaceType>
 653 gfx::Rect OcclusionTrackerBase<LayerType, RenderSurfaceType>::
 654     UnoccludedContributingSurfaceContentRect(
 655         const LayerType* layer,
 656         bool for_replica,
 657         gfx::Rect content_rect,
 658         bool* has_occlusion_from_outside_target_surface) const {
 659   DCHECK(!stack_.empty());
 660   // The layer is a contributing render_target so it should have a surface.
 661   DCHECK(layer->render_surface());
 662   // The layer is a contributing render_target so its target should be itself.
 663   DCHECK_EQ(layer->render_target(), layer);
 664   // The layer should not be the root, else what is is contributing to?
 665   DCHECK(layer->parent());
 666   // This should be called while the layer is still considered the current
 667   // target in the occlusion tracker.
 668   DCHECK_EQ(layer, stack_.back().target);
 669
 670   if (has_occlusion_from_outside_target_surface)
 671     *has_occlusion_from_outside_target_surface = false;
 672   if (prevent_occlusion_)
 673     return content_rect;
 674
 675   if (content_rect.IsEmpty())
 676     return content_rect;
 677
 678   const RenderSurfaceType* surface = layer->render_surface();
 679   const LayerType* contributing_surface_render_target =
 680       layer->parent()->render_target();
 681
 682   if (!SurfaceTransformsToTargetKnown(surface))
 683     return content_rect;
 684
 685   gfx::Transform draw_transform =
 686       for_replica ? surface->replica_draw_transform()
 687                   : surface->draw_transform();
 688   gfx::Transform inverse_draw_transform(gfx::Transform::kSkipInitialization);
 689   if (!draw_transform.GetInverse(&inverse_draw_transform))
 690     return content_rect;
 691
 692   // A contributing surface doesn't get occluded by things inside its own
 693   // surface, so only things outside the surface can occlude it. That occlusion
 694   // is found just below the top of the stack (if it exists).
 695   bool has_occlusion = stack_.size() > 1;
 696
 697   // Take the ToEnclosingRect at each step, as we want to contain any unoccluded
 698   // partial pixels in the resulting Rect.
 699   Region unoccluded_region_in_target_surface = gfx::ToEnclosingRect(
 700       MathUtil::MapClippedRect(draw_transform, gfx::RectF(content_rect)));
 701   // Layers can't clip across surfaces, so count this as internal occlusion.
 702   if (surface->is_clipped())
 703     unoccluded_region_in_target_surface.Intersect(surface->clip_rect());
 704   if (has_occlusion) {
 705     const StackObject& second_last = stack_[stack_.size() - 2];
 706     unoccluded_region_in_target_surface.Subtract(
 707         second_last.occlusion_from_inside_target);
 708   }
 709   gfx::RectF unoccluded_rect_in_target_surface_without_outside_occlusion =
 710       unoccluded_region_in_target_surface.bounds();
 711   if (has_occlusion) {
 712     const StackObject& second_last = stack_[stack_.size() - 2];
 713     unoccluded_region_in_target_surface.Subtract(
 714         second_last.occlusion_from_outside_target);
 715   }
 716
 717   // Treat other clipping as occlusion from outside the target surface.
 718   unoccluded_region_in_target_surface.Intersect(
 719       contributing_surface_render_target->render_surface()->content_rect());
 720   unoccluded_region_in_target_surface.Intersect(
 721       ScreenSpaceClipRectInTargetSurface(
 722           contributing_surface_render_target->render_surface(),
 723           screen_space_clip_rect_));
 724
 725   gfx::RectF unoccluded_rect_in_target_surface =
 726       unoccluded_region_in_target_surface.bounds();
 727   gfx::Rect unoccluded_rect = gfx::ToEnclosingRect(
 728       MathUtil::ProjectClippedRect(inverse_draw_transform,
 729                                    unoccluded_rect_in_target_surface));
 730   unoccluded_rect.Intersect(content_rect);
 731
 732   if (has_occlusion_from_outside_target_surface) {
 733     // Check if the unoccluded rect shrank when applying outside occlusion.
 734     *has_occlusion_from_outside_target_surface = !gfx::SubtractRects(
 735         unoccluded_rect_in_target_surface_without_outside_occlusion,
 736         unoccluded_rect_in_target_surface).IsEmpty();
 737   }
 738
 739   return unoccluded_rect;
 740 }
 741
 742 // Instantiate (and export) templates here for the linker.
 743 template class OcclusionTrackerBase<Layer, RenderSurface>;
 744 template class OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>;
 745
 746 }  // namespace cc