Use LayoutUnit for all border-*-width logic

third_party/WebKit/Source/core/style/ComputedStyle.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, 2009, 2010, 2011 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
@@ skipping 494 matching lines @@
   void SetStyleType(PseudoId style_type) { SetStyleTypeInternal(style_type); }
 
   ComputedStyle* GetCachedPseudoStyle(PseudoId) const;
   ComputedStyle* AddCachedPseudoStyle(RefPtr<ComputedStyle>);
   void RemoveCachedPseudoStyle(PseudoId);
 
   const PseudoStyleCache* CachedPseudoStyles() const {
     return cached_pseudo_styles_.get();
   }
 
-  bool BorderWidthEquals(float border_width_first,
-                         float border_width_second) const {
-    return WidthToFixedPoint(border_width_first) ==
-           WidthToFixedPoint(border_width_second);
-  }
-
   /**
      * ComputedStyle properties
      *
      * Each property stored in ComputedStyle is made up of fields. Fields have
      * initial value functions, getters and setters. A field is preferably a
      * basic data type or enum, but can be any type. A set of fields should be
      * preceded by the property the field is stored for.
      *
      * Field method naming should be done like so:
      *   // name-of-property
@@ skipping 179 matching lines @@
 
   // Border width properties.
   static float InitialBorderWidth() { return 3; }
 
   // TODO(nainar): Move all fixed point logic to a separate class.
   // border-top-width
   float BorderTopWidth() const {
     if (BorderTopStyle() == EBorderStyle::kNone ||
         BorderTopStyle() == EBorderStyle::kHidden)
       return 0;
-    return static_cast<float>(BorderTopWidthInternal()) /
-           kBorderWidthDenominator;
+    return BorderTopWidthInternal().ToFloat();
   }
-  void SetBorderTopWidth(float v) {
-    SetBorderTopWidthInternal(WidthToFixedPoint(v));
-  }
+  void SetBorderTopWidth(float v) { SetBorderTopWidthInternal(LayoutUnit(v)); }
   bool BorderTopNonZero() const {
     return BorderTopWidth() && (BorderTopStyle() != EBorderStyle::kNone);
   }
 
   // border-bottom-width
   float BorderBottomWidth() const {
     if (BorderBottomStyle() == EBorderStyle::kNone ||
         BorderBottomStyle() == EBorderStyle::kHidden)
       return 0;
-    return static_cast<float>(BorderBottomWidthInternal()) /
-           kBorderWidthDenominator;
+    return BorderBottomWidthInternal().ToFloat();
   }
   void SetBorderBottomWidth(float v) {
-    SetBorderBottomWidthInternal(WidthToFixedPoint(v));
+    SetBorderBottomWidthInternal(LayoutUnit(v));
   }
   bool BorderBottomNonZero() const {
     return BorderBottomWidth() && (BorderBottomStyle() != EBorderStyle::kNone);
   }
 
   // border-left-width
   float BorderLeftWidth() const {
     if (BorderLeftStyle() == EBorderStyle::kNone ||
         BorderLeftStyle() == EBorderStyle::kHidden)
       return 0;
-    return static_cast<float>(BorderLeftWidthInternal()) /
-           kBorderWidthDenominator;
+    return BorderLeftWidthInternal().ToFloat();
   }
   void SetBorderLeftWidth(float v) {
-    SetBorderLeftWidthInternal(WidthToFixedPoint(v));
+    SetBorderLeftWidthInternal(LayoutUnit(v));
   }
   bool BorderLeftNonZero() const {
     return BorderLeftWidth() && (BorderLeftStyle() != EBorderStyle::kNone);
   }
 
   // border-right-width
   float BorderRightWidth() const {
     if (BorderRightStyle() == EBorderStyle::kNone ||
         BorderRightStyle() == EBorderStyle::kHidden)
       return 0;
-    return static_cast<float>(BorderRightWidthInternal()) /
-           kBorderWidthDenominator;
+    return BorderRightWidthInternal().ToFloat();
   }
   void SetBorderRightWidth(float v) {
-    SetBorderRightWidthInternal(WidthToFixedPoint(v));
+    SetBorderRightWidthInternal(LayoutUnit(v));
   }
   bool BorderRightNonZero() const {
     return BorderRightWidth() && (BorderRightStyle() != EBorderStyle::kNone);
   }
 
   static EBorderStyle InitialColumnRuleStyle() { return EBorderStyle::kNone; }
 
   // Border color properties.
   // border-left-color
   void SetBorderLeftColor(const StyleColor& color) {
@@ skipping 2251 matching lines @@
   bool HasBorderImageOutsets() const {
     return BorderImage().HasImage() && BorderImage().Outset().NonZero();
   }
   LayoutRectOutsets BorderImageOutsets() const {
     return ImageOutsets(BorderImage());
   }
   bool BorderImageSlicesFill() const { return BorderImage().Fill(); }
 
   void SetBorderImageSlicesFill(bool);
   const BorderValue BorderLeft() const {
-    return BorderValue(
-        BorderLeftStyle(), BorderLeftColor(),
-        static_cast<float>(BorderLeftWidthInternal()) / kBorderWidthDenominator,
-        OutlineStyleIsAuto());
+    return BorderValue(BorderLeftStyle(), BorderLeftColor(),
+                       BorderLeftWidthInternal().ToFloat(),
+                       OutlineStyleIsAuto());
   }
   const BorderValue BorderRight() const {
     return BorderValue(BorderRightStyle(), BorderRightColor(),
-                       static_cast<float>(BorderRightWidthInternal()) /
-                           kBorderWidthDenominator,
+                       BorderRightWidthInternal().ToFloat(),
                        OutlineStyleIsAuto());
   }
   const BorderValue BorderTop() const {
-    return BorderValue(
-        BorderTopStyle(), BorderTopColor(),
-        static_cast<float>(BorderTopWidthInternal()) / kBorderWidthDenominator,
-        OutlineStyleIsAuto());
+    return BorderValue(BorderTopStyle(), BorderTopColor(),
+                       BorderTopWidthInternal().ToFloat(),
+                       OutlineStyleIsAuto());
   }
   const BorderValue BorderBottom() const {
     return BorderValue(BorderBottomStyle(), BorderBottomColor(),
-                       static_cast<float>(BorderBottomWidthInternal()) /
-                           kBorderWidthDenominator,
+                       BorderBottomWidthInternal().ToFloat(),
                        OutlineStyleIsAuto());
   }
 
   bool BorderSizeEquals(const ComputedStyle& o) const {
-    return BorderWidthEquals(BorderLeftWidth(), o.BorderLeftWidth()) &&
-           BorderWidthEquals(BorderTopWidth(), o.BorderTopWidth()) &&
-           BorderWidthEquals(BorderRightWidth(), o.BorderRightWidth()) &&
-           BorderWidthEquals(BorderBottomWidth(), o.BorderBottomWidth());
+    return BorderLeftWidthInternal() == o.BorderLeftWidthInternal() &&
+           BorderTopWidthInternal() == o.BorderTopWidthInternal() &&
+           BorderRightWidthInternal() == o.BorderRightWidthInternal() &&
+           BorderBottomWidthInternal() == o.BorderBottomWidthInternal();
   }
 
   BorderValue BorderBefore() const;
   BorderValue BorderAfter() const;
   BorderValue BorderStart() const;
   BorderValue BorderEnd() const;
   float BorderAfterWidth() const;
   float BorderBeforeWidth() const;
   float BorderEndWidth() const;
   float BorderStartWidth() const;
@@ skipping 957 matching lines @@
       PseudoBitsInternal() | 1 << (pseudo - kFirstPublicPseudoId)));
 }
 
 inline bool ComputedStyle::HasPseudoElementStyle() const {
   return PseudoBitsInternal() & kElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h