s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
  *               All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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
@@ skipping 89 matching lines @@
   // re-layout the float.
   // This hack can be removed after SPv2.
   return m_layoutObject->layer() &&
          m_layoutObject->layer()->isSelfPaintingOnlyBecauseIsCompositedPart() &&
          !RuntimeEnabledFeatures::slimmingPaintV2Enabled();
 }
 
 std::unique_ptr<FloatingObject> FloatingObject::create(
     LayoutBox* layoutObject) {
   std::unique_ptr<FloatingObject> newObj =
-      wrapUnique(new FloatingObject(layoutObject));
+      WTF::wrapUnique(new FloatingObject(layoutObject));
 
   // If a layer exists, the float will paint itself. Otherwise someone else
   // will.
   newObj->setShouldPaint(!layoutObject->hasSelfPaintingLayer() ||
                          newObj->shouldPaintForCompositedLayoutPart());
 
   newObj->setIsDescendant(true);
 
   return newObj;
 }
 
 bool FloatingObject::shouldPaint() const {
   return m_shouldPaint && !m_layoutObject->hasSelfPaintingLayer();
 }
 
 std::unique_ptr<FloatingObject> FloatingObject::copyToNewContainer(
     LayoutSize offset,
     bool shouldPaint,
     bool isDescendant) const {
-  return wrapUnique(new FloatingObject(
+  return WTF::wrapUnique(new FloatingObject(
       layoutObject(), getType(),
       LayoutRect(frameRect().location() - offset, frameRect().size()),
       shouldPaint, isDescendant, isLowestNonOverhangingFloatInChild()));
 }
 
 std::unique_ptr<FloatingObject> FloatingObject::unsafeClone() const {
   std::unique_ptr<FloatingObject> cloneObject =
-      wrapUnique(new FloatingObject(layoutObject(), getType(), m_frameRect,
-                                    m_shouldPaint, m_isDescendant, false));
+      WTF::wrapUnique(new FloatingObject(layoutObject(), getType(), m_frameRect,
+                                         m_shouldPaint, m_isDescendant, false));
   cloneObject->m_isPlaced = m_isPlaced;
   return cloneObject;
 }
 
 template <FloatingObject::Type FloatTypeValue>
 class ComputeFloatOffsetAdapter {
  public:
   typedef FloatingObjectInterval IntervalType;
 
   ComputeFloatOffsetAdapter(const LayoutBlockFlow* layoutObject,
@@ skipping 396 matching lines @@
 #if ENABLE(ASSERT)
   floatingObject.setIsInPlacedTree(false);
 #endif
   markLowestFloatLogicalBottomCacheAsDirty();
 }
 
 FloatingObject* FloatingObjects::add(
     std::unique_ptr<FloatingObject> floatingObject) {
   FloatingObject* newObject = floatingObject.release();
   increaseObjectsCount(newObject->getType());
-  m_set.add(wrapUnique(newObject));
+  m_set.add(WTF::wrapUnique(newObject));
   if (newObject->isPlaced())
     addPlacedObject(*newObject);
   markLowestFloatLogicalBottomCacheAsDirty();
   return newObject;
 }
 
 void FloatingObjects::remove(FloatingObject* toBeRemoved) {
   decreaseObjectsCount(toBeRemoved->getType());
   std::unique_ptr<FloatingObject> floatingObject = m_set.take(toBeRemoved);
   ASSERT(floatingObject->isPlaced() || !floatingObject->isInPlacedTree());
@@ skipping 181 matching lines @@
     const FloatingObject* floatingObject) {
   return String::format("%p (%gx%g %gx%g)", floatingObject,
                         floatingObject->frameRect().x().toFloat(),
                         floatingObject->frameRect().y().toFloat(),
                         floatingObject->frameRect().maxX().toFloat(),
                         floatingObject->frameRect().maxY().toFloat());
 }
 #endif
 
 }  // namespace blink