cc: Remove can_use_lcd_text from draw properties

cc/trees/draw_property_utils.cc

 // Copyright 2014 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/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 989 matching lines @@
   // (included) and its target surface (excluded).
   const EffectNode* node = tree.Node(render_surface->EffectTreeIndex());
   float draw_opacity = tree.EffectiveOpacity(node);
   for (node = tree.parent(node); node && !node->data.has_render_surface;
        node = tree.parent(node)) {
     draw_opacity *= tree.EffectiveOpacity(node);
   }
   render_surface->SetDrawOpacity(draw_opacity);
 }
 
-static bool LayerCanUseLcdText(const LayerImpl* layer,
-                               bool layers_always_allowed_lcd_text,
-                               bool can_use_lcd_text,
-                               const TransformNode* transform_node,
-                               const EffectNode* effect_node) {
-  if (layers_always_allowed_lcd_text)
-    return true;
-  if (!can_use_lcd_text)
-    return false;
-  if (!layer->contents_opaque())
-    return false;
-
-  if (effect_node->data.screen_space_opacity != 1.f)
-    return false;
-  if (!transform_node->data.node_and_ancestors_have_only_integer_translation)
-    return false;
-  if (static_cast<int>(layer->offset_to_transform_parent().x()) !=
-      layer->offset_to_transform_parent().x())
-    return false;
-  if (static_cast<int>(layer->offset_to_transform_parent().y()) !=
-      layer->offset_to_transform_parent().y())
-    return false;
-  return true;
-}
-
 static gfx::Rect LayerDrawableContentRect(
     const LayerImpl* layer,
     const gfx::Rect& layer_bounds_in_target_space,
     const gfx::Rect& clip_rect) {
   if (layer->is_clipped())
     return IntersectRects(layer_bounds_in_target_space, clip_rect);
 
   return layer_bounds_in_target_space;
 }
 
@@ skipping 18 matching lines @@
   if (surface_transform_node->data.sublayer_scale.x() != 0 &&
       surface_transform_node->data.sublayer_scale.y() != 0) {
     replica_to_surface.Scale(
         1.0 / surface_transform_node->data.sublayer_scale.x(),
         1.0 / surface_transform_node->data.sublayer_scale.y());
   }
   return replica_to_surface;
 }
 
 void ComputeLayerDrawProperties(LayerImpl* layer,
-                                const PropertyTrees* property_trees,
-                                bool layers_always_allowed_lcd_text,
-                                bool can_use_lcd_text) {
+                                const PropertyTrees* property_trees) {
   const TransformNode* transform_node =
       property_trees->transform_tree.Node(layer->transform_tree_index());
-  const EffectNode* effect_node =
-      property_trees->effect_tree.Node(layer->effect_tree_index());
   const ClipNode* clip_node =
       property_trees->clip_tree.Node(layer->clip_tree_index());
 
   layer->draw_properties().screen_space_transform =
       ScreenSpaceTransformInternal(layer, transform_node);
   if (property_trees->non_root_surfaces_enabled) {
     layer->draw_properties().target_space_transform =
         DrawTransform(layer, property_trees->transform_tree);
   } else {
     layer->draw_properties().target_space_transform =
         layer->draw_properties().screen_space_transform;
   }
   layer->draw_properties().screen_space_transform_is_animating =
       transform_node->data.to_screen_is_potentially_animated;
   if (layer->layer_tree_impl()
           ->settings()
           .layer_transforms_should_scale_layer_contents) {
     layer->draw_properties().maximum_animation_contents_scale =
         transform_node->data.combined_maximum_animation_target_scale;
     layer->draw_properties().starting_animation_contents_scale =
         transform_node->data.combined_starting_animation_scale;
   } else {
     layer->draw_properties().maximum_animation_contents_scale = 0.f;
     layer->draw_properties().starting_animation_contents_scale = 0.f;
   }
 
   layer->draw_properties().opacity =
       LayerDrawOpacity(layer, property_trees->effect_tree);
-  layer->draw_properties().can_use_lcd_text =
-      LayerCanUseLcdText(layer, layers_always_allowed_lcd_text,
-                         can_use_lcd_text, transform_node, effect_node);
   if (property_trees->non_root_surfaces_enabled) {
     layer->draw_properties().is_clipped = clip_node->data.layers_are_clipped;
   } else {
     layer->draw_properties().is_clipped =
         clip_node->data.layers_are_clipped_when_surfaces_disabled;
   }
 
   gfx::Rect bounds_in_target_space = MathUtil::MapEnclosingClippedRect(
       layer->draw_properties().target_space_transform,
       gfx::Rect(layer->bounds()));
@@ skipping 125 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc