Use floating_object's parent object to check for overhanging floats.

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

 /*
  * Copyright (C) 2013 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 4131 matching lines @@
     if (!ancestor_floating_objects)
       break;
     FloatingObjectSet::iterator it =
         ancestor_floating_objects->MutableSet()
             .Find<FloatingObjectHashTranslator>(
                 const_cast<LayoutBox*>(&float_box));
     if (it == ancestor_floating_objects->MutableSet().end())
       break;
 
     FloatingObject& floating_object = **it;
-    if (!float_box_is_self_painting_layer) {
-      // This repeats the logic in addOverhangingFloats() about shouldPaint
-      // flag:
-      // - The nearest enclosing block in which the float doesn't overhang
-      //   paints the float;
-      // - Or even if the float overhangs, if the ancestor block has
-      //   self-painting layer, it paints the float.
-      if (ancestor_block->HasSelfPaintingLayer() ||
-          !ancestor_block->IsOverhangingFloat(floating_object)) {
-        floating_object.SetShouldPaint(true);
-        return;
-      }
-    } else {
-      floating_object.SetShouldPaint(false);
-    }
+    // This repeats the logic in addOverhangingFloats() about shouldPaint
+    // flag:
+    // - The nearest enclosing block in which the float doesn't overhang
+    //   paints the float;
+    // - Or even if the float overhangs, if the ancestor block has
+    //   self-painting layer, it paints the float.
+    LayoutBlockFlow* parent_block =
+        ToLayoutBlockFlow(floating_object.GetLayoutObject()->Parent());
+    bool is_overhanging_float =
+        parent_block && parent_block->IsOverhangingFloat(floating_object);
+    bool should_paint =
+        !float_box_is_self_painting_layer &&
+        (ancestor_block->HasSelfPaintingLayer() || !is_overhanging_float);
+    floating_object.SetShouldPaint(should_paint);
+
+    if (floating_object.ShouldPaint())
+      return;
   }
 }
 
 bool LayoutBlockFlow::AllowsPaginationStrut() const {
   // The block needs to be contained by a LayoutBlockFlow (and not by e.g. a
   // flexbox, grid, or a table (the latter being the case for table cell or
   // table caption)). The reason for this limitation is simply that
   // LayoutBlockFlow child layout code is the only place where we pick up the
   // struts and handle them. We handle floats and regular in-flow children, and
   // that's all. We could handle this in other layout modes as well (and even
@@ skipping 515 matching lines @@
   return LayoutBlock::DeprecatedInvalidatePaint(paint_invalidation_state);
 }
 
 void LayoutBlockFlow::InvalidateDisplayItemClients(
     PaintInvalidationReason invalidation_reason) const {
   BlockFlowPaintInvalidator(*this).InvalidateDisplayItemClients(
       invalidation_reason);
 }
 
 }  // namespace blink