[css-grid] Rename GridSpan properties

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

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 25 matching lines @@
 #include "wtf/HashMap.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/text/WTFString.h"
 #include <algorithm>
 
 namespace blink {
 
 // Recommended maximum size for both explicit and implicit grids.
 const int kGridMaxTracks = 1000000;
 
-// A span in a single direction (either rows or columns). Note that |resolvedInitialPosition|
-// and |resolvedFinalPosition| are grid lines' indexes.
-// Iterating over the span shouldn't include |resolvedFinalPosition| to be correct.
+// A span in a single direction (either rows or columns). Note that |startLine|
+// and |endLine| are grid lines' indexes.
+// Despite line numbers in the spec start in "1", the indexes here start in "0".
 struct GridSpan {
     USING_FAST_MALLOC(GridSpan);
 public:
 
-    static GridSpan untranslatedDefiniteGridSpan(int resolvedInitialPosition, int resolvedFinalPosition)
+    static GridSpan untranslatedDefiniteGridSpan(int startLine, int endLine)
     {
-        return GridSpan(resolvedInitialPosition, resolvedFinalPosition, UntranslatedDefinite);
+        return GridSpan(startLine, endLine, UntranslatedDefinite);
     }
 
-    static GridSpan translatedDefiniteGridSpan(size_t resolvedInitialPosition, size_t resolvedFinalPosition)
+    static GridSpan translatedDefiniteGridSpan(size_t startLine, size_t endLine)
     {
-        return GridSpan(resolvedInitialPosition, resolvedFinalPosition, TranslatedDefinite);
+        return GridSpan(startLine, endLine, TranslatedDefinite);
     }
 
     static GridSpan indefiniteGridSpan()
     {
         return GridSpan(0, 1, Indefinite);
     }
 
     bool operator==(const GridSpan& o) const
     {
-        return m_type == o.m_type && m_resolvedInitialPosition == o.m_resolvedInitialPosition && m_resolvedFinalPosition == o.m_resolvedFinalPosition;
+        return m_type == o.m_type && m_startLine == o.m_startLine && m_endLine == o.m_endLine;
     }
 
     size_t integerSpan() const
     {
         ASSERT(isTranslatedDefinite());
-        ASSERT(m_resolvedFinalPosition > m_resolvedInitialPosition);
-        return m_resolvedFinalPosition - m_resolvedInitialPosition;
+        ASSERT(m_endLine > m_startLine);
+        return m_endLine - m_startLine;
     }
 
-    int untranslatedResolvedInitialPosition() const
+    int untranslatedStartLine() const
     {
         ASSERT(m_type == UntranslatedDefinite);
-        return m_resolvedInitialPosition;
+        return m_startLine;
     }
 
-    int untranslatedResolvedFinalPosition() const
+    int untranslatedEndLine() const
     {
         ASSERT(m_type == UntranslatedDefinite);
-        return m_resolvedFinalPosition;
+        return m_endLine;
     }
 
-    size_t resolvedInitialPosition() const
+    size_t startLine() const
     {
         ASSERT(isTranslatedDefinite());
-        ASSERT(m_resolvedInitialPosition >= 0);
-        return m_resolvedInitialPosition;
+        ASSERT(m_startLine >= 0);
+        return m_startLine;
     }
 
-    size_t resolvedFinalPosition() const
+    size_t endLine() const
     {
         ASSERT(isTranslatedDefinite());
-        ASSERT(m_resolvedFinalPosition > 0);
-        return m_resolvedFinalPosition;
+        ASSERT(m_endLine > 0);
+        return m_endLine;
     }
 
     struct GridSpanIterator {
         GridSpanIterator(size_t v) : value(v) {}
 
         size_t operator*() const { return value; }
         size_t operator++() { return value++; }
         bool operator!=(GridSpanIterator other) const { return value != other.value; }
 
         size_t value;
     };
 
     GridSpanIterator begin() const
     {
         ASSERT(isTranslatedDefinite());
-        return m_resolvedInitialPosition;
+        return m_startLine;
     }
 
     GridSpanIterator end() const
     {
         ASSERT(isTranslatedDefinite());
-        return m_resolvedFinalPosition;
+        return m_endLine;
     }
 
     bool isTranslatedDefinite() const
     {
         return m_type == TranslatedDefinite;
     }
 
     bool isIndefinite() const
     {
         return m_type == Indefinite;
     }
 
     void translate(size_t offset)
     {
         ASSERT(m_type == UntranslatedDefinite);
 
         m_type = TranslatedDefinite;
-        m_resolvedInitialPosition += offset;
-        m_resolvedFinalPosition += offset;
+        m_startLine += offset;
+        m_endLine += offset;
 
-        ASSERT(m_resolvedInitialPosition >= 0);
-        ASSERT(m_resolvedFinalPosition > 0);
+        ASSERT(m_startLine >= 0);
+        ASSERT(m_endLine > 0);
     }
 
 private:
 
     enum GridSpanType {UntranslatedDefinite, TranslatedDefinite, Indefinite};
 
-    GridSpan(int resolvedInitialPosition, int resolvedFinalPosition, GridSpanType type)
+    GridSpan(int startLine, int endLine, GridSpanType type)
         : m_type(type)
     {
 #if ENABLE(ASSERT)
-        ASSERT(resolvedInitialPosition < resolvedFinalPosition);
+        ASSERT(startLine < endLine);
         if (type == TranslatedDefinite) {
-            ASSERT(resolvedInitialPosition >= 0);
-            ASSERT(resolvedFinalPosition > 0);
+            ASSERT(startLine >= 0);
+            ASSERT(endLine > 0);
         }
 #endif
 
-        if (resolvedInitialPosition >= 0)
-            m_resolvedInitialPosition = std::min(resolvedInitialPosition, kGridMaxTracks - 1);
+        if (startLine >= 0)
+            m_startLine = std::min(startLine, kGridMaxTracks - 1);
         else
-            m_resolvedInitialPosition = std::max(resolvedInitialPosition, -kGridMaxTracks);
+            m_startLine = std::max(startLine, -kGridMaxTracks);
 
-        if (resolvedFinalPosition >= 0)
-            m_resolvedFinalPosition = std::min(resolvedFinalPosition, kGridMaxTracks);
+        if (endLine >= 0)
+            m_endLine = std::min(endLine, kGridMaxTracks);
         else
-            m_resolvedFinalPosition = std::max(resolvedFinalPosition, -kGridMaxTracks + 1);
+            m_endLine = std::max(endLine, -kGridMaxTracks + 1);
     }
 
-    int m_resolvedInitialPosition;
-    int m_resolvedFinalPosition;
+    int m_startLine;
+    int m_endLine;
     GridSpanType m_type;
 };
 
 // This represents a grid area that spans in both rows' and columns' direction.
 struct GridArea {
     USING_FAST_MALLOC(GridArea);
 public:
     // HashMap requires a default constuctor.
     GridArea()
         : columns(GridSpan::indefiniteGridSpan())
@@ skipping 19 matching lines @@
 
     GridSpan columns;
     GridSpan rows;
 };
 
 typedef HashMap<String, GridArea> NamedGridAreaMap;
 
 } // namespace blink
 
 #endif // GridArea_h