cc: Modify visible geometry rect calc while appending quads.

cc/layers/picture_layer_impl.cc

Index: cc/layers/picture_layer_impl.cc
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index f1b74852d8d9157a32f82dfb2445b39a37e1a45c..d933a9ed254e0177f8b7a3a629bfbf26519bd824 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -177,6 +177,11 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
           .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,
@@ -185,8 +190,8 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
 
     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.
@@ -194,9 +199,9 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
         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());
@@ -207,7 +212,7 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
     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);
@@ -286,13 +291,15 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
        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()) {
@@ -316,9 +323,9 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
           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;
@@ -327,7 +334,7 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
         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();
@@ -348,8 +355,8 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
       }
       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)) {
@@ -357,14 +364,14 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
         ++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() *
@@ -378,7 +385,7 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
 
     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