cc: Modify visible geometry rect calc while appending quads.

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 159 matching lines @@
     return;
   }
 
   float max_contents_scale = MaximumTilingContentsScale();
   PopulateScaledSharedQuadState(shared_quad_state, max_contents_scale);
   Occlusion scaled_occlusion =
       draw_properties()
           .occlusion_in_content_space.GetOcclusionWithGivenDrawTransform(
               shared_quad_state->quad_to_target_transform);
 
+  gfx::Rect scaled_visible_layer_rect =
+      ScaleToEnclosingRect(visible_layer_rect(), max_contents_scale);
+  gfx::Rect visible_geometry_rect =

[enne (OOO), 2016/07/08 17:58:55]

Maybe an early out here if visible geometry rect is empty too?

+      scaled_occlusion.GetUnoccludedContentRect(scaled_visible_layer_rect);
+
   if (current_draw_mode_ == DRAW_MODE_RESOURCELESS_SOFTWARE) {
     AppendDebugBorderQuad(
         render_pass, shared_quad_state->quad_layer_bounds, shared_quad_state,
         append_quads_data, DebugColors::DirectPictureBorderColor(),
         DebugColors::DirectPictureBorderWidth(layer_tree_impl()));
 
     gfx::Rect geometry_rect = shared_quad_state->visible_quad_layer_rect;
     gfx::Rect opaque_rect = contents_opaque() ? geometry_rect : gfx::Rect();
-    gfx::Rect visible_geometry_rect =
-        scaled_occlusion.GetUnoccludedContentRect(geometry_rect);
+    gfx::Rect visible_tile_rect = visible_geometry_rect;
+    visible_tile_rect.Intersect(geometry_rect);
 
     // The raster source may not be valid over the entire visible rect,
     // and rastering outside of that may cause incorrect pixels.
     gfx::Rect scaled_recorded_viewport = gfx::ScaleToEnclosingRect(
         raster_source_->RecordedViewport(), max_contents_scale);
     geometry_rect.Intersect(scaled_recorded_viewport);
     opaque_rect.Intersect(scaled_recorded_viewport);
-    visible_geometry_rect.Intersect(scaled_recorded_viewport);
+    visible_tile_rect.Intersect(scaled_recorded_viewport);
 
-    if (visible_geometry_rect.IsEmpty())
+    if (visible_tile_rect.IsEmpty())
       return;
 
     DCHECK(raster_source_->HasRecordings());
     gfx::Rect quad_content_rect = shared_quad_state->visible_quad_layer_rect;
     gfx::Size texture_size = quad_content_rect.size();
     gfx::RectF texture_rect = gfx::RectF(gfx::SizeF(texture_size));
 
     PictureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
     quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
-                 visible_geometry_rect, texture_rect, texture_size,
+                 visible_tile_rect, texture_rect, texture_size,
                  nearest_neighbor_, RGBA_8888, quad_content_rect,
                  max_contents_scale, raster_source_);
     ValidateQuadResources(quad);
     return;
   }
 
   AppendDebugBorderQuad(render_pass, shared_quad_state->quad_layer_bounds,
                         shared_quad_state, append_quads_data);
 
   if (ShowDebugBorders()) {
@@ skipping 58 matching lines @@
   size_t on_demand_missing_tile_count = 0u;
   only_used_low_res_last_append_quads_ = true;
   gfx::Rect scaled_recorded_viewport = gfx::ScaleToEnclosingRect(
       raster_source_->RecordedViewport(), max_contents_scale);
   for (PictureLayerTilingSet::CoverageIterator iter(
            tilings_.get(), max_contents_scale,
            shared_quad_state->visible_quad_layer_rect, ideal_contents_scale_);
        iter; ++iter) {
     gfx::Rect geometry_rect = iter.geometry_rect();
     gfx::Rect opaque_rect = contents_opaque() ? geometry_rect : gfx::Rect();
-    gfx::Rect visible_geometry_rect =
-        scaled_occlusion.GetUnoccludedContentRect(geometry_rect);
-    if (visible_geometry_rect.IsEmpty())
+
+    gfx::Rect visible_tile_rect = visible_geometry_rect;
+    visible_tile_rect.Intersect(geometry_rect);
+
+    if (visible_tile_rect.IsEmpty())
       continue;
 
     append_quads_data->visible_layer_area +=
-        visible_geometry_rect.width() * visible_geometry_rect.height();
+        visible_tile_rect.width() * visible_tile_rect.height();
 
     bool has_draw_quad = false;
     if (*iter && iter->draw_info().IsReadyToDraw()) {
       const TileDrawInfo& draw_info = iter->draw_info();
       switch (draw_info.mode()) {
         case TileDrawInfo::RESOURCE_MODE: {
           gfx::RectF texture_rect = iter.texture_rect();
 
           // The raster_contents_scale_ is the best scale that the layer is
           // trying to produce, even though it may not be ideal. Since that's
           // the best the layer can promise in the future, consider those as
           // complete. But if a tile is ideal scale, we don't want to consider
           // it incomplete and trying to replace it with a tile at a worse
           // scale.
           if (iter->contents_scale() != raster_contents_scale_ &&
               iter->contents_scale() != ideal_contents_scale_ &&
               geometry_rect.Intersects(scaled_viewport_for_tile_priority)) {
             append_quads_data->num_incomplete_tiles++;
           }
 
           TileDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
           quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
-                       visible_geometry_rect, draw_info.resource_id(),
-                       texture_rect, draw_info.resource_size(),
-                       draw_info.contents_swizzled(), nearest_neighbor_);
+                       visible_tile_rect, draw_info.resource_id(), texture_rect,
+                       draw_info.resource_size(), draw_info.contents_swizzled(),
+                       nearest_neighbor_);
           ValidateQuadResources(quad);
           iter->draw_info().set_was_ever_used_to_draw();
           has_draw_quad = true;
           break;
         }
         case TileDrawInfo::SOLID_COLOR_MODE: {
           SolidColorDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-          quad->SetNew(shared_quad_state, geometry_rect, visible_geometry_rect,
+          quad->SetNew(shared_quad_state, geometry_rect, visible_tile_rect,
                        draw_info.solid_color(), false);
           ValidateQuadResources(quad);
           iter->draw_info().set_was_ever_used_to_draw();
           has_draw_quad = true;
           break;
         }
         case TileDrawInfo::OOM_MODE:
           break;  // Checkerboard.
       }
     }
 
     if (!has_draw_quad) {
       // Checkerboard.
       SkColor color = SafeOpaqueBackgroundColor();
       if (ShowDebugBorders()) {
         // Fill the whole tile with the missing tile color.
         color = DebugColors::OOMTileBorderColor();
       }
       SolidColorDrawQuad* quad =
           render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-      quad->SetNew(shared_quad_state, geometry_rect, visible_geometry_rect,
-                   color, false);
+      quad->SetNew(shared_quad_state, geometry_rect, visible_tile_rect, color,
+                   false);
       ValidateQuadResources(quad);
 
       if (geometry_rect.Intersects(scaled_viewport_for_tile_priority)) {
         append_quads_data->num_missing_tiles++;
         ++missing_tile_count;
       }
       int64_t checkerboarded_area =
-          visible_geometry_rect.width() * visible_geometry_rect.height();
+          visible_tile_rect.width() * visible_tile_rect.height();
       append_quads_data->checkerboarded_visible_content_area +=
           checkerboarded_area;
       // Intersect checkerboard rect with interest rect to generate rect where
       // we checkerboarded and has recording. The area where we don't have
       // recording is not necessarily a Rect, and its area is calculated using
       // subtraction.
-      gfx::Rect visible_rect_has_recording = visible_geometry_rect;
+      gfx::Rect visible_rect_has_recording = visible_tile_rect;
       visible_rect_has_recording.Intersect(scaled_recorded_viewport);
       int64_t checkerboarded_has_recording_area =
           visible_rect_has_recording.width() *
           visible_rect_has_recording.height();
       append_quads_data->checkerboarded_needs_raster_content_area +=
           checkerboarded_has_recording_area;
       append_quads_data->checkerboarded_no_recording_content_area +=
           checkerboarded_area - checkerboarded_has_recording_area;
       continue;
     }
 
     if (iter.resolution() != HIGH_RESOLUTION) {
       append_quads_data->approximated_visible_content_area +=
-          visible_geometry_rect.width() * visible_geometry_rect.height();
+          visible_tile_rect.width() * visible_tile_rect.height();
     }
 
     // If we have a draw quad, but it's not low resolution, then
     // mark that we've used something other than low res to draw.
     if (iter.resolution() != LOW_RESOLUTION)
       only_used_low_res_last_append_quads_ = false;
 
     if (last_append_quads_tilings_.empty() ||
         last_append_quads_tilings_.back() != iter.CurrentTiling()) {
       last_append_quads_tilings_.push_back(iter.CurrentTiling());
@@ skipping 912 matching lines @@
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() &&
          is_drawn_render_surface_layer_list_member();
 }
 
 }  // namespace cc