Make the LayoutRect->FloatRect constructor explicit.

Source/core/layout/LayoutInline.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 664 matching lines @@
         : m_quads(quads)
         , m_geometryMap()
     {
         m_geometryMap.pushMappingsToAncestor(layoutObject, 0);
     }
 
     void operator()(const FloatRect& rect)
     {
         m_quads.append(m_geometryMap.absoluteRect(rect));
     }
+    void operator()(const LayoutRect& rect)
+    {
+        m_quads.append(m_geometryMap.absoluteRect(FloatRect(rect)));

[jbroman, 2015/08/26 19:06:43]

nit: I don't feel strongly, but how about delegating to the existing method
which shares most of the logic:

void operator()(const LayoutRect& rect)
{
    operator()(FloatRect(rect));
}

[chrishtr, 2015/08/26 20:53:51]

Done.

+    }
 private:
     Vector<FloatQuad>& m_quads;
     LayoutGeometryMap m_geometryMap;
 };
 
 } // unnamed namespace
 
 void LayoutInline::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
 {
     AbsoluteQuadsGeneratorContext context(this, quads);
@@ skipping 84 matching lines @@
 namespace {
 
 class HitTestCulledInlinesGeneratorContext {
 public:
     HitTestCulledInlinesGeneratorContext(Region& region, const HitTestLocation& location) : m_intersected(false), m_region(region), m_location(location) { }
     void operator()(const FloatRect& rect)
     {
         m_intersected = m_intersected || m_location.intersects(rect);
         m_region.unite(enclosingIntRect(rect));
     }
+    void operator()(const LayoutRect& rect)
+    {
+        m_intersected = m_intersected || m_location.intersects(rect);
+        m_region.unite(enclosingIntRect(rect));
+    }
     bool intersected() const { return m_intersected; }
 private:
     bool m_intersected;
     Region& m_region;
     const HitTestLocation& m_location;
 };
 
 } // unnamed namespace
 
 bool LayoutInline::hitTestCulledInline(HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset)
@@ skipping 43 matching lines @@
 
 namespace {
 
 class LinesBoundingBoxGeneratorContext {
 public:
     LinesBoundingBoxGeneratorContext(FloatRect& rect) : m_rect(rect) { }
     void operator()(const FloatRect& rect)
     {
         m_rect.uniteIfNonZero(rect);
     }
+    void operator()(const LayoutRect& rect)
+    {
+        m_rect.uniteIfNonZero(FloatRect(rect));

[jbroman, 2015/08/26 19:06:43]

could do the same here; not sure if it's cleaner or not

[chrishtr, 2015/08/26 20:53:51]

Done.

+    }
 private:
     FloatRect& m_rect;
 };
 
 } // unnamed namespace
 
 IntRect LayoutInline::linesBoundingBox() const
 {
     if (!alwaysCreateLineBoxes()) {
         ASSERT(!firstLineBox());
@@ skipping 484 matching lines @@
 namespace {
 
 class AbsoluteLayoutRectsGeneratorContext {
 public:
     AbsoluteLayoutRectsGeneratorContext(Vector<LayoutRect>& rects, const LayoutPoint& accumulatedOffset)
         : m_rects(rects)
         , m_accumulatedOffset(accumulatedOffset) { }
 
     void operator()(const FloatRect& rect)
     {
         LayoutRect layoutRect(rect);

[jbroman, 2015/08/26 19:06:43]

nit: and here, but delegating to the LayoutRect overload

[chrishtr, 2015/08/26 20:53:51]

Done.

-        layoutRect.move(m_accumulatedOffset.x(), m_accumulatedOffset.y());
+        layoutRect.moveBy(m_accumulatedOffset);
+        m_rects.append(layoutRect);
+    }
+    void operator()(const LayoutRect& rect)
+    {
+        LayoutRect layoutRect(rect);
+        layoutRect.moveBy(m_accumulatedOffset);
         m_rects.append(layoutRect);
     }
 private:
     Vector<LayoutRect>& m_rects;
     const LayoutPoint& m_accumulatedOffset;
 };
 
 class AbsoluteLayoutRectsIgnoringEmptyRectsGeneratorContext : public AbsoluteLayoutRectsGeneratorContext {
 public:
     AbsoluteLayoutRectsIgnoringEmptyRectsGeneratorContext(Vector<LayoutRect>& rects, const LayoutPoint& accumulatedOffset)
         : AbsoluteLayoutRectsGeneratorContext(rects, accumulatedOffset) { }
 
     void operator()(const FloatRect& rect)
     {
         if (!rect.isEmpty())
             AbsoluteLayoutRectsGeneratorContext::operator()(rect);
     }
+    void operator()(const LayoutRect& rect)
+    {
+        if (!rect.isEmpty())
+            AbsoluteLayoutRectsGeneratorContext::operator()(FloatRect(rect));
+    }
 };
 
 } // unnamed namespace
 
 void LayoutInline::addOutlineRects(Vector<LayoutRect>& rects, const LayoutPoint& additionalOffset) const
 {
     AbsoluteLayoutRectsIgnoringEmptyRectsGeneratorContext context(rects, additionalOffset);
     generateLineBoxRects(context);
     addOutlineRectsForChildrenAndContinuations(rects, additionalOffset);
 }
@@ skipping 44 matching lines @@
 }
 
 void LayoutInline::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     LayoutBoxModelObject::invalidateDisplayItemClients(paintInvalidationContainer);
     for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box);
 }
 
 } // namespace blink