cc: Move calculation of content rect to RenderSurfaceImpl class

cc/layers/render_surface_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/layers/render_surface_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 132 matching lines @@
 }
 
 void RenderSurfaceImpl::SetContentRect(const gfx::Rect& content_rect) {
   if (content_rect == draw_properties_.content_rect)
     return;
 
   surface_property_changed_ = true;
   draw_properties_.content_rect = content_rect;
 }
 
+void RenderSurfaceImpl::SetContentRectForTesting(const gfx::Rect& rect) {
+  SetContentRect(rect);
+}
+
+void RenderSurfaceImpl::CalculateContentRectFromAccumulatedContentRect(
+    int max_texture_size) {
+  // Root render surface use viewport, and does not calculate content rect.
+  DCHECK_NE(render_target(), this);
+
+  // Surface's content rect is the clipped accumulated content rect. By default
+  // use accumulated content rect, and then try to clip it.
+  gfx::Rect surface_content_rect = accumulated_content_rect();
+  // Early out if no need to clip.
+  if (!owning_layer_->replica_layer() && !owning_layer_->HasCopyRequest() &&
+      is_clipped()) {
+    if (!accumulated_content_rect().IsEmpty()) {
+      // Calculate projection from the target surface rect to local
+      // space. Non-invertible draw transforms means no able to bring clipped
+      // rect in target space back to local space, early out without clip.
+      gfx::Transform target_to_surface(gfx::Transform::kSkipInitialization);
+      if (draw_transform().GetInverse(&target_to_surface)) {
+        // Clip rect is in target space. Bring accumulated content rect to
+        // target space in preparation for clipping.
+        gfx::Rect accumulated_rect_in_target_space =
+            MathUtil::MapEnclosingClippedRect(draw_transform(),
+                                              accumulated_content_rect());
+        // If accumulated content rect is contained within clip rect, early out
+        // without clipping.
+        if (!clip_rect().Contains(accumulated_rect_in_target_space)) {
+          gfx::Rect clipped_accumulated_rect_in_target_space = clip_rect();
+          clipped_accumulated_rect_in_target_space.Intersect(
+              accumulated_rect_in_target_space);
+
+          if (!clipped_accumulated_rect_in_target_space.IsEmpty()) {
+            gfx::Rect clipped_accumulated_rect_in_local_space =
+                MathUtil::ProjectEnclosingClippedRect(
+                    target_to_surface,
+                    clipped_accumulated_rect_in_target_space);
+            // Bringing clipped accumulated rect back to local space may result
+            // in inflationg due to axis-alignment.

[ajuma, 2016/04/19 19:20:37]

typo: inflation

+            surface_content_rect.Intersect(
+                clipped_accumulated_rect_in_local_space);
+          } else {
+            // All accumulated content rect is clipped out.
+            surface_content_rect = gfx::Rect();
+          }
+        }
+      }
+    }
+  }

[ajuma, 2016/04/19 19:20:37]

Suggestion for making this easier to read: put this into a
ComputeClippedContentRect helper, and then early-return when you can early-out
instead of having nested if statements.

+  // The RenderSurfaceImpl backing texture cannot exceed the maximum
+  // supported texture size.
+  surface_content_rect.set_width(
+      std::min(surface_content_rect.width(), max_texture_size));
+  surface_content_rect.set_height(
+      std::min(surface_content_rect.height(), max_texture_size));
+
+  SetContentRect(surface_content_rect);
+}
+
+void RenderSurfaceImpl::SetContentRectToViewport() {
+  // Only root render surface use viewport as content rect.
+  DCHECK_EQ(render_target(), this);
+  gfx::Rect viewport = gfx::ToEnclosingRect(owning_layer_->layer_tree_impl()
+                                                ->property_trees()
+                                                ->clip_tree.ViewportClip());
+  SetContentRect(viewport);
+}
+
 void RenderSurfaceImpl::ClearAccumulatedContentRect() {
   accumulated_content_rect_ = gfx::Rect();
 }
 
 void RenderSurfaceImpl::AccumulateContentRectFromContributingLayer(
     LayerImpl* layer) {
   DCHECK(layer->DrawsContent());
   DCHECK_EQ(this, layer->render_target());
 
   // Root render surface doesn't accumulate content rect, it always uses
@@ skipping 112 matching lines @@
   RenderPassDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_quad_state, content_rect(), visible_layer_rect,
                render_pass_id, mask_resource_id, mask_uv_scale,
                mask_texture_size, owning_layer_->filters(),
                owning_layer_to_target_scale,
                owning_layer_->background_filters());
 }
 
 }  // namespace cc