cc: Avoid pointless gfx::Point/Size contructors when making Rects.

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 152 matching lines @@
     // be cached instead of computing it redundantly for every layer.
     visible_rect_in_target_surface_space.Intersect(
         ancestor_clip_rect_in_descendant_surface_space);
   }
 
   if (visible_rect_in_target_surface_space.IsEmpty())
     return gfx::Rect();
 
   return CalculateVisibleRectWithCachedLayerRect(
       visible_rect_in_target_surface_space,
-      gfx::Rect(gfx::Point(), layer->content_bounds()),
+      gfx::Rect(layer->content_bounds()),
       layer_rect_in_target_space,
       layer->draw_transform());
 }
 
 static inline bool TransformToParentIsKnown(LayerImpl* layer) { return true; }
 
 static inline bool TransformToParentIsKnown(Layer* layer) {
 
   return !layer->TransformIsAnimating();
 }
@@ skipping 696 matching lines @@
   // causes jank.
   bool adjust_text_aa =
       !animating_opacity_to_screen && !animating_transform_to_screen;
   // To avoid color fringing, LCD text should only be used on opaque layers with
   // just integral translation.
   bool layer_can_use_lcd_text =
       subtree_can_use_lcd_text && (accumulated_draw_opacity == 1.f) &&
       layer_draw_properties.target_space_transform.
           IsIdentityOrIntegerTranslation();
 
-  gfx::RectF content_rect(gfx::PointF(), layer->content_bounds());
+  gfx::RectF content_rect(layer->content_bounds());
 
   // full_hierarchy_matrix is the matrix that transforms objects between screen
   // space (except projection matrix) and the most recent RenderSurfaceImpl's
   // space.  next_hierarchy_matrix will only change if this layer uses a new
   // RenderSurfaceImpl, otherwise remains the same.
   gfx::Transform next_hierarchy_matrix = full_hierarchy_matrix;
   gfx::Transform sublayer_matrix;
 
   gfx::Vector2dF render_surface_sublayer_scale =
       MathUtil::ComputeTransform2dScaleComponents(
@@ skipping 65 matching lines @@
     // the tree. This way, we can avoid transforming clip rects from ancestor
     // target surface space to current target surface space that could cause
     // more w < 0 headaches.
     subtree_should_be_clipped = false;
 
     if (layer->mask_layer()) {
       DrawProperties<LayerType, RenderSurfaceType>& mask_layer_draw_properties =
           layer->mask_layer()->draw_properties();
       mask_layer_draw_properties.render_target = layer;
       mask_layer_draw_properties.visible_content_rect =
-          gfx::Rect(gfx::Point(), layer->content_bounds());
+          gfx::Rect(layer->content_bounds());
     }
 
     if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
       DrawProperties<LayerType, RenderSurfaceType>&
       replica_mask_draw_properties =
           layer->replica_layer()->mask_layer()->draw_properties();
       replica_mask_draw_properties.render_target = layer;
       replica_mask_draw_properties.visible_content_rect =
-          gfx::Rect(gfx::Point(), layer->content_bounds());
+          gfx::Rect(layer->content_bounds());
     }
 
     // TODO(senorblanco): make this smarter for the SkImageFilter case (check
     // for pixel-moving filters)
     if (layer->filters().hasFilterThatMovesPixels() || layer->filter())
       nearest_ancestor_that_moves_pixels = render_surface;
 
     // The render surface clip rect is expressed in the space where this surface
     // draws, i.e. the same space as clip_rect_from_ancestor.
     render_surface->SetIsClipped(ancestor_clips_subtree);
@@ skipping 299 matching lines @@
     std::vector<scoped_refptr<Layer> >* render_surface_layer_list) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
   gfx::Transform device_scale_transform;
   device_scale_transform.Scale(device_scale_factor, device_scale_factor);
   std::vector<scoped_refptr<Layer> > dummy_layer_list;
 
   // The root layer's render_surface should receive the device viewport as the
   // initial clip rect.
   bool subtree_should_be_clipped = true;
-  gfx::Rect device_viewport_rect(gfx::Point(), device_viewport_size);
+  gfx::Rect device_viewport_rect(device_viewport_size);
   bool update_tile_priorities = false;
 
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformation<Layer>(root_layer);
   CalculateDrawPropertiesInternal<Layer,
                                   std::vector<scoped_refptr<Layer> >,
                                   RenderSurface>(root_layer,
                                                  device_scale_transform,
@@ skipping 32 matching lines @@
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
   gfx::Transform device_scale_transform;
   device_scale_transform.Scale(device_scale_factor, device_scale_factor);
   std::vector<LayerImpl*> dummy_layer_list;
   LayerSorter layer_sorter;
 
   // The root layer's render_surface should receive the device viewport as the
   // initial clip rect.
   bool subtree_should_be_clipped = true;
-  gfx::Rect device_viewport_rect(gfx::Point(), device_viewport_size);
+  gfx::Rect device_viewport_rect(device_viewport_size);
 
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformation<LayerImpl>(root_layer);
   CalculateDrawPropertiesInternal<LayerImpl,
                                   std::vector<LayerImpl*>,
                                   RenderSurfaceImpl>(
       root_layer,
       device_scale_transform,
@@ skipping 124 matching lines @@
   for (LayerIteratorType
            it = LayerIteratorType::Begin(&render_surface_layer_list);
        it != end;
        ++it) {
     // We don't want to consider render_surfaces for hit testing.
     if (!it.represents_itself())
       continue;
 
     LayerImpl* current_layer = (*it);
 
-    gfx::RectF content_rect(gfx::PointF(), current_layer->content_bounds());
+    gfx::RectF content_rect(current_layer->content_bounds());
     if (!PointHitsRect(screen_space_point,
                        current_layer->screen_space_transform(),
                        content_rect))
       continue;
 
     // At this point, we think the point does hit the layer, but we need to walk
     // up the parents to ensure that the layer was not clipped in such a way
     // that the hit point actually should not hit the layer.
     if (PointIsClippedBySurfaceOrClipRect(screen_space_point, current_layer))
       continue;
@@ skipping 60 matching lines @@
   // At this point, we think the point does hit the touch event handler region
   // on the layer, but we need to walk up the parents to ensure that the layer
   // was not clipped in such a way that the hit point actually should not hit
   // the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc