Support subpixel layout for borders.

third_party/WebKit/Source/core/style/BorderValue.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 14 matching lines @@
 #ifndef BorderValue_h
 #define BorderValue_h
 
 #include "core/css/StyleColor.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "platform/graphics/Color.h"
 #include "wtf/Allocator.h"
 
 namespace blink {
 
+// In order to conserve memory, the border width uses fixed point,
+// which can be bitpacked.  This fixed point implementation is
+// essentially the same as in LayoutUnit.  Six bits are used for the
+// fraction, which leaves 20 bits for the integer part, making 1048575
+// the largest number.
+
+static const int kBorderWidthFractionalBits = 6;
+static const int kBorderWidthDenominator = 1 << kBorderWidthFractionalBits;
+static const int kMaxForBorderWidth = ((1 << 26) - 1) / kBorderWidthDenominator;
+
 class BorderValue {
   DISALLOW_NEW();
   friend class ComputedStyle;
 
  public:
   BorderValue()
       : m_color(0),
         m_colorIsCurrentColor(true),
-        m_width(3),
         m_style(BorderStyleNone),
-        m_isAuto(OutlineIsAutoOff) {}
+        m_isAuto(OutlineIsAutoOff) {
+    setWidth(3);
+  }
 
   bool nonZero() const { return width() && (m_style != BorderStyleNone); }
 
   bool isTransparent() const {
     return !m_colorIsCurrentColor && !m_color.alpha();
   }
 
   bool operator==(const BorderValue& o) const {
     return m_width == o.m_width && m_style == o.m_style &&
            m_color == o.m_color &&
@@ skipping 15 matching lines @@
   void setColor(const StyleColor& color) {
     m_color = color.resolve(Color());
     m_colorIsCurrentColor = color.isCurrentColor();
   }
 
   StyleColor color() const {
     return m_colorIsCurrentColor ? StyleColor::currentColor()
                                  : StyleColor(m_color);
   }
 
-  int width() const { return m_width; }
+  float width() const {
+    return static_cast<float>(m_width) / kBorderWidthDenominator;
+  }
+  void setWidth(float width) { m_width = widthToFixedPoint(width); }
+
+  // Since precision is lost with fixed point, comparisons also have
+  // to be done in fixed point.
+  bool widthEquals(float width) const {
+    return widthToFixedPoint(width) == m_width;
+  }
 
   EBorderStyle style() const { return static_cast<EBorderStyle>(m_style); }
   void setStyle(EBorderStyle style) { m_style = style; }
 
  protected:
+  static unsigned widthToFixedPoint(float width) {
+    DCHECK_GE(width, 0);
+    return static_cast<unsigned>(std::min<float>(width, kMaxForBorderWidth) *
+                                 kBorderWidthDenominator);
+  }
+
   Color m_color;
   unsigned m_colorIsCurrentColor : 1;
 
-  unsigned m_width : 26;
+  unsigned m_width : 26;  // Fixed point width
   unsigned m_style : 4;  // EBorderStyle
 
   // This is only used by OutlineValue but moved here to keep the bits packed.
   unsigned m_isAuto : 1;  // OutlineIsAuto
 };
 
 }  // namespace blink
 
 #endif  // BorderValue_h