blink: m_foo -> foo_ in logging strings.

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

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. 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>
@@ skipping 145 matching lines @@
 //
 // The class is central to painting and hit-testing. That's because it handles
 // a lot of tasks (we included ones done by associated satellite objects for
 // historical reasons):
 // - Complex painting operations (opacity, clipping, filters, reflections, ...).
 // - hardware acceleration (through PaintLayerCompositor).
 // - scrolling (through PaintLayerScrollableArea).
 // - some performance optimizations.
 //
 // The compositing code is also based on PaintLayer. The entry to it is the
-// PaintLayerCompositor, which fills |m_compositedLayerMapping| for hardware
+// PaintLayerCompositor, which fills |composited_layer_mapping| for hardware
 // accelerated layers.
 //
 // TODO(jchaffraix): Expand the documentation about hardware acceleration.
 //
 //
 // ***** SELF-PAINTING LAYER *****
 // One important concept about PaintLayer is "self-painting"
-// (m_isSelfPaintingLayer).
+// (is_self_painting_layer_).
 // PaintLayer started as the implementation of a stacking context. This meant
 // that we had to use PaintLayer's painting order (the code is now in
 // PaintLayerPainter and PaintLayerStackingNode) instead of the LayoutObject's
 // children order. Over the years, as more operations were handled by
 // PaintLayer, some LayoutObjects that were not stacking context needed to have
 // a PaintLayer for bookkeeping reasons. One such example is the overflow hidden
 // case that wanted hardware acceleration and thus had to allocate a PaintLayer
 // to get it. However overflow hidden is something LayoutObject can paint
 // without a PaintLayer, which includes a lot of painting overhead. Thus the
 // self-painting flag was introduced. The flag is a band-aid solution done for
@@ skipping 79 matching lines @@
       curr = curr->Parent();
     return curr;
   }
 
   const LayoutPoint& Location() const {
 #if DCHECK_IS_ON()
     DCHECK(!needs_position_update_);
 #endif
     return location_;
   }
-  // FIXME: size() should DCHECK(!m_needsPositionUpdate) as well, but that fails
-  // in some tests, for example, fast/repaint/clipped-relative.html.
+  // FIXME: size() should DCHECK(!needs_position_update_) as well, but that
+  // fails in some tests, for example, fast/repaint/clipped-relative.html.
   const IntSize& size() const { return size_; }
   void SetSizeHackForLayoutTreeAsText(const IntSize& size) { size_ = size; }
 
   LayoutRect Rect() const { return LayoutRect(Location(), LayoutSize(size())); }
 
   bool IsRootLayer() const { return is_root_layer_; }
 
   PaintLayerCompositor* Compositor() const;
 
   // Notification from the layoutObject that its content changed (e.g. current
@@ skipping 903 matching lines @@
 
   unsigned contains_dirty_overlay_scrollbars_ : 1;
 
   unsigned needs_ancestor_dependent_compositing_inputs_update_ : 1;
   unsigned child_needs_compositing_inputs_update_ : 1;
 
   // Used only while determining what layers should be composited. Applies to
   // the tree of z-order lists.
   unsigned has_compositing_descendant_ : 1;
 
-  // True iff we have scrollable overflow and all children of m_layoutObject are
+  // True iff we have scrollable overflow and all children of layout_object_ are
   // known to paint exclusively into their own composited layers.  Set by
   // updateScrollingStateAfterCompositingChange().
   unsigned is_all_scrolling_content_composited_ : 1;
 
   // Should be for stacking contexts having unisolated blending descendants.
   unsigned should_isolate_composited_descendants_ : 1;
 
   // True if this layout layer just lost its grouped mapping due to the
   // CompositedLayerMapping being destroyed, and we don't yet know to what
   // graphics layer this Layer will be assigned.
   unsigned lost_grouped_mapping_ : 1;
 
   unsigned needs_repaint_ : 1;
   unsigned previous_paint_result_ : 1;  // PaintResult
   static_assert(kMaxPaintResult <= 2,
-                "Should update number of bits of m_previousPaintResult");
+                "Should update number of bits of previous_paint_result_");
 
   unsigned needs_paint_phase_descendant_outlines_ : 1;
   unsigned previous_paint_phase_descendant_outlines_was_empty_ : 1;
   unsigned needs_paint_phase_float_ : 1;
   unsigned previous_paint_phase_float_was_empty_ : 1;
   unsigned needs_paint_phase_descendant_block_backgrounds_ : 1;
   unsigned previous_paint_phase_descendant_block_backgrounds_was_empty_ : 1;
 
   // These bitfields are part of ancestor/descendant dependent compositing
   // inputs.
@@ skipping 51 matching lines @@
 
 }  // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 CORE_EXPORT void showLayerTree(const blink::PaintLayer*);
 CORE_EXPORT void showLayerTree(const blink::LayoutObject*);
 #endif
 
 #endif  // Layer_h