Cleanup CSSGradientValue

third_party/WebKit/Source/core/css/CSSGradientValue.cpp

 /*
  * Copyright (C) 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 753 matching lines @@
            sign * primitive_value->GetFloatValue() / 100.f * edge_distance;
 
   if (primitive_value->IsCalculatedPercentageWithLength())
     return origin + sign * primitive_value->CssCalcValue()
                                ->ToCalcValue(conversion_data)
                                ->Evaluate(edge_distance);
 
   return origin + sign * primitive_value->ComputeLength<float>(conversion_data);
 }
 
-FloatPoint CSSGradientValue::ComputeEndPoint(
-    CSSValue* horizontal,
-    CSSValue* vertical,
+// Resolve points/radii to front end values.
+static FloatPoint ComputeEndPoint(
+    const CSSValue* horizontal,
+    const CSSValue* vertical,
     const CSSToLengthConversionData& conversion_data,
     const IntSize& size) {
   FloatPoint result;
 
   if (horizontal)
     result.SetX(PositionFromValue(horizontal, conversion_data, size, true));
 
   if (vertical)
     result.SetY(PositionFromValue(vertical, conversion_data, size, false));
 
@@ skipping 10 matching lines @@
 
 void CSSGradientValue::GetStopColors(Vector<Color>& stop_colors,
                                      const LayoutObject& object) const {
   for (auto& stop : stops_) {
     if (!stop.IsHint())
       stop_colors.push_back(ResolveStopColor(*stop.color_, object));
   }
 }
 
 DEFINE_TRACE_AFTER_DISPATCH(CSSGradientValue) {
-  visitor->Trace(first_x_);
-  visitor->Trace(first_y_);
-  visitor->Trace(second_x_);
-  visitor->Trace(second_y_);
   visitor->Trace(stops_);
   CSSImageGeneratorValue::TraceAfterDispatch(visitor);
 }
 
 String CSSLinearGradientValue::CustomCSSText() const {
   StringBuilder result;
   if (gradient_type_ == kCSSDeprecatedLinearGradient) {
     result.Append("-webkit-gradient(linear, ");
     result.Append(first_x_->CssText());
     result.Append(' ');
@@ skipping 240 matching lines @@
   } else if (first_y_) {
     equal_xand_y = DataEquivalent(first_y_, other.first_y_) && !other.first_x_;
   } else {
     equal_xand_y = !other.first_x_ && !other.first_y_;
   }
 
   return equal_xand_y && stops_ == other.stops_;
 }
 
 DEFINE_TRACE_AFTER_DISPATCH(CSSLinearGradientValue) {
+  visitor->Trace(first_x_);
+  visitor->Trace(first_y_);
+  visitor->Trace(second_x_);
+  visitor->Trace(second_y_);
   visitor->Trace(angle_);
   CSSGradientValue::TraceAfterDispatch(visitor);
 }
 
 void CSSGradientValue::AppendCSSTextForColorStops(
     StringBuilder& result,
     bool requires_separator) const {
   const CSSValue* prev_color = nullptr;
 
   for (const auto& stop : stops_) {
@@ skipping 138 matching lines @@
     wrote_something |=
         AppendPosition(result, first_x_, first_y_, wrote_something);
 
     AppendCSSTextForColorStops(result, wrote_something);
   }
 
   result.Append(')');
   return result.ToString();
 }
 
-float CSSRadialGradientValue::ResolveRadius(
-    CSSPrimitiveValue* radius,
-    const CSSToLengthConversionData& conversion_data,
-    float* width_or_height) {
+namespace {
+
+// Resolve points/radii to front end values.
+float ResolveRadius(const CSSPrimitiveValue* radius,
+                    const CSSToLengthConversionData& conversion_data,
+                    float* width_or_height = nullptr) {
   float result = 0;
   if (radius->IsNumber())
     result = radius->GetFloatValue() * conversion_data.Zoom();
   else if (width_or_height && radius->IsPercentage())
     result = *width_or_height * radius->GetFloatValue() / 100;
   else
     result = radius->ComputeLength<float>(conversion_data);
 
   return clampTo<float>(std::max(result, 0.0f));
 }
 
-namespace {
-
 enum EndShapeType { kCircleEndShape, kEllipseEndShape };
 
 // Compute the radius to the closest/farthest side (depending on the compare
 // functor).
 FloatSize RadiusToSide(const FloatPoint& point,
                        const FloatSize& size,
                        EndShapeType shape,
                        bool (*compare)(float, float)) {
   float dx1 = clampTo<float>(fabs(point.X()));
   float dy1 = clampTo<float>(fabs(point.Y()));
@@ skipping 195 matching lines @@
     equal_shape = !other.shape_;
     equal_sizing_behavior = !other.sizing_behavior_;
     equal_horizontal_and_vertical_size =
         !other.end_horizontal_size_ && !other.end_vertical_size_;
   }
   return equal_shape && equal_sizing_behavior &&
          equal_horizontal_and_vertical_size && stops_ == other.stops_;
 }
 
 DEFINE_TRACE_AFTER_DISPATCH(CSSRadialGradientValue) {
+  visitor->Trace(first_x_);
+  visitor->Trace(first_y_);
+  visitor->Trace(second_x_);
+  visitor->Trace(second_y_);
   visitor->Trace(first_radius_);
   visitor->Trace(second_radius_);
   visitor->Trace(shape_);
   visitor->Trace(sizing_behavior_);
   visitor->Trace(end_horizontal_size_);
   visitor->Trace(end_vertical_size_);
   CSSGradientValue::TraceAfterDispatch(visitor);
 }
 
 String CSSConicGradientValue::CustomCSSText() const {
   StringBuilder result;
 
   if (repeating_)
     result.Append("repeating-");
   result.Append("conic-gradient(");
 
   bool wrote_something = false;
 
   if (from_angle_) {
     result.Append("from ");
     result.Append(from_angle_->CssText());
     wrote_something = true;
   }
 
-  wrote_something |=
-      AppendPosition(result, first_x_, first_y_, wrote_something);
+  wrote_something |= AppendPosition(result, x_, y_, wrote_something);
 
   AppendCSSTextForColorStops(result, wrote_something);
 
   result.Append(')');
   return result.ToString();
 }
 
 PassRefPtr<Gradient> CSSConicGradientValue::CreateGradient(
     const CSSToLengthConversionData& conversion_data,
     const IntSize& size,
     const LayoutObject& object) {
   DCHECK(!size.IsEmpty());
 
   const float angle = from_angle_ ? from_angle_->ComputeDegrees() : 0;
 
   const FloatPoint position(
-      first_x_ ? PositionFromValue(first_x_, conversion_data, size, true)
-               : size.Width() / 2,
-      first_y_ ? PositionFromValue(first_y_, conversion_data, size, false)
-               : size.Height() / 2);
+      x_ ? PositionFromValue(x_, conversion_data, size, true)
+         : size.Width() / 2,
+      y_ ? PositionFromValue(y_, conversion_data, size, false)
+         : size.Height() / 2);
 
   GradientDesc desc(position, position,
                     repeating_ ? kSpreadMethodRepeat : kSpreadMethodPad);
   AddStops(desc, conversion_data, object);
 
   RefPtr<Gradient> gradient = Gradient::CreateConic(
       position, angle, Gradient::ColorInterpolation::kPremultiplied);
   gradient->AddColorStops(desc.stops);
 
   return gradient.Release();
 }
 
 bool CSSConicGradientValue::Equals(const CSSConicGradientValue& other) const {
-  return repeating_ == other.repeating_ &&
-         DataEquivalent(first_x_, other.first_x_) &&
-         DataEquivalent(first_y_, other.first_y_) &&
+  return repeating_ == other.repeating_ && DataEquivalent(x_, other.x_) &&
+         DataEquivalent(y_, other.y_) &&
          DataEquivalent(from_angle_, other.from_angle_) &&
          stops_ == other.stops_;
 }
 
 DEFINE_TRACE_AFTER_DISPATCH(CSSConicGradientValue) {
+  visitor->Trace(x_);
+  visitor->Trace(y_);
   visitor->Trace(from_angle_);
   CSSGradientValue::TraceAfterDispatch(visitor);
 }
 
 }  // namespace blink