Propogate the clip rect for visible_content_rect into surfaces.

cc/trees/layer_tree_host_common.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_host_common.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 1927 matching lines @@
       // but in either case, we'll be clipping to the projected clip rect of our
       // ancestor.
       gfx::Transform inverse_surface_draw_transform(
           gfx::Transform::kSkipInitialization);
       if (!render_surface->draw_transform().GetInverse(
               &inverse_surface_draw_transform)) {
         // TODO(shawnsingh): Either we need to handle uninvertible transforms
         // here, or DCHECK that the transform is invertible.
       }
 
+      gfx::Rect surface_clip_rect_in_target_space = gfx::IntersectRects(
+          data_from_ancestor.clip_rect_of_target_surface_in_target_space,
+          ancestor_clip_rect_in_target_space);
       gfx::Rect projected_surface_rect = MathUtil::ProjectEnclosingClippedRect(
-          inverse_surface_draw_transform, ancestor_clip_rect_in_target_space);
+          inverse_surface_draw_transform, surface_clip_rect_in_target_space);
 
       if (layer_draw_properties.num_unclipped_descendants > 0) {
         // If we have unclipped descendants, we cannot count on the render
         // surface's bounds clipping our subtree: the unclipped descendants
         // could cause us to expand our bounds. In this case, we must rely on
         // layer clipping for correctess. NB: since we can only encounter
         // translations between a clip child and its clip parent, clipping is
         // guaranteed to be exact in this case.
         layer_or_ancestor_clips_descendants = true;
         clip_rect_in_target_space = projected_surface_rect;
@@ skipping 360 matching lines @@
                globals.layer_sorter);
   }
 
   UpdateAccumulatedSurfaceState<LayerType>(
       layer, local_drawable_content_rect_of_subtree, accumulated_surface_state);
 
   if (layer->HasContributingDelegatedRenderPasses()) {
     layer->render_target()->render_surface()->
         AddContributingDelegatedRenderPassLayer(layer);
   }
-}
+}  // NOLINT(readability/fn_size)
 
 template <typename LayerType, typename RenderSurfaceLayerListType>
 static void ProcessCalcDrawPropsInputs(
     const LayerTreeHostCommon::CalcDrawPropsInputs<LayerType,
                                                    RenderSurfaceLayerListType>&
         inputs,
     SubtreeGlobals<LayerType>* globals,
     DataForRecursion<LayerType>* data_for_recursion) {
   DCHECK(inputs.root_layer);
   DCHECK(IsRootLayer(inputs.root_layer));
@@ skipping 92 matching lines @@
       inputs->current_render_surface_layer_list_id);
 
   // The dummy layer list should not have been used.
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(inputs->root_layer->render_surface());
 }
 
 }  // namespace cc