[css-grid] Initial support for implicit grid before explicit grid

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 23 matching lines @@
 #include "core/style/GridResolvedPosition.h"
 #include "wtf/Allocator.h"
 #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 size_t kGridMaxTracks = 1000000;
+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.
 struct GridSpan {
     USING_FAST_MALLOC(GridSpan);
 public:
 
-    static GridSpan definiteGridSpan(size_t resolvedInitialPosition, size_t resolvedFinalPosition)
+    static GridSpan untranslatedDefiniteGridSpan(int resolvedInitialPosition, int resolvedFinalPosition)
     {
-        return GridSpan(resolvedInitialPosition, resolvedFinalPosition, Definite);
+        return GridSpan(resolvedInitialPosition, resolvedFinalPosition, UntranslatedDefinite);
+    }
+
+    static GridSpan translatedDefiniteGridSpan(size_t resolvedInitialPosition, size_t resolvedFinalPosition)
+    {
+        return GridSpan(resolvedInitialPosition, resolvedFinalPosition, TranslatedDefinite);
     }
 

[svillar, 2016/01/04 09:10:06]

I don't think we need these. Why don't we make the constructor public and just
use it directly?

[Manuel Rego, 2016/01/04 10:00:11]

The main reason to have these static methods
(which were added before this patch)
is the "indefinite" GridSpan case.

When we create an "indefinite" GridSpan
we don't care about the initial and final positions.
So, we've a static method that creates a GridSpan with:
    GridSpan(0, 1, Indefinite);

If we make the constructor public
(we could have default values for the positions)
but we could be creating "indefinite" spans using random positions,
those positions will be completely ignored. E.g.:
    GridSpan(2, 5, Indefinite);

For that reason I think it's better to keep the 3 static methods.

BTW, using the static methods is not a big difference:
    GridSpan::untranslatedDefiniteGridSpan(2, 5);
vs
    GridSpan(UntranslatedDefinite, 2, 5);

In any case I think we can change this in a follow-up patch
if it's really an issue.

     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());
+        ASSERT(isTranslatedDefinite());
         ASSERT(m_resolvedFinalPosition > m_resolvedInitialPosition);
         return m_resolvedFinalPosition - m_resolvedInitialPosition;
     }
 
+    int untranslatedResolvedInitialPosition() const
+    {
+        ASSERT(m_type == UntranslatedDefinite);
+        return m_resolvedInitialPosition;
+    }
+
+    int untranslatedResolvedFinalPosition() const
+    {
+        ASSERT(m_type == UntranslatedDefinite);
+        return m_resolvedFinalPosition;
+    }
+
     size_t resolvedInitialPosition() const
     {
-        ASSERT(isDefinite());
+        ASSERT(isTranslatedDefinite());
+        ASSERT(m_resolvedInitialPosition >= 0);
         return m_resolvedInitialPosition;
     }
 
     size_t resolvedFinalPosition() const
     {
-        ASSERT(isDefinite());
-        ASSERT(m_resolvedFinalPosition);
+        ASSERT(isTranslatedDefinite());
+        ASSERT(m_resolvedFinalPosition > 0);
         return m_resolvedFinalPosition;
     }
 
     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(isDefinite());
+        ASSERT(isTranslatedDefinite());
         return m_resolvedInitialPosition;
     }
 
     GridSpanIterator end() const
     {
-        ASSERT(isDefinite());
+        ASSERT(isTranslatedDefinite());
         return m_resolvedFinalPosition;
     }
 
-    bool isDefinite() const
+    bool isTranslatedDefinite() const
     {
-        return m_type == Definite;
+        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;
+
+        ASSERT(m_resolvedInitialPosition >= 0);
+        ASSERT(m_resolvedFinalPosition > 0);
     }
 
 private:
 
-    enum GridSpanType {Definite, Indefinite};
+    enum GridSpanType {UntranslatedDefinite, TranslatedDefinite, Indefinite};
 
-    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)
+    GridSpan(int resolvedInitialPosition, int resolvedFinalPosition, GridSpanType type)
+        : m_type(type)
     {
+#if ENABLE(ASSERT)
         ASSERT(resolvedInitialPosition < resolvedFinalPosition);
+        if (type == TranslatedDefinite) {
+            ASSERT(resolvedInitialPosition >= 0);
+            ASSERT(resolvedFinalPosition > 0);
+        }
+#endif
+
+        if (resolvedInitialPosition >= 0)
+            m_resolvedInitialPosition = std::min(resolvedInitialPosition, kGridMaxTracks - 1);
+        else
+            m_resolvedInitialPosition = std::max(resolvedInitialPosition, -kGridMaxTracks);
+
+        if (resolvedFinalPosition >= 0)
+            m_resolvedFinalPosition = std::min(resolvedFinalPosition, kGridMaxTracks);
+        else
+            m_resolvedFinalPosition = std::max(resolvedFinalPosition, -kGridMaxTracks + 1);
     }
 
-    size_t m_resolvedInitialPosition;
-    size_t m_resolvedFinalPosition;
+    int m_resolvedInitialPosition;
+    int 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