cc: Remove unused arguments from CalculateContentsScale

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 914 matching lines @@
     float maximum_animation_contents_scale,
     float page_scale_factor,
     float device_scale_factor) {
   layer->draw_properties().ideal_contents_scale = ideal_contents_scale;
   layer->draw_properties().maximum_animation_contents_scale =
       maximum_animation_contents_scale;
   layer->draw_properties().page_scale_factor = page_scale_factor;
   layer->draw_properties().device_scale_factor = device_scale_factor;
 }
 
-static inline void CalculateContentsScale(
-    LayerImpl* layer,
-    float contents_scale,
-    float device_scale_factor,
-    float page_scale_factor,
-    float maximum_animation_contents_scale,
-    bool animating_transform_to_screen) {
+static inline void CalculateContentsScale(LayerImpl* layer,
+                                          float contents_scale) {
   // LayerImpl has all of its content scales and bounds pushed from the Main
   // thread during commit and just uses those values as-is.
 }
 
-static inline void CalculateContentsScale(
-    Layer* layer,
-    float contents_scale,
-    float device_scale_factor,
-    float page_scale_factor,
-    float maximum_animation_contents_scale,
-    bool animating_transform_to_screen) {
+static inline void CalculateContentsScale(Layer* layer, float contents_scale) {
   layer->CalculateContentsScale(contents_scale,
-                                device_scale_factor,
-                                page_scale_factor,
-                                maximum_animation_contents_scale,
-                                animating_transform_to_screen,
                                 &layer->draw_properties().contents_scale_x,
                                 &layer->draw_properties().contents_scale_y,
                                 &layer->draw_properties().content_bounds);
 
   Layer* mask_layer = layer->mask_layer();
   if (mask_layer) {
     mask_layer->CalculateContentsScale(
         contents_scale,
-        device_scale_factor,
-        page_scale_factor,
-        maximum_animation_contents_scale,
-        animating_transform_to_screen,
         &mask_layer->draw_properties().contents_scale_x,
         &mask_layer->draw_properties().contents_scale_y,
         &mask_layer->draw_properties().content_bounds);
   }
 
   Layer* replica_mask_layer =
       layer->replica_layer() ? layer->replica_layer()->mask_layer() : NULL;
   if (replica_mask_layer) {
     replica_mask_layer->CalculateContentsScale(
         contents_scale,
-        device_scale_factor,
-        page_scale_factor,
-        maximum_animation_contents_scale,
-        animating_transform_to_screen,
         &replica_mask_layer->draw_properties().contents_scale_x,
         &replica_mask_layer->draw_properties().contents_scale_y,
         &replica_mask_layer->draw_properties().content_bounds);
   }
 }
 
 static inline void UpdateLayerContentsScale(
     LayerImpl* layer,
     bool can_adjust_raster_scale,
     float ideal_contents_scale,
     float device_scale_factor,
     float page_scale_factor,
-    float maximum_animation_contents_scale,
     bool animating_transform_to_screen) {
-  CalculateContentsScale(layer,
-                         ideal_contents_scale,
-                         device_scale_factor,
-                         page_scale_factor,
-                         maximum_animation_contents_scale,
-                         animating_transform_to_screen);
+  CalculateContentsScale(layer, ideal_contents_scale);
 }
 
 static inline void UpdateLayerContentsScale(
     Layer* layer,
     bool can_adjust_raster_scale,
     float ideal_contents_scale,
     float device_scale_factor,
     float page_scale_factor,
-    float maximum_animation_contents_scale,
     bool animating_transform_to_screen) {
   if (can_adjust_raster_scale) {
     float ideal_raster_scale =
         ideal_contents_scale / (device_scale_factor * page_scale_factor);
 
     bool need_to_set_raster_scale = layer->raster_scale_is_unknown();
 
     // If we've previously saved a raster_scale but the ideal changes, things
     // are unpredictable and we should just use 1.
     if (!need_to_set_raster_scale && layer->raster_scale() != 1.f &&
@@ skipping 12 matching lines @@
 
   float raster_scale = 1.f;
   if (!layer->raster_scale_is_unknown())
     raster_scale = layer->raster_scale();
 
   gfx::Size old_content_bounds = layer->content_bounds();
   float old_contents_scale_x = layer->contents_scale_x();
   float old_contents_scale_y = layer->contents_scale_y();
 
   float contents_scale = raster_scale * device_scale_factor * page_scale_factor;
-  CalculateContentsScale(layer,
-                         contents_scale,
-                         device_scale_factor,
-                         page_scale_factor,
-                         maximum_animation_contents_scale,
-                         animating_transform_to_screen);
+  CalculateContentsScale(layer, contents_scale);
 
   if (layer->content_bounds() != old_content_bounds ||
       layer->contents_scale_x() != old_contents_scale_x ||
       layer->contents_scale_y() != old_contents_scale_y)
     layer->SetNeedsPushProperties();
 }
 
 static inline void CalculateAnimationContentsScale(
     Layer* layer,
     bool ancestor_is_animating_scale,
@@ skipping 713 matching lines @@
                  combined_transform_scales.y())
       : layer_scale_factors;
   UpdateLayerContentsScale(
       layer,
       globals.can_adjust_raster_scales,
       ideal_contents_scale,
       globals.device_scale_factor,
       data_from_ancestor.in_subtree_of_page_scale_application_layer
           ? globals.page_scale_factor
           : 1.f,
-      combined_maximum_animation_contents_scale,
       animating_transform_to_screen);
 
   UpdateLayerScaleDrawProperties(
       layer,
       ideal_contents_scale,
       combined_maximum_animation_contents_scale,
       data_from_ancestor.in_subtree_of_page_scale_application_layer
           ? globals.page_scale_factor
           : 1.f,
       globals.device_scale_factor);
@@ skipping 690 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