[css-grid] Get rid of GridResolvedPosition

third_party/WebKit/Source/core/style/GridCoordinate.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 32 matching lines @@
 // Recommended maximum size for both explicit and implicit grids.
 const size_t 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.
 struct GridSpan {
     USING_FAST_MALLOC(GridSpan);
 public:
 
-    static GridSpan definiteGridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition)
+    static GridSpan definiteGridSpan(size_t resolvedInitialPosition, size_t resolvedFinalPosition)
     {
         return GridSpan(resolvedInitialPosition, resolvedFinalPosition, Definite);
     }
 
     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;
     }
 
     size_t integerSpan() const
     {
         ASSERT(isDefinite());

[rune, 2015/12/03 14:08:38]

ASSERT(m_resolvedFinalPosition >= m_resolvedInitialPosition)

[Manuel Rego, 2015/12/04 07:28:06]

We're already checking something similar in the constructor:
resolvedInitialPosition < resolvedFinalPosition

But I'd add a new assert here, actually it should be:
ASSERT(m_resolvedFinalPosition > m_resolvedInitialPosition)

As "1" is the minimum value it should return.

-        return m_resolvedFinalPosition.toInt() - m_resolvedInitialPosition.toInt();
+        return m_resolvedFinalPosition - m_resolvedInitialPosition;
     }
 
-    const GridResolvedPosition& resolvedInitialPosition() const
+    size_t resolvedInitialPosition() const
     {
         ASSERT(isDefinite());
         return m_resolvedInitialPosition;
     }
 
-    const GridResolvedPosition& resolvedFinalPosition() const
+    size_t resolvedFinalPosition() const
     {
         ASSERT(isDefinite());

[rune, 2015/12/03 14:08:38]

ASSERT(m_resolvedFinalPosition)?

[Manuel Rego, 2015/12/04 07:28:06]

Acknowledged.

         return m_resolvedFinalPosition;
     }
 
-    typedef GridResolvedPosition iterator;
+    struct GridSpanIterator {

[cbiesinger, 2015/12/03 17:19:17]

How does this work as an iterator without an operator++...?

[Manuel Rego, 2015/12/04 07:30:21]

It's an iterator over a primitive type and it's overloading "&" operator.
The basic operations (++, !=) just work for size_t.

Other option could be remove the overloading of "&"
and overload "++" and "!=".

I can change that if you think it makes the code clearer.

[cbiesinger, 2015/12/04 21:06:29]

Yes, I think overloading ++ and != would be a lot clearer.

+        GridSpanIterator(size_t v) : value(v) {}
 
-    iterator begin() const
+        operator size_t&() { return value; }
+        size_t operator*() const { return value; }
+
+        size_t value;
+    };
+
+    GridSpanIterator begin() const
     {
         ASSERT(isDefinite());
         return m_resolvedInitialPosition;
     }
 
-    iterator end() const
+    GridSpanIterator end() const
     {
         ASSERT(isDefinite());
         return m_resolvedFinalPosition;
     }
 
     bool isDefinite() const
     {
         return m_type == Definite;
     }
 
 private:
 
     enum GridSpanType {Definite, Indefinite};
 
-    GridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition, GridSpanType type)
-        : m_resolvedInitialPosition(std::min(resolvedInitialPosition.toInt(), kGridMaxTracks - 1))
-        , m_resolvedFinalPosition(std::min(resolvedFinalPosition.toInt(), kGridMaxTracks))
+    GridSpan(size_t resolvedInitialPosition, size_t resolvedFinalPosition, GridSpanType type)
+        : m_resolvedInitialPosition(std::min(resolvedInitialPosition, kGridMaxTracks - 1))
+        , m_resolvedFinalPosition(std::min(resolvedFinalPosition, kGridMaxTracks))
         , m_type(type)
     {
         ASSERT(resolvedInitialPosition < resolvedFinalPosition);
     }
 
-    GridResolvedPosition m_resolvedInitialPosition;
-    GridResolvedPosition m_resolvedFinalPosition;
+    size_t m_resolvedInitialPosition;
+    size_t m_resolvedFinalPosition;
     GridSpanType m_type;
 };
 
 // This represents a grid area that spans in both rows' and columns' direction.
 struct GridCoordinate {
     USING_FAST_MALLOC(GridCoordinate);
 public:
     // HashMap requires a default constuctor.
     GridCoordinate()
         : columns(GridSpan::indefiniteGridSpan())
@@ skipping 19 matching lines @@
 
     GridSpan columns;
     GridSpan rows;
 };
 
 typedef HashMap<String, GridCoordinate> NamedGridAreaMap;
 
 } // namespace blink
 
 #endif // GridCoordinate_h