Manually rename \<m_[0-9]... fields to help rewrite_to_chrome_style tool.

third_party/WebKit/Source/core/paint/PaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 118 matching lines @@
 }
 
 PaintLayerRareData::~PaintLayerRareData()
 {
 }
 
 PaintLayer::PaintLayer(LayoutBoxModelObject* layoutObject)
     : m_hasSelfPaintingLayerDescendant(false)
     , m_hasSelfPaintingLayerDescendantDirty(false)
     , m_isRootLayer(layoutObject->isLayoutView())
-    , m_visibleContentStatusDirty(true)
+    , m_isVisibleContentDirty(true)
     , m_hasVisibleContent(false)
-    , m_visibleDescendantStatusDirty(false)
+    , m_isVisibleDescendantDirty(false)
     , m_hasVisibleDescendant(false)
 #if ENABLE(ASSERT)
     , m_needsPositionUpdate(true)
 #endif
-    , m_3DTransformedDescendantStatusDirty(true)
+    , m_is3DTransformedDescendantDirty(true)
     , m_has3DTransformedDescendant(false)
     , m_containsDirtyOverlayScrollbars(false)
     , m_needsAncestorDependentCompositingInputsUpdate(true)
     , m_needsDescendantDependentCompositingInputsUpdate(true)
     , m_childNeedsCompositingInputsUpdate(true)
     , m_hasCompositingDescendant(false)
     , m_isAllScrollingContentComposited(false)
     , m_shouldIsolateCompositedDescendants(false)
     , m_lostGroupedMapping(false)
     , m_needsRepaint(false)
@@ skipping 12 matching lines @@
     , m_last(0)
     , m_staticInlinePosition(0)
     , m_staticBlockPosition(0)
     , m_ancestorOverflowLayer(nullptr)
 {
     updateStackingNode();
 
     m_isSelfPaintingLayer = shouldBeSelfPaintingLayer();
 
     if (!layoutObject->slowFirstChild() && layoutObject->style()) {
-        m_visibleContentStatusDirty = false;
+        m_isVisibleContentDirty = false;
         m_hasVisibleContent = layoutObject->style()->visibility() == EVisibility::Visible;
     }
 
     updateScrollableArea();
 }
 
 PaintLayer::~PaintLayer()
 {
     if (m_rareData && m_rareData->filterInfo)
         m_rareData->filterInfo->clearLayer();
@@ skipping 404 matching lines @@
     // an ancestor of all of them, in order to properly take into account any local transforms etc.
     // FIXME: remove this special-case code that works around the paint invalidation code structure.
     layoutObject.mapToVisualRectInAncestorSpace(&paintInvalidationContainer, rect);
 
     mapRectInPaintInvalidationContainerToBacking(paintInvalidationContainer, rect);
 }
 
 void PaintLayer::dirtyVisibleContentStatus()
 {
     compositor()->setNeedsUpdateDescendantDependentFlags();
-    m_visibleContentStatusDirty = true;
+    m_isVisibleContentDirty = true;
     if (parent())
         parent()->dirtyAncestorChainVisibleDescendantStatus();
     // Non-self-painting layers paint into their ancestor layer, and count as part of the "visible contents" of the parent, so we need to dirty it.
     if (!isSelfPaintingLayer())
         parent()->dirtyVisibleContentStatus();
 }
 
 void PaintLayer::potentiallyDirtyVisibleContentStatus(EVisibility visibility)
 {
-    if (m_visibleContentStatusDirty)
+    if (m_isVisibleContentDirty)
         return;
     if (hasVisibleContent() == (visibility == EVisibility::Visible))
         return;
     dirtyVisibleContentStatus();
 }
 
 void PaintLayer::dirtyAncestorChainVisibleDescendantStatus()
 {
     compositor()->setNeedsUpdateDescendantDependentFlags();
 
     for (PaintLayer* layer = this; layer; layer = layer->parent()) {
-        if (layer->m_visibleDescendantStatusDirty)
+        if (layer->m_isVisibleDescendantDirty)
             break;
-        layer->m_visibleDescendantStatusDirty = true;
+        layer->m_isVisibleDescendantDirty = true;
     }
 }
 
 // FIXME: this is quite brute-force. We could be more efficient if we were to
 // track state and update it as appropriate as changes are made in the layout tree.
 void PaintLayer::updateScrollingStateAfterCompositingChange()
 {
     TRACE_EVENT0("blink", "PaintLayer::updateScrollingStateAfterCompositingChange");
     m_isAllScrollingContentComposited = true;
     for (LayoutObject* r = layoutObject()->slowFirstChild(); r; r = r->nextSibling()) {
@@ skipping 11 matching lines @@
             // If the child is composited, but not a stacking context, it may paint
             // negative z-index descendants into an ancestor's GraphicsLayer.
             m_isAllScrollingContentComposited = false;
             return;
         }
     }
 }
 
 void PaintLayer::updateDescendantDependentFlags()
 {
-    if (m_visibleDescendantStatusDirty) {
+    if (m_isVisibleDescendantDirty) {
         m_hasVisibleDescendant = false;
 
         for (PaintLayer* child = firstChild(); child; child = child->nextSibling()) {
             child->updateDescendantDependentFlags();
 
             if (child->m_hasVisibleContent || child->m_hasVisibleDescendant) {
                 m_hasVisibleDescendant = true;
                 break;
             }
         }
 
-        m_visibleDescendantStatusDirty = false;
+        m_isVisibleDescendantDirty = false;
     }
 
-    if (m_visibleContentStatusDirty) {
+    if (m_isVisibleContentDirty) {
         bool previouslyHasVisibleContent = m_hasVisibleContent;
         if (layoutObject()->style()->visibility() == EVisibility::Visible) {
             m_hasVisibleContent = true;
         } else {
             // layer may be hidden but still have some visible content, check for this
             m_hasVisibleContent = false;
             LayoutObject* r = layoutObject()->slowFirstChild();
             while (r) {
                 if (r->style()->visibility() == EVisibility::Visible && (!r->hasLayer() || !r->enclosingLayer()->isSelfPaintingLayer())) {
                     m_hasVisibleContent = true;
                     break;
                 }
                 LayoutObject* layoutObjectFirstChild = r->slowFirstChild();
                 if (layoutObjectFirstChild && (!r->hasLayer() || !r->enclosingLayer()->isSelfPaintingLayer())) {
                     r = layoutObjectFirstChild;
                 } else if (r->nextSibling()) {
                     r = r->nextSibling();
                 } else {
                     do {
                         r = r->parent();
                         if (r == layoutObject())
                             r = 0;
                     } while (r && !r->nextSibling());
                     if (r)
                         r = r->nextSibling();
                 }
             }
         }
-        m_visibleContentStatusDirty = false;
+        m_isVisibleContentDirty = false;
 
         if (hasVisibleContent() != previouslyHasVisibleContent) {
             setNeedsCompositingInputsUpdate();
             // We need to tell m_layoutObject to recheck its rect because we
             // pretend that invisible LayoutObjects have 0x0 rects. Changing
             // visibility therefore changes our rect and we need to visit
             // this LayoutObject during the invalidateTreeIfNeeded walk.
             m_layoutObject->setMayNeedPaintInvalidation();
         }
     }
 }
 
 void PaintLayer::dirty3DTransformedDescendantStatus()
 {
     PaintLayerStackingNode* stackingNode = m_stackingNode->ancestorStackingContextNode();
     if (!stackingNode)
         return;
 
-    stackingNode->layer()->m_3DTransformedDescendantStatusDirty = true;
+    stackingNode->layer()->m_is3DTransformedDescendantDirty = true;
 
     // This propagates up through preserve-3d hierarchies to the enclosing flattening layer.
     // Note that preserves3D() creates stacking context, so we can just run up the stacking containers.
     while (stackingNode && stackingNode->layer()->preserves3D()) {
-        stackingNode->layer()->m_3DTransformedDescendantStatusDirty = true;
+        stackingNode->layer()->m_is3DTransformedDescendantDirty = true;
         stackingNode = stackingNode->ancestorStackingContextNode();
     }
 }
 
 // Return true if this layer or any preserve-3d descendants have 3d.
 bool PaintLayer::update3DTransformedDescendantStatus()
 {
-    if (m_3DTransformedDescendantStatusDirty) {
+    if (m_is3DTransformedDescendantDirty) {
         m_has3DTransformedDescendant = false;
 
         m_stackingNode->updateZOrderLists();
 
         // Transformed or preserve-3d descendants can only be in the z-order lists, not
         // in the normal flow list, so we only need to check those.
         PaintLayerStackingNodeIterator iterator(*m_stackingNode.get(), PositiveZOrderChildren | NegativeZOrderChildren);
         while (PaintLayerStackingNode* node = iterator.next())
             m_has3DTransformedDescendant |= node->layer()->update3DTransformedDescendantStatus();
 
-        m_3DTransformedDescendantStatusDirty = false;
+        m_is3DTransformedDescendantDirty = false;
     }
 
     // If we live in a 3d hierarchy, then the layer at the root of that hierarchy needs
     // the m_has3DTransformedDescendant set.
     if (preserves3D())
         return has3DTransform() || m_has3DTransformedDescendant;
 
     return has3DTransform();
 }
 
@@ skipping 2190 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif