diff --git a/third_party/WebKit/Source/core/core.gypi b/third_party/WebKit/Source/core/core.gypi
index 7bf477a..41d6642 100644
--- a/third_party/WebKit/Source/core/core.gypi
+++ b/third_party/WebKit/Source/core/core.gypi
@@ -771,7 +771,7 @@
             'style/ContentData.cpp',
             'style/CounterDirectives.cpp',
             'style/FillLayer.cpp',
-            'style/GridCoordinate.h',
+            'style/GridArea.h',
             'style/GridPositionsResolver.cpp',
             'style/GridPositionsResolver.h',
             'style/ComputedStyle.cpp',
diff --git a/third_party/WebKit/Source/core/css/CSSGridTemplateAreasValue.cpp b/third_party/WebKit/Source/core/css/CSSGridTemplateAreasValue.cpp
index 6f65191..e928c15 100644
--- a/third_party/WebKit/Source/core/css/CSSGridTemplateAreasValue.cpp
+++ b/third_party/WebKit/Source/core/css/CSSGridTemplateAreasValue.cpp
@@ -49,14 +49,14 @@
     Vector<String> candidates;
 
     for (const auto& item : gridAreaMap) {
-        const GridCoordinate& coordinate = item.value;
-        if (row >= coordinate.rows.resolvedInitialPosition() && row < coordinate.rows.resolvedFinalPosition())
+        const GridArea& area = item.value;
+        if (row >= area.rows.resolvedInitialPosition() && row < area.rows.resolvedFinalPosition())
             candidates.append(item.key);
     }
 
     for (const auto& item : gridAreaMap) {
-        const GridCoordinate& coordinate = item.value;
-        if (column >= coordinate.columns.resolvedInitialPosition() && column < coordinate.columns.resolvedFinalPosition() && candidates.contains(item.key))
+        const GridArea& area = item.value;
+        if (column >= area.columns.resolvedInitialPosition() && column < area.columns.resolvedFinalPosition() && candidates.contains(item.key))
             return item.key;
     }
 
diff --git a/third_party/WebKit/Source/core/css/CSSGridTemplateAreasValue.h b/third_party/WebKit/Source/core/css/CSSGridTemplateAreasValue.h
index 8b801b6..abddc47 100644
--- a/third_party/WebKit/Source/core/css/CSSGridTemplateAreasValue.h
+++ b/third_party/WebKit/Source/core/css/CSSGridTemplateAreasValue.h
@@ -32,7 +32,7 @@
 #define CSSGridTemplateAreasValue_h
 
 #include "core/css/CSSValue.h"
-#include "core/style/GridCoordinate.h"
+#include "core/style/GridArea.h"
 #include "wtf/text/StringHash.h"
 
 namespace blink {
diff --git a/third_party/WebKit/Source/core/css/parser/LegacyCSSPropertyParser.cpp b/third_party/WebKit/Source/core/css/parser/LegacyCSSPropertyParser.cpp
index 2e69dc9..ef2812c 100644
--- a/third_party/WebKit/Source/core/css/parser/LegacyCSSPropertyParser.cpp
+++ b/third_party/WebKit/Source/core/css/parser/LegacyCSSPropertyParser.cpp
@@ -48,7 +48,7 @@
 #include "core/css/parser/CSSParserFastPaths.h"
 #include "core/css/parser/CSSParserValues.h"
 #include "core/frame/UseCounter.h"
-#include "core/style/GridCoordinate.h"
+#include "core/style/GridArea.h"
 #include "platform/RuntimeEnabledFeatures.h"
 
 namespace blink {
@@ -2071,24 +2071,24 @@
 
         NamedGridAreaMap::iterator gridAreaIt = gridAreaMap.find(gridAreaName);
         if (gridAreaIt == gridAreaMap.end()) {
-            gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan::translatedDefiniteGridSpan(rowCount, rowCount + 1), GridSpan::translatedDefiniteGridSpan(currentCol, lookAheadCol)));
+            gridAreaMap.add(gridAreaName, GridArea(GridSpan::translatedDefiniteGridSpan(rowCount, rowCount + 1), GridSpan::translatedDefiniteGridSpan(currentCol, lookAheadCol)));
         } else {
-            GridCoordinate& gridCoordinate = gridAreaIt->value;
+            GridArea& gridArea = gridAreaIt->value;
 
             // The following checks test that the grid area is a single filled-in rectangle.
             // 1. The new row is adjacent to the previously parsed row.
-            if (rowCount != gridCoordinate.rows.resolvedFinalPosition())
+            if (rowCount != gridArea.rows.resolvedFinalPosition())
                 return false;
 
             // 2. The new area starts at the same position as the previously parsed area.
-            if (currentCol != gridCoordinate.columns.resolvedInitialPosition())
+            if (currentCol != gridArea.columns.resolvedInitialPosition())
                 return false;
 
             // 3. The new area ends at the same position as the previously parsed area.
-            if (lookAheadCol != gridCoordinate.columns.resolvedFinalPosition())
+            if (lookAheadCol != gridArea.columns.resolvedFinalPosition())
                 return false;
 
-            gridCoordinate.rows = GridSpan::translatedDefiniteGridSpan(gridCoordinate.rows.resolvedInitialPosition(), gridCoordinate.rows.resolvedFinalPosition() + 1);
+            gridArea.rows = GridSpan::translatedDefiniteGridSpan(gridArea.rows.resolvedInitialPosition(), gridArea.rows.resolvedFinalPosition() + 1);
         }
         currentCol = lookAheadCol - 1;
     }
diff --git a/third_party/WebKit/Source/core/layout/LayoutGrid.cpp b/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
index 20617a3..53079b8f 100644
--- a/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
@@ -30,7 +30,7 @@
 #include "core/paint/GridPainter.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/ComputedStyle.h"
-#include "core/style/GridCoordinate.h"
+#include "core/style/GridArea.h"
 #include "platform/LengthFunctions.h"
 #include <algorithm>
 
@@ -197,7 +197,7 @@
         return true;
     }
 
-    PassOwnPtr<GridCoordinate> nextEmptyGridArea(size_t fixedTrackSpan, size_t varyingTrackSpan)
+    PassOwnPtr<GridArea> nextEmptyGridArea(size_t fixedTrackSpan, size_t varyingTrackSpan)
     {
         ASSERT(!m_grid.isEmpty());
         ASSERT(fixedTrackSpan >= 1 && varyingTrackSpan >= 1);
@@ -209,7 +209,7 @@
         const size_t endOfVaryingTrackIndex = (m_direction == ForColumns) ? m_grid.size() : m_grid[0].size();
         for (; varyingTrackIndex < endOfVaryingTrackIndex; ++varyingTrackIndex) {
             if (checkEmptyCells(rowSpan, columnSpan)) {
-                OwnPtr<GridCoordinate> result = adoptPtr(new GridCoordinate(GridSpan::translatedDefiniteGridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan::translatedDefiniteGridSpan(m_columnIndex, m_columnIndex + columnSpan)));
+                OwnPtr<GridArea> result = adoptPtr(new GridArea(GridSpan::translatedDefiniteGridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan::translatedDefiniteGridSpan(m_columnIndex, m_columnIndex + columnSpan)));
                 // Advance the iterator to avoid an infinite loop where we would return the same grid area over and over.
                 ++varyingTrackIndex;
                 return result.release();
@@ -1104,13 +1104,13 @@
     }
 }
 
-void LayoutGrid::insertItemIntoGrid(LayoutBox& child, const GridCoordinate& coordinate)
+void LayoutGrid::insertItemIntoGrid(LayoutBox& child, const GridArea& area)
 {
-    RELEASE_ASSERT(coordinate.rows.isTranslatedDefinite() && coordinate.columns.isTranslatedDefinite());
-    ensureGridSize(coordinate.rows.resolvedFinalPosition(), coordinate.columns.resolvedFinalPosition());
+    RELEASE_ASSERT(area.rows.isTranslatedDefinite() && area.columns.isTranslatedDefinite());
+    ensureGridSize(area.rows.resolvedFinalPosition(), area.columns.resolvedFinalPosition());
 
-    for (const auto& row : coordinate.rows) {
-        for (const auto& column: coordinate.columns)
+    for (const auto& row : area.rows) {
+        for (const auto& column: area.columns)
             m_grid[row][column].append(&child);
     }
 }
@@ -1120,7 +1120,7 @@
     if (!m_gridIsDirty)
         return;
 
-    ASSERT(m_gridItemCoordinate.isEmpty());
+    ASSERT(m_gridItemArea.isEmpty());
 
     populateExplicitGridAndOrderIterator();
 
@@ -1133,22 +1133,22 @@
         if (child->isOutOfFlowPositioned())
             continue;
 
-        GridCoordinate coordinate = cachedGridCoordinate(*child);
-        if (!coordinate.rows.isIndefinite())
-            coordinate.rows.translate(abs(m_smallestRowStart));
-        if (!coordinate.columns.isIndefinite())
-            coordinate.columns.translate(abs(m_smallestColumnStart));
-        m_gridItemCoordinate.set(child, coordinate);
+        GridArea area = cachedGridArea(*child);
+        if (!area.rows.isIndefinite())
+            area.rows.translate(abs(m_smallestRowStart));
+        if (!area.columns.isIndefinite())
+            area.columns.translate(abs(m_smallestColumnStart));
+        m_gridItemArea.set(child, area);
 
-        if (coordinate.rows.isIndefinite() || coordinate.columns.isIndefinite()) {
-            GridSpan majorAxisPositions = (autoPlacementMajorAxisDirection() == ForColumns) ? coordinate.columns : coordinate.rows;
+        if (area.rows.isIndefinite() || area.columns.isIndefinite()) {
+            GridSpan majorAxisPositions = (autoPlacementMajorAxisDirection() == ForColumns) ? area.columns : area.rows;
             if (majorAxisPositions.isIndefinite())
                 autoMajorAxisAutoGridItems.append(child);
             else
                 specifiedMajorAxisAutoGridItems.append(child);
             continue;
         }
-        insertItemIntoGrid(*child, coordinate);
+        insertItemIntoGrid(*child, area);
     }
 
     ASSERT(gridRowCount() >= GridPositionsResolver::explicitGridRowCount(*style()));
@@ -1164,8 +1164,8 @@
         if (child->isOutOfFlowPositioned())
             continue;
 
-        GridCoordinate coordinate = cachedGridCoordinate(*child);
-        ASSERT(coordinate.rows.isTranslatedDefinite() && coordinate.columns.isTranslatedDefinite());
+        GridArea area = cachedGridArea(*child);
+        ASSERT(area.rows.isTranslatedDefinite() && area.columns.isTranslatedDefinite());
     }
 #endif
 }
@@ -1188,10 +1188,10 @@
         populator.collectChild(child);
         m_gridItemsIndexesMap.set(child, childIndex++);
 
-        // This function bypasses the cache (cachedGridCoordinate()) as it is used to build it.
+        // This function bypasses the cache (cachedGridArea()) as it is used to build it.
         GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(*style(), *child, ForRows);
         GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(*style(), *child, ForColumns);
-        m_gridItemCoordinate.set(child, GridCoordinate(rowPositions, columnPositions));
+        m_gridItemArea.set(child, GridArea(rowPositions, columnPositions));
 
         // |positions| is 0 if we need to run the auto-placement algorithm.
         if (!rowPositions.isIndefinite()) {
@@ -1218,13 +1218,13 @@
         column.grow(maximumColumnIndex + abs(m_smallestColumnStart));
 }
 
-PassOwnPtr<GridCoordinate> LayoutGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(const LayoutBox& gridItem, GridTrackSizingDirection specifiedDirection, const GridSpan& specifiedPositions) const
+PassOwnPtr<GridArea> LayoutGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(const LayoutBox& gridItem, GridTrackSizingDirection specifiedDirection, const GridSpan& specifiedPositions) const
 {
     GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ? ForRows : ForColumns;
     const size_t endOfCrossDirection = crossDirection == ForColumns ? gridColumnCount() : gridRowCount();
     size_t crossDirectionSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(*style(), gridItem, crossDirection);
     GridSpan crossDirectionPositions = GridSpan::translatedDefiniteGridSpan(endOfCrossDirection, endOfCrossDirection + crossDirectionSpanSize);
-    return adoptPtr(new GridCoordinate(specifiedDirection == ForColumns ? crossDirectionPositions : specifiedPositions, specifiedDirection == ForColumns ? specifiedPositions : crossDirectionPositions));
+    return adoptPtr(new GridArea(specifiedDirection == ForColumns ? crossDirectionPositions : specifiedPositions, specifiedDirection == ForColumns ? specifiedPositions : crossDirectionPositions));
 }
 
 void LayoutGrid::placeSpecifiedMajorAxisItemsOnGrid(const Vector<LayoutBox*>& autoGridItems)
@@ -1245,11 +1245,11 @@
         unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition();
 
         GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
-        OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions.integerSpan(), minorAxisSpanSize);
+        OwnPtr<GridArea> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions.integerSpan(), minorAxisSpanSize);
         if (!emptyGridArea)
             emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(*autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
 
-        m_gridItemCoordinate.set(autoGridItem, *emptyGridArea);
+        m_gridItemArea.set(autoGridItem, *emptyGridArea);
         insertItemIntoGrid(*autoGridItem, *emptyGridArea);
 
         if (!isGridAutoFlowDense)
@@ -1283,7 +1283,7 @@
     size_t majorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.second : autoPlacementCursor.first;
     size_t minorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.first : autoPlacementCursor.second;
 
-    OwnPtr<GridCoordinate> emptyGridArea;
+    OwnPtr<GridArea> emptyGridArea;
     if (minorAxisPositions.isTranslatedDefinite()) {
         // Move to the next track in major axis if initial position in minor axis is before auto-placement cursor.
         if (minorAxisPositions.resolvedInitialPosition() < minorAxisAutoPlacementCursor)
@@ -1323,7 +1323,7 @@
             emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(gridItem, autoPlacementMinorAxisDirection(), GridSpan::translatedDefiniteGridSpan(0, minorAxisSpanSize));
     }
 
-    m_gridItemCoordinate.set(&gridItem, *emptyGridArea);
+    m_gridItemArea.set(&gridItem, *emptyGridArea);
     insertItemIntoGrid(gridItem, *emptyGridArea);
     // Move auto-placement cursor to the new position.
     autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition();
@@ -1353,7 +1353,7 @@
     setNeedsLayout(LayoutInvalidationReason::GridChanged);
 
     m_grid.resize(0);
-    m_gridItemCoordinate.clear();
+    m_gridItemArea.clear();
     m_gridItemsOverflowingGridArea.resize(0);
     m_gridItemsIndexesMap.clear();
     m_gridIsDirty = true;
@@ -1429,9 +1429,9 @@
         updateAutoMarginsInRowAxisIfNeeded(*child);
 
 #if ENABLE(ASSERT)
-        const GridCoordinate& coordinate = cachedGridCoordinate(*child);
-        ASSERT(coordinate.columns.resolvedInitialPosition() < sizingData.columnTracks.size());
-        ASSERT(coordinate.rows.resolvedInitialPosition() < sizingData.rowTracks.size());
+        const GridArea& area = cachedGridArea(*child);
+        ASSERT(area.columns.resolvedInitialPosition() < sizingData.columnTracks.size());
+        ASSERT(area.rows.resolvedInitialPosition() < sizingData.rowTracks.size());
 #endif
         child->setLogicalLocation(findChildLogicalPosition(*child, sizingData));
 
@@ -1544,16 +1544,16 @@
     }
 }
 
-GridCoordinate LayoutGrid::cachedGridCoordinate(const LayoutBox& gridItem) const
+GridArea LayoutGrid::cachedGridArea(const LayoutBox& gridItem) const
 {
-    ASSERT(m_gridItemCoordinate.contains(&gridItem));
-    return m_gridItemCoordinate.get(&gridItem);
+    ASSERT(m_gridItemArea.contains(&gridItem));
+    return m_gridItemArea.get(&gridItem);
 }
 
 GridSpan LayoutGrid::cachedGridSpan(const LayoutBox& gridItem, GridTrackSizingDirection direction) const
 {
-    GridCoordinate coordinate = cachedGridCoordinate(gridItem);
-    return direction == ForColumns ? coordinate.columns : coordinate.rows;
+    GridArea area = cachedGridArea(gridItem);
+    return direction == ForColumns ? area.columns : area.rows;
 }
 
 LayoutUnit LayoutGrid::gridAreaBreadthForChild(const LayoutBox& child, GridTrackSizingDirection direction, const Vector<GridTrack>& tracks) const
diff --git a/third_party/WebKit/Source/core/layout/LayoutGrid.h b/third_party/WebKit/Source/core/layout/LayoutGrid.h
index f85d573..2b8a16c 100644
--- a/third_party/WebKit/Source/core/layout/LayoutGrid.h
+++ b/third_party/WebKit/Source/core/layout/LayoutGrid.h
@@ -33,7 +33,7 @@
 namespace blink {
 
 struct ContentAlignmentData;
-struct GridCoordinate;
+struct GridArea;
 struct GridSpan;
 class GridTrack;
 
@@ -116,10 +116,10 @@
     void resolveContentBasedTrackSizingFunctions(GridTrackSizingDirection, GridSizingData&);
 
     void ensureGridSize(size_t maximumRowSize, size_t maximumColumnSize);
-    void insertItemIntoGrid(LayoutBox&, const GridCoordinate&);
+    void insertItemIntoGrid(LayoutBox&, const GridArea&);
     void placeItemsOnGrid();
     void populateExplicitGridAndOrderIterator();
-    PassOwnPtr<GridCoordinate> createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(const LayoutBox&, GridTrackSizingDirection, const GridSpan& specifiedPositions) const;
+    PassOwnPtr<GridArea> createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(const LayoutBox&, GridTrackSizingDirection, const GridSpan& specifiedPositions) const;
     void placeSpecifiedMajorAxisItemsOnGrid(const Vector<LayoutBox*>&);
     void placeAutoMajorAxisItemsOnGrid(const Vector<LayoutBox*>&);
     void placeAutoMajorAxisItemOnGrid(LayoutBox&, std::pair<size_t, size_t>& autoPlacementCursor);
@@ -158,7 +158,7 @@
     LayoutUnit columnAxisOffsetForChild(const LayoutBox&) const;
     ContentAlignmentData computeContentPositionAndDistributionOffset(GridTrackSizingDirection, const LayoutUnit& availableFreeSpace, unsigned numberOfGridTracks) const;
     LayoutPoint findChildLogicalPosition(const LayoutBox&, GridSizingData&) const;
-    GridCoordinate cachedGridCoordinate(const LayoutBox&) const;
+    GridArea cachedGridArea(const LayoutBox&) const;
     GridSpan cachedGridSpan(const LayoutBox&, GridTrackSizingDirection) const;
 
     LayoutUnit gridAreaBreadthForChild(const LayoutBox& child, GridTrackSizingDirection, const Vector<GridTrack>&) const;
@@ -206,7 +206,7 @@
     bool m_gridIsDirty;
     Vector<LayoutUnit> m_rowPositions;
     Vector<LayoutUnit> m_columnPositions;
-    HashMap<const LayoutBox*, GridCoordinate> m_gridItemCoordinate;
+    HashMap<const LayoutBox*, GridArea> m_gridItemArea;
     OrderIterator m_orderIterator;
     Vector<LayoutBox*> m_gridItemsOverflowingGridArea;
     HashMap<const LayoutBox*, size_t> m_gridItemsIndexesMap;
diff --git a/third_party/WebKit/Source/core/style/GridCoordinate.h b/third_party/WebKit/Source/core/style/GridArea.h
similarity index 93%
rename from third_party/WebKit/Source/core/style/GridCoordinate.h
rename to third_party/WebKit/Source/core/style/GridArea.h
index 65ab46c..990bad2 100644
--- a/third_party/WebKit/Source/core/style/GridCoordinate.h
+++ b/third_party/WebKit/Source/core/style/GridArea.h
@@ -28,8 +28,8 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef GridCoordinate_h
-#define GridCoordinate_h
+#ifndef GridArea_h
+#define GridArea_h
 
 #include "core/style/GridPositionsResolver.h"
 #include "wtf/Allocator.h"
@@ -179,28 +179,28 @@
 };
 
 // This represents a grid area that spans in both rows' and columns' direction.
-struct GridCoordinate {
-    USING_FAST_MALLOC(GridCoordinate);
+struct GridArea {
+    USING_FAST_MALLOC(GridArea);
 public:
     // HashMap requires a default constuctor.
-    GridCoordinate()
+    GridArea()
         : columns(GridSpan::indefiniteGridSpan())
         , rows(GridSpan::indefiniteGridSpan())
     {
     }
 
-    GridCoordinate(const GridSpan& r, const GridSpan& c)
+    GridArea(const GridSpan& r, const GridSpan& c)
         : columns(c)
         , rows(r)
     {
     }
 
-    bool operator==(const GridCoordinate& o) const
+    bool operator==(const GridArea& o) const
     {
         return columns == o.columns && rows == o.rows;
     }
 
-    bool operator!=(const GridCoordinate& o) const
+    bool operator!=(const GridArea& o) const
     {
         return !(*this == o);
     }
@@ -209,8 +209,8 @@
     GridSpan rows;
 };
 
-typedef HashMap<String, GridCoordinate> NamedGridAreaMap;
+typedef HashMap<String, GridArea> NamedGridAreaMap;
 
 } // namespace blink
 
-#endif // GridCoordinate_h
+#endif // GridArea_h
diff --git a/third_party/WebKit/Source/core/style/GridPositionsResolver.cpp b/third_party/WebKit/Source/core/style/GridPositionsResolver.cpp
index 611434a..7d4972c 100644
--- a/third_party/WebKit/Source/core/style/GridPositionsResolver.cpp
+++ b/third_party/WebKit/Source/core/style/GridPositionsResolver.cpp
@@ -5,7 +5,7 @@
 #include "GridPositionsResolver.h"
 
 #include "core/layout/LayoutBox.h"
-#include "core/style/GridCoordinate.h"
+#include "core/style/GridArea.h"
 #include <algorithm>
 
 namespace blink {
diff --git a/third_party/WebKit/Source/core/style/StyleGridData.h b/third_party/WebKit/Source/core/style/StyleGridData.h
index 2c8ea70..fa5fae1 100644
--- a/third_party/WebKit/Source/core/style/StyleGridData.h
+++ b/third_party/WebKit/Source/core/style/StyleGridData.h
@@ -26,7 +26,7 @@
 #ifndef StyleGridData_h
 #define StyleGridData_h
 
-#include "core/style/GridCoordinate.h"
+#include "core/style/GridArea.h"
 #include "core/style/GridTrackSize.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "wtf/PassRefPtr.h"