Remove WTFLogAlways() usages from core/layout/

third_party/WebKit/Source/core/layout/LayoutGeometryMap.cpp

 /*
  * Copyright (C) 2012 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 12 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/layout/LayoutGeometryMap.h"
 
 #include "core/frame/LocalFrame.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/geometry/TransformState.h"
 #include "platform/wtf/AutoReset.h"
 
-#define LAYOUT_GEOMETRY_MAP_LOGGING 0

[fs, 2017/06/14 20:14:19]

"...as the code is unmaintainable."

I'm not sure I understand this statement. I don't see the "unmaintainable" bit
here. I don't particularly mind removing this debugging code, but I also didn't
add it... So, could we have a better reason for removing it? (And, tangentially,
there's a typo LayoutGeomteryMap in the same sentence in the description.)

[mrunal, 2017/06/19 22:10:57]

The unmaintainable bit is below where LAYOUT_GEOMETRY_MAP_LOG is used. The
variable references in LAYOUT_GEOMETRY_MAP_LOG are not compile checked so if
their definitions change over time it's hard to keep that code up to date.
I will correct the LayoutGeomteryMap.cpp to LayoutGeometryMap.cpp in the
description.

[fs, 2017/06/20 08:24:35]

Yes, sure, but that is pretty much the burden of having this code checked in in
the first place...

-
-#if LAYOUT_GEOMETRY_MAP_LOGGING
-#define LAYOUT_GEOMETRY_MAP_LOG(...) WTFLogAlways(__VA_ARGS__)

[tkent, 2017/06/14 23:41:39]

Such conditional log macros is usually replaced with DVLOG().

-#else
-#define LAYOUT_GEOMETRY_MAP_LOG(...) ((void)0)
-#endif
-
 namespace blink {
 
 LayoutGeometryMap::LayoutGeometryMap(MapCoordinatesFlags flags)
     : insertion_position_(kNotFound),
       non_uniform_steps_count_(0),
       transformed_steps_count_(0),
       fixed_steps_count_(0),
       map_coordinates_flags_(flags) {}
 
 LayoutGeometryMap::~LayoutGeometryMap() {}
@@ skipping 181 matching lines @@
          map_coordinates_flags_ & kTraverseDocumentBoundaries);
 
   // We have to visit all the layoutObjects to detect flipped blocks. This might
   // defeat the gains from mapping via layers.
   bool can_convert_in_layer_tree =
       (ancestor_layer && !cross_document)
           ? CanMapBetweenLayoutObjects(layout_object,
                                        ancestor_layer->GetLayoutObject())
           : false;
 
-  LAYOUT_GEOMETRY_MAP_LOG(
-      "LayoutGeometryMap::pushMappingsToAncestor from layer %p to layer %p, "
-      "canConvertInLayerTree=%d\n",
-      layer, ancestorLayer, canConvertInLayerTree);
-
   if (can_convert_in_layer_tree) {
     LayoutPoint layer_offset;
     layer->ConvertToLayerCoords(ancestor_layer, layer_offset);
 
     // The LayoutView must be pushed first.
     if (!mapping_.size()) {
       DCHECK(ancestor_layer->GetLayoutObject().IsLayoutView());
       PushMappingsToAncestor(&ancestor_layer->GetLayoutObject(), 0);
     }
 
     AutoReset<size_t> position_change(&insertion_position_, mapping_.size());
     bool accumulating_transform =
         layout_object.Style()->Preserves3D() ||
         ancestor_layer->GetLayoutObject().Style()->Preserves3D();
     Push(&layout_object, ToLayoutSize(layer_offset),
          accumulating_transform ? kAccumulatingTransform : 0);
     return;
   }
   const LayoutBoxModelObject* ancestor_layout_object =
       ancestor_layer ? &ancestor_layer->GetLayoutObject() : 0;
   PushMappingsToAncestor(&layout_object, ancestor_layout_object);
 }
 
 void LayoutGeometryMap::Push(const LayoutObject* layout_object,
                              const LayoutSize& offset_from_container,
                              GeometryInfoFlags flags,
                              LayoutSize offset_for_fixed_position) {
-  LAYOUT_GEOMETRY_MAP_LOG("LayoutGeometryMap::push %p %d,%d isNonUniform=%d\n",
-                          layoutObject, offsetFromContainer.width().toInt(),

[mrunal, 2017/06/19 22:10:57]

@fs, For example there is no definition for offsetFromContainer now as it has
changed. Things like these are unmaintainable if it cannot be checked compile
time.

-                          offsetFromContainer.height().toInt(), isNonUniform);
-
   DCHECK_NE(insertion_position_, kNotFound);
   DCHECK(!layout_object->IsLayoutView() || !insertion_position_ ||
          map_coordinates_flags_ & kTraverseDocumentBoundaries);
   DCHECK(offset_for_fixed_position.IsZero() || layout_object->IsLayoutView());
 
   mapping_.insert(insertion_position_,
                   LayoutGeometryMapStep(layout_object, flags));
 
   LayoutGeometryMapStep& step = mapping_[insertion_position_];
   step.offset_ = offset_from_container;
@@ skipping 94 matching lines @@
   // If we're not working with multiple LayoutViews, then any view is considered
   // "topmost" (to preserve original behavior).
   if (!(map_coordinates_flags_ & kTraverseDocumentBoundaries))
     return true;
 
   return layout_object->GetFrame()->IsMainFrame();
 }
 #endif
 
 }  // namespace blink