Layout support for new circle shape syntax

Source/core/rendering/style/BasicShapes.h

 /*
  * Copyright (C) 2012 Adobe Systems Incorporated. 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.
@@ skipping 22 matching lines @@
 #include "core/rendering/style/RenderStyleConstants.h"
 #include "platform/Length.h"
 #include "platform/graphics/WindRule.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 class FloatRect;
+class FloatSize;
 class Path;
 
 class BasicShape : public RefCounted<BasicShape> {
 public:
     virtual ~BasicShape() { }
 
     enum Type {
         BasicShapeRectangleType,
         DeprecatedBasicShapeCircleType,
         DeprecatedBasicShapeEllipseType,
@@ skipping 82 matching lines @@
     };
     BasicShapeCenterCoordinate() : m_keyword(None), m_length(Undefined) { }
     explicit BasicShapeCenterCoordinate(Length length) : m_keyword(None), m_length(length) { }
     BasicShapeCenterCoordinate(Keyword keyword, Length length) : m_keyword(keyword), m_length(length) { }
     BasicShapeCenterCoordinate(const BasicShapeCenterCoordinate& other) : m_keyword(other.keyword()), m_length(other.length()) { }
     bool operator==(const BasicShapeCenterCoordinate& other) const { return m_keyword == other.m_keyword && m_length == other.m_length; }
 
     Keyword keyword() const { return m_keyword; }
     const Length& length() const { return m_length; }
 
+    bool canBlend(const BasicShapeCenterCoordinate& other) const
+    {
+        // FIXME determine how to interpolate between keywords. See issue 330248.
+        return m_keyword == None && other.keyword() == None;
+    }
+
     BasicShapeCenterCoordinate blend(const BasicShapeCenterCoordinate& other, double progress) const
     {
         if (m_keyword != None || other.keyword() != None)
             return BasicShapeCenterCoordinate(other);
 
         return BasicShapeCenterCoordinate(m_length.blend(other.length(), progress, ValueRangeAll));
     }
 
 private:
     Keyword m_keyword;
     Length m_length;
 };
 
 class BasicShapeRadius {
 public:
     enum Type {
         Value,
         ClosestSide,
         FarthestSide
     };
     BasicShapeRadius() : m_value(Undefined), m_type(ClosestSide) { }
     explicit BasicShapeRadius(Length v) : m_value(v), m_type(Value) { }
     explicit BasicShapeRadius(Type t) : m_value(Undefined), m_type(t) { }
     BasicShapeRadius(const BasicShapeRadius& other) : m_value(other.value()), m_type(other.type()) { }
     bool operator==(const BasicShapeRadius& other) const { return m_type == other.m_type && m_value == other.m_value; }
 
     const Length& value() const { return m_value; }
     Type type() const { return m_type; }
 
+    bool canBlend(const BasicShapeRadius& other) const
+    {
+        // FIXME determine how to interpolate between keywords. See issue 330248.
+        return m_type == Value && other.type() == Value;
+    }
+
     BasicShapeRadius blend(const BasicShapeRadius& other, double progress) const
     {
         if (m_type != Value || other.type() != Value)
             return BasicShapeRadius(other);
 
         return BasicShapeRadius(m_value.blend(other.value(), progress, ValueRangeAll));
     }
 
 private:
     Length m_value;
     Type m_type;
 
 };
 
 class BasicShapeCircle : public BasicShape {
 public:
     static PassRefPtr<BasicShapeCircle> create() { return adoptRef(new BasicShapeCircle); }
 
     const BasicShapeCenterCoordinate& centerX() const { return m_centerX; }
     const BasicShapeCenterCoordinate& centerY() const { return m_centerY; }
     const BasicShapeRadius& radius() const { return m_radius; }
 
+    float floatValueForRadiusInBox(FloatSize) const;
     void setCenterX(BasicShapeCenterCoordinate centerX) { m_centerX = centerX; }
     void setCenterY(BasicShapeCenterCoordinate centerY) { m_centerY = centerY; }
     void setRadius(BasicShapeRadius radius) { m_radius = radius; }
 
     virtual void path(Path&, const FloatRect&) OVERRIDE;
     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;
     virtual bool operator==(const BasicShape&) const OVERRIDE;
 
     virtual Type type() const { return BasicShapeCircleType; }
 private:
@@ skipping 159 matching lines @@
     Length m_bottom;
     Length m_left;
     Length m_cornerRadiusX;
     Length m_cornerRadiusY;
 };
 
 DEFINE_BASICSHAPE_TYPE_CASTS(BasicShapeInsetRectangle);
 
 }
 #endif