cc: Make occlusion a draw property.

cc/trees/layer_tree_impl.cc

 // Copyright 2011 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/layer_tree_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 562 matching lines @@
         settings().layer_transforms_should_scale_layer_contents,
         settings().verify_property_trees,
         &render_surface_layer_list_, render_surface_layer_list_id_);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   }
 
   {
     TRACE_EVENT_BEGIN2("cc", "LayerTreeImpl::UpdateTilePriorities", "IsActive",
                        IsActiveTree(), "SourceFrameNumber",
                        source_frame_number_);
-    scoped_ptr<OcclusionTracker<LayerImpl>> occlusion_tracker;
-    if (settings().use_occlusion_for_tile_prioritization) {
-      occlusion_tracker.reset(new OcclusionTracker<LayerImpl>(
-          root_layer()->render_surface()->content_rect()));
-      occlusion_tracker->set_minimum_tracking_size(
-          settings().minimum_occlusion_tracking_size);
-    }
-
-    bool resourceless_software_draw = (layer_tree_host_impl_->GetDrawMode() ==
-                                       DRAW_MODE_RESOURCELESS_SOFTWARE);
+    OcclusionTracker<LayerImpl> occlusion_tracker(
+        root_layer()->render_surface()->content_rect());
+    occlusion_tracker.set_minimum_tracking_size(
+        settings().minimum_occlusion_tracking_size);
 
     // LayerIterator is used here instead of CallFunctionForSubtree to only
     // UpdateTilePriorities on layers that will be visible (and thus have valid
     // draw properties) and not because any ordering is required.
-    typedef LayerIterator<LayerImpl> LayerIteratorType;
-    LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list_);
+    auto end = LayerIterator<LayerImpl>::End(&render_surface_layer_list_);
+    for (auto it = LayerIterator<LayerImpl>::Begin(&render_surface_layer_list_);
+         it != end; ++it) {
+      occlusion_tracker.EnterLayer(it);
+
+      if (it.represents_itself()) {
+        Occlusion occlusion =
+            occlusion_tracker.GetCurrentOcclusionForLayer(it->draw_transform());
+        it->draw_properties().occlusion_in_content_space = occlusion;
+      }
+
+      if (it.represents_contributing_render_surface()) {
+        it->render_surface()->set_occlusion_in_content_space(
+            occlusion_tracker.GetCurrentOcclusionForContributingSurface(
+                it->render_surface()->draw_transform()));
+        it->render_surface()->set_replica_occlusion_in_content_space(
+            occlusion_tracker.GetCurrentOcclusionForContributingSurface(
+                it->render_surface()->replica_draw_transform()));
+        if (LayerImpl* mask = it->mask_layer()) {
+          mask->draw_properties().occlusion_in_content_space =
+              occlusion_tracker.GetCurrentOcclusionForContributingSurface(
+                  it->render_surface()->draw_transform() *

[vmpstr, 2015/02/13 00:24:54]

This is probably lack of knowledge for my part, but why is it that for a layer
we use it->draw_transform() but for a mask layer we use
render_surface->draw_transform() * it->draw_transform()?

[danakj, 2015/02/13 00:27:07]

The mask is used when drawing the surface, so I think it should have the same
occlusion as the surface, ie it should not be occluded by things inside the
surface.

[enne (OOO), 2015/02/13 00:30:23]

Occlusion on masks is not used anywhere, as it's redundant with the surface. 
(If you did use it, what would you do if the mask and surface disagreed?)

I'd say to just leave the mask occlusion unset / totally unoccluded.

+                  it->draw_transform());
+        }
+        if (it->replica_layer()) {
+          if (LayerImpl* mask = it->replica_layer()->mask_layer()) {
+            mask->draw_properties().occlusion_in_content_space =
+                occlusion_tracker.GetCurrentOcclusionForContributingSurface(
+                    it->render_surface()->replica_draw_transform() *
+                    it->draw_transform());
+          }
+        }
+      }
+
+      occlusion_tracker.LeaveLayer(it);
+    }
+
+    unoccluded_screen_space_region_ =
+        occlusion_tracker.ComputeVisibleRegionInScreen();
+
+    const bool resourceless_software_draw =
+        (layer_tree_host_impl_->GetDrawMode() ==
+         DRAW_MODE_RESOURCELESS_SOFTWARE);
+    static const Occlusion kEmptyOcclusion;
     size_t layers_updated_count = 0;
     bool tile_priorities_updated = false;
-    for (LayerIteratorType it =
-             LayerIteratorType::Begin(&render_surface_layer_list_);
-         it != end;
-         ++it) {
-      if (occlusion_tracker)
-        occlusion_tracker->EnterLayer(it);
-
-      LayerImpl* layer = *it;
-      const Occlusion& occlusion_in_content_space =
-          occlusion_tracker ? occlusion_tracker->GetCurrentOcclusionForLayer(
-                                  layer->draw_transform())
-                            : Occlusion();
-
-      if (it.represents_itself()) {
-        tile_priorities_updated |= layer->UpdateTiles(
-            occlusion_in_content_space, resourceless_software_draw);
-        ++layers_updated_count;
-      }
-
-      if (!it.represents_contributing_render_surface()) {
-        if (occlusion_tracker)
-          occlusion_tracker->LeaveLayer(it);
+    for (PictureLayerImpl* layer : picture_layers_) {
+      // TODO(danakj): Remove this to fix crbug.com/446751
+      if (!layer->IsDrawnRenderSurfaceLayerListMember())
         continue;
-      }
-
-      if (layer->mask_layer()) {
-        tile_priorities_updated |= layer->mask_layer()->UpdateTiles(
-            occlusion_in_content_space, resourceless_software_draw);
-        ++layers_updated_count;
-      }
-      if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
-        tile_priorities_updated |=
-            layer->replica_layer()->mask_layer()->UpdateTiles(
-                occlusion_in_content_space, resourceless_software_draw);
-        ++layers_updated_count;
-      }
-
-      if (occlusion_tracker)
-        occlusion_tracker->LeaveLayer(it);
+      ++layers_updated_count;
+      const Occlusion& occlusion =
+          settings().use_occlusion_for_tile_prioritization
+              ? layer->draw_properties().occlusion_in_content_space
+              : kEmptyOcclusion;
+      tile_priorities_updated |=
+          layer->UpdateTiles(occlusion, resourceless_software_draw);

[vmpstr, 2015/02/13 00:24:54]

mask and replica mask also need update tiles, right?

     }
 
     if (tile_priorities_updated)
       DidModifyTilePriorities();
 
     TRACE_EVENT_END1("cc", "LayerTreeImpl::UpdateTilePriorities",
                      "layers_updated_count", layers_updated_count);
   }
 
   DCHECK(!needs_update_draw_properties_) <<
       "CalcDrawProperties should not set_needs_update_draw_properties()";
   return true;
 }
 
 const LayerImplList& LayerTreeImpl::RenderSurfaceLayerList() const {
   // If this assert triggers, then the list is dirty.
   DCHECK(!needs_update_draw_properties_);
   return render_surface_layer_list_;
 }
 
+const Region& LayerTreeImpl::UnoccludedScreenSpaceRegion() const {
+  // If this assert triggers, then the render_surface_layer_list_ is dirty, so
+  // the unoccluded_screen_space_region_ is not valid anymore.
+  DCHECK(!needs_update_draw_properties_);
+  return unoccluded_screen_space_region_;
+}
+
 gfx::Size LayerTreeImpl::ScrollableSize() const {
   LayerImpl* root_scroll_layer = OuterViewportScrollLayer()
                                      ? OuterViewportScrollLayer()
                                      : InnerViewportScrollLayer();
   if (!root_scroll_layer || root_scroll_layer->children().empty())
     return gfx::Size();
   return root_scroll_layer->children()[0]->bounds();
 }
 
 LayerImpl* LayerTreeImpl::LayerById(int id) {
@@ skipping 920 matching lines @@
     scoped_ptr<PendingPageScaleAnimation> pending_animation) {
   pending_page_scale_animation_ = pending_animation.Pass();
 }
 
 scoped_ptr<PendingPageScaleAnimation>
     LayerTreeImpl::TakePendingPageScaleAnimation() {
   return pending_page_scale_animation_.Pass();
 }
 
 }  // namespace cc