Rename DisplayItem::Type enum constants to Chromium style.

third_party/WebKit/Source/platform/graphics/paint/DisplayItem.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef DisplayItem_h
 #define DisplayItem_h
 
 #include "platform/PlatformExport.h"
 #include "platform/graphics/ContiguousContainer.h"
 #include "platform/graphics/paint/DisplayItemClient.h"
@@ skipping 12 matching lines @@
 
 class GraphicsContext;
 class IntRect;
 class WebDisplayItemList;
 
 class PLATFORM_EXPORT DisplayItem {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
     enum {
         // Must be kept in sync with core/paint/PaintPhase.h.
-        PaintPhaseMax = 11,
+        kPaintPhaseMax = 11,
     };
 
     // A display item type uniquely identifies a display item of a client.
     // Some display item types can be categorized using the following directives:
     // - In enum Type:
     //   - enum value <Category>First;
     //   - enum values of the category, first of which should equal <Category>First;
     //     (for ease of maintenance, the values should be in alphabetic order)
     //   - enum value <Category>Last which should be equal to the last of the enum values of the category
     // - DEFINE_CATEGORY_METHODS(<Category>) to define is<Category>Type(Type) and is<Category>() methods.
     //
     // A category or subset of a category can contain types each of which corresponds to a PaintPhase:
     // - In enum Type:
     //   - enum value <Category>[<Subset>]PaintPhaseFirst;
     //   - enum value <Category>[<Subset>]PaintPhaseLast = <Category>[<Subset>]PaintPhaseFirst + PaintPhaseMax;
     // - DEFINE_PAINT_PHASE_CONVERSION_METHOD(<Category>[<Subset>]) to define
     //   paintPhaseTo<Category>[<Subset>]Type(PaintPhase) method.
     //
     // A category can be derived from another category, containing types each of which corresponds to a
     // value of the latter category:
     // - In enum Type:
     //   - enum value <Category>First;
     //   - enum value <Category>Last = <Category>First + <BaseCategory>Last - <BaseCategory>First;
     // - DEFINE_CONVERSION_METHODS(<Category>, <category>, <BaseCategory>, <baseCategory>) to define methods to
     //   convert types between the categories;
     enum Type {
-        DrawingFirst,
-        DrawingPaintPhaseFirst = DrawingFirst,
-        DrawingPaintPhaseLast = DrawingFirst + PaintPhaseMax,
-        BoxDecorationBackground,
-        Caret,
-        ColumnRules,
-        DebugDrawing,
-        DocumentBackground,
-        DragImage,
-        DragCaret,
-        SVGImage,
-        LinkHighlight,
-        ImageAreaFocusRing,
-        PageOverlay,
-        PageWidgetDelegateBackgroundFallback,
-        PopupContainerBorder,
-        PopupListBoxBackground,
-        PopupListBoxRow,
-        PrintedContentBackground,
-        PrintedContentDestinationLocations,
-        PrintedContentLineBoundary,
-        PrintedContentPDFURLRect,
-        Resizer,
-        SVGClip,
-        SVGFilter,
-        SVGMask,
-        ScrollbarBackButtonEnd,
-        ScrollbarBackButtonStart,
-        ScrollbarBackground,
-        ScrollbarBackTrack,
-        ScrollbarCorner,
-        ScrollbarForwardButtonEnd,
-        ScrollbarForwardButtonStart,
-        ScrollbarForwardTrack,
-        ScrollbarThumb,
-        ScrollbarTickmarks,
-        ScrollbarTrackBackground,
-        ScrollbarCompositedScrollbar,
-        SelectionTint,
-        TableCellBackgroundFromColumnGroup,
-        TableCellBackgroundFromColumn,
-        TableCellBackgroundFromSection,
-        TableCellBackgroundFromRow,
+        kDrawingFirst,
+        kDrawingPaintPhaseFirst = kDrawingFirst,
+        kDrawingPaintPhaseLast = kDrawingFirst + kPaintPhaseMax,
+        kBoxDecorationBackground,
+        kCaret,
+        kColumnRules,
+        kDebugDrawing,
+        kDocumentBackground,
+        kDragImage,
+        kDragCaret,
+        kSVGImage,
+        kLinkHighlight,
+        kImageAreaFocusRing,
+        kPageOverlay,
+        kPageWidgetDelegateBackgroundFallback,
+        kPopupContainerBorder,
+        kPopupListBoxBackground,
+        kPopupListBoxRow,
+        kPrintedContentBackground,
+        kPrintedContentDestinationLocations,
+        kPrintedContentLineBoundary,
+        kPrintedContentPDFURLRect,
+        kResizer,
+        kSVGClip,
+        kSVGFilter,
+        kSVGMask,
+        kScrollbarBackButtonEnd,
+        kScrollbarBackButtonStart,
+        kScrollbarBackground,
+        kScrollbarBackTrack,
+        kScrollbarCorner,
+        kScrollbarForwardButtonEnd,
+        kScrollbarForwardButtonStart,
+        kScrollbarForwardTrack,
+        kScrollbarThumb,
+        kScrollbarTickmarks,
+        kScrollbarTrackBackground,
+        kScrollbarCompositedScrollbar,
+        kSelectionTint,
+        kTableCellBackgroundFromColumnGroup,
+        kTableCellBackgroundFromColumn,
+        kTableCellBackgroundFromSection,
+        kTableCellBackgroundFromRow,
         // Table collapsed borders can be painted together (e.g., left & top) but there are at most 4 phases of collapsed
         // border painting for a single cell. To disambiguate these phases of collapsed border painting, a mask is used.
         // TableCollapsedBorderBase can be larger than TableCollapsedBorderUnalignedBase to ensure the base lower bits are 0's.
-        TableCollapsedBorderUnalignedBase,
-        TableCollapsedBorderBase = (((TableCollapsedBorderUnalignedBase - 1) >> 4) + 1) << 4,
-        TableCollapsedBorderLast = TableCollapsedBorderBase + 0x0f,
-        TableSectionBoxShadowInset,
-        TableSectionBoxShadowNormal,
-        TableRowBoxShadowInset,
-        TableRowBoxShadowNormal,
-        VideoBitmap,
-        WebPlugin,
-        WebFont,
-        ReflectionMask,
-        DrawingLast = ReflectionMask,
+        kTableCollapsedBorderUnalignedBase,
+        kTableCollapsedBorderBase = (((kTableCollapsedBorderUnalignedBase - 1) >> 4) + 1) << 4,
+        kTableCollapsedBorderLast = kTableCollapsedBorderBase + 0x0f,
+        kTableSectionBoxShadowInset,
+        kTableSectionBoxShadowNormal,
+        kTableRowBoxShadowInset,
+        kTableRowBoxShadowNormal,
+        kVideoBitmap,
+        kWebPlugin,
+        kWebFont,
+        kReflectionMask,
+        kDrawingLast = kReflectionMask,
 
-        ForeignLayerFirst,
-        ForeignLayerCanvas = ForeignLayerFirst,
-        ForeignLayerPlugin,
-        ForeignLayerVideo,
-        ForeignLayerLast = ForeignLayerVideo,
+        kForeignLayerFirst,
+        kForeignLayerCanvas = kForeignLayerFirst,
+        kForeignLayerPlugin,
+        kForeignLayerVideo,
+        kForeignLayerLast = kForeignLayerVideo,
 
-        ClipFirst,
-        ClipBoxPaintPhaseFirst = ClipFirst,
-        ClipBoxPaintPhaseLast = ClipBoxPaintPhaseFirst + PaintPhaseMax,
-        ClipColumnBoundsPaintPhaseFirst,
-        ClipColumnBoundsPaintPhaseLast = ClipColumnBoundsPaintPhaseFirst + PaintPhaseMax,
-        ClipLayerFragmentPaintPhaseFirst,
-        ClipLayerFragmentPaintPhaseLast = ClipLayerFragmentPaintPhaseFirst + PaintPhaseMax,
-        ClipFileUploadControlRect,
-        ClipFrameToVisibleContentRect,
-        ClipFrameScrollbars,
-        ClipLayerBackground,
-        ClipLayerColumnBounds,
-        ClipLayerFilter,
-        ClipLayerForeground,
-        ClipLayerParent,
-        ClipLayerOverflowControls,
-        ClipNodeImage,
-        ClipPopupListBoxFrame,
-        ClipScrollbarsToBoxBounds,
-        ClipSelectionImage,
-        PageWidgetDelegateClip,
-        ClipPrintedPage,
-        ClipLast = ClipPrintedPage,
+        kClipFirst,
+        kClipBoxPaintPhaseFirst = kClipFirst,
+        kClipBoxPaintPhaseLast = kClipBoxPaintPhaseFirst + kPaintPhaseMax,
+        kClipColumnBoundsPaintPhaseFirst,
+        kClipColumnBoundsPaintPhaseLast = kClipColumnBoundsPaintPhaseFirst + kPaintPhaseMax,
+        kClipLayerFragmentPaintPhaseFirst,
+        kClipLayerFragmentPaintPhaseLast = kClipLayerFragmentPaintPhaseFirst + kPaintPhaseMax,
+        kClipFileUploadControlRect,
+        kClipFrameToVisibleContentRect,
+        kClipFrameScrollbars,
+        kClipLayerBackground,
+        kClipLayerColumnBounds,
+        kClipLayerFilter,
+        kClipLayerForeground,
+        kClipLayerParent,
+        kClipLayerOverflowControls,
+        kClipNodeImage,
+        kClipPopupListBoxFrame,
+        kClipScrollbarsToBoxBounds,
+        kClipSelectionImage,
+        kPageWidgetDelegateClip,
+        kClipPrintedPage,
+        kClipLast = kClipPrintedPage,
 
-        EndClipFirst,
-        EndClipLast = EndClipFirst + ClipLast - ClipFirst,
+        kEndClipFirst,
+        kEndClipLast = kEndClipFirst + kClipLast - kClipFirst,
 
-        FloatClipFirst,
-        FloatClipPaintPhaseFirst = FloatClipFirst,
-        FloatClipPaintPhaseLast = FloatClipFirst + PaintPhaseMax,
-        FloatClipLast = FloatClipPaintPhaseLast,
-        EndFloatClipFirst,
-        EndFloatClipLast = EndFloatClipFirst + FloatClipLast - FloatClipFirst,
+        kFloatClipFirst,
+        kFloatClipPaintPhaseFirst = kFloatClipFirst,
+        kFloatClipPaintPhaseLast = kFloatClipFirst + kPaintPhaseMax,
+        kFloatClipLast = kFloatClipPaintPhaseLast,
+        kEndFloatClipFirst,
+        kEndFloatClipLast = kEndFloatClipFirst + kFloatClipLast - kFloatClipFirst,
 
-        ScrollFirst,
-        ScrollPaintPhaseFirst = ScrollFirst,
-        ScrollPaintPhaseLast = ScrollPaintPhaseFirst + PaintPhaseMax,
-        ScrollOverflowControls,
-        ScrollLast = ScrollOverflowControls,
-        EndScrollFirst,
-        EndScrollLast = EndScrollFirst + ScrollLast - ScrollFirst,
+        kScrollFirst,
+        kScrollPaintPhaseFirst = kScrollFirst,
+        kScrollPaintPhaseLast = kScrollPaintPhaseFirst + kPaintPhaseMax,
+        kScrollOverflowControls,
+        kScrollLast = kScrollOverflowControls,
+        kEndScrollFirst,
+        kEndScrollLast = kEndScrollFirst + kScrollLast - kScrollFirst,
 
-        Transform3DFirst,
-        Transform3DElementTransform = Transform3DFirst,
-        Transform3DLast = Transform3DElementTransform,
-        EndTransform3DFirst,
-        EndTransform3DLast = EndTransform3DFirst + Transform3DLast - Transform3DFirst,
+        kTransform3DFirst,
+        kTransform3DElementTransform = kTransform3DFirst,
+        kTransform3DLast = kTransform3DElementTransform,
+        kEndTransform3DFirst,
+        kEndTransform3DLast = kEndTransform3DFirst + kTransform3DLast - kTransform3DFirst,
 
-        BeginFilter,
-        EndFilter,
-        BeginCompositing,
-        EndCompositing,
-        BeginTransform,
-        EndTransform,
-        BeginClipPath,
-        EndClipPath,
+        kBeginFilter,
+        kEndFilter,
+        kBeginCompositing,
+        kEndCompositing,
+        kBeginTransform,
+        kEndTransform,
+        kBeginClipPath,
+        kEndClipPath,
 
-        Subsequence,
-        EndSubsequence,
+        kSubsequence,
+        kEndSubsequence,
 
-        UninitializedType,
-        TypeLast = UninitializedType
+        kUninitializedType,
+        kTypeLast = kUninitializedType
     };
 
-    static_assert(TableCollapsedBorderBase >= TableCollapsedBorderUnalignedBase, "TableCollapsedBorder types overlap with other types");
-    static_assert((TableCollapsedBorderBase & 0xf) == 0, "The lowest 4 bits of TableCollapsedBorderBase should be zero");
+    static_assert(kTableCollapsedBorderBase >= kTableCollapsedBorderUnalignedBase, "TableCollapsedBorder types overlap with other types");
+    static_assert((kTableCollapsedBorderBase & 0xf) == 0, "The lowest 4 bits of TableCollapsedBorderBase should be zero");
     // Bits or'ed onto TableCollapsedBorderBase to generate a real table collapsed border type.
     enum TableCollapsedBorderSides {
         TableCollapsedBorderTop = 1 << 0,
         TableCollapsedBorderRight = 1 << 1,
         TableCollapsedBorderBottom = 1 << 2,
         TableCollapsedBorderLeft = 1 << 3,
     };
 
     DisplayItem(const DisplayItemClient& client, Type type, size_t derivedSize)
         : m_client(&client)
@@ skipping 39 matching lines @@
     // For PaintController only. Painters should use DisplayItemCacheSkipper instead.
     void setSkippedCache() { m_skippedCache = true; }
     bool skippedCache() const { return m_skippedCache; }
 
     // TODO(wkorman): Only DrawingDisplayItem needs the visual rect argument.
     // Consider refactoring class hierarchy to make this more explicit.
     virtual void appendToWebDisplayItemList(const IntRect&, WebDisplayItemList*) const { }
 
     // See comments of enum Type for usage of the following macros.
 #define DEFINE_CATEGORY_METHODS(Category) \
-    static bool is##Category##Type(Type type) { return type >= Category##First && type <= Category##Last; } \
+    static bool is##Category##Type(Type type) { return type >= k##Category##First && type <= k##Category##Last; } \
     bool is##Category() const { return is##Category##Type(getType()); }
 
 #define DEFINE_CONVERSION_METHODS(Category1, category1, Category2, category2) \
     static Type category1##TypeTo##Category2##Type(Type type) \
     { \
-        static_assert(Category1##Last - Category1##First == Category2##Last - Category2##First, \
+        static_assert(k##Category1##Last - k##Category1##First == k##Category2##Last - k##Category2##First, \
             "Categories " #Category1 " and " #Category2 " should have same number of enum values. See comments of DisplayItem::Type"); \
         ASSERT(is##Category1##Type(type)); \
-        return static_cast<Type>(type - Category1##First + Category2##First); \
+        return static_cast<Type>(type - k##Category1##First + k##Category2##First); \
     } \
     static Type category2##TypeTo##Category1##Type(Type type) \
     { \
         ASSERT(is##Category2##Type(type)); \
-        return static_cast<Type>(type - Category2##First + Category1##First); \
+        return static_cast<Type>(type - k##Category2##First + k##Category1##First); \
     }
 
 #define DEFINE_PAIRED_CATEGORY_METHODS(Category, category) \
     DEFINE_CATEGORY_METHODS(Category) \
     DEFINE_CATEGORY_METHODS(End##Category) \
     DEFINE_CONVERSION_METHODS(Category, category, End##Category, end##Category)
 
 #define DEFINE_PAINT_PHASE_CONVERSION_METHOD(Category) \
     static Type paintPhaseTo##Category##Type(int paintPhase) \
     { \
-        static_assert(Category##PaintPhaseLast - Category##PaintPhaseFirst == PaintPhaseMax, \
+        static_assert(k##Category##PaintPhaseLast - k##Category##PaintPhaseFirst == k##PaintPhaseMax, \
             "Invalid paint-phase-based category " #Category ". See comments of DisplayItem::Type"); \
-        return static_cast<Type>(paintPhase + Category##PaintPhaseFirst); \
+        return static_cast<Type>(paintPhase + k##Category##PaintPhaseFirst); \
     }
 
     DEFINE_CATEGORY_METHODS(Drawing)
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(Drawing)
 
     DEFINE_CATEGORY_METHODS(ForeignLayer)
 
     DEFINE_PAIRED_CATEGORY_METHODS(Clip, clip)
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(ClipLayerFragment)
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(ClipBox)
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(ClipColumnBounds)
 
     DEFINE_PAIRED_CATEGORY_METHODS(FloatClip, floatClip)
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(FloatClip)
 
     DEFINE_PAIRED_CATEGORY_METHODS(Scroll, scroll)
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(Scroll)
 
     DEFINE_PAIRED_CATEGORY_METHODS(Transform3D, transform3D)
 
-    static bool isCacheableType(Type type) { return isDrawingType(type) || type == Subsequence; }
+    static bool isCacheableType(Type type) { return isDrawingType(type) || type == kSubsequence; }
     bool isCacheable() const { return !skippedCache() && isCacheableType(m_type); }
 
     virtual bool isBegin() const { return false; }
     virtual bool isEnd() const { return false; }
 
 #if DCHECK_IS_ON()
     virtual bool isEndAndPairedWith(DisplayItem::Type otherType) const { return false; }
     virtual bool equals(const DisplayItem& other) const
     {
         return m_client == other.m_client
@@ skipping 23 matching lines @@
 #endif
 
 private:
     // The default DisplayItem constructor is only used by
     // ContiguousContainer::appendByMoving where an invalid DisplaItem is
     // constructed at the source location.
     template <typename T, unsigned alignment> friend class ContiguousContainer;
 
     DisplayItem()
         : m_client(nullptr)
-        , m_type(UninitializedType)
+        , m_type(kUninitializedType)
         , m_derivedSize(sizeof(*this))
         , m_skippedCache(false)
     { }
 
     const DisplayItemClient* m_client;
-    static_assert(TypeLast < (1 << 16), "DisplayItem::Type should fit in 16 bits");
+    static_assert(kTypeLast < (1 << 16), "DisplayItem::Type should fit in 16 bits");
     const Type m_type : 16;
     const unsigned m_derivedSize : 8; // size of the actual derived class
     unsigned m_skippedCache : 1;
 
 #ifndef NDEBUG
     WTF::String m_clientDebugString;
 #endif
 };
 
 inline bool operator==(const DisplayItem::Id& a, const DisplayItem::Id& b)
@@ skipping 22 matching lines @@
     bool isEndAndPairedWith(DisplayItem::Type otherType) const override = 0;
 #endif
 
 private:
     bool isEnd() const final { return true; }
 };
 
 } // namespace blink
 
 #endif // DisplayItem_h