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);
+}
+
+gfx::Rect RenderSurfaceImpl::CalculateClippedAccumulatedContentRect() {
+  if (owning_layer_->replica_layer() || owning_layer_->HasCopyRequest() ||
+      !is_clipped())
+    return accumulated_content_rect();
+
+  if (accumulated_content_rect().IsEmpty())
+    return gfx::Rect();
+
+  // 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))
+    return accumulated_content_rect();
+
+  // 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))
+    return accumulated_content_rect();
+
+  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())
+    return gfx::Rect();
+
+  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 inflation due to axis-alignment.
+  clipped_accumulated_rect_in_local_space.Intersect(accumulated_content_rect());
+  return clipped_accumulated_rect_in_local_space;
+}
+
+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 = CalculateClippedAccumulatedContentRect();
+
+  // 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