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

third_party/WebKit/Source/platform/graphics/BitmapImage.cpp

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2008 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
@@ skipping 472 matching lines @@
   // the other hand, it makes animations "less accurate" for pages that try to
   // sync an image and some other resource (e.g. audio), especially if users
   // switch tabs (and thus stop drawing the animation, which will pause it)
   // during that initial loop, then switch back later.
   if (nextFrame == 0 && m_repetitionsComplete == 0 &&
       m_desiredFrameStartTime < time)
     m_desiredFrameStartTime = time;
 
   if (catchUpIfNecessary == DoNotCatchUp || time < m_desiredFrameStartTime) {
     // Haven't yet reached time for next frame to start; delay until then.
-    m_frameTimer = wrapUnique(
+    m_frameTimer = WTF::wrapUnique(
         new Timer<BitmapImage>(this, &BitmapImage::advanceAnimation));
     m_frameTimer->startOneShot(std::max(m_desiredFrameStartTime - time, 0.),
                                BLINK_FROM_HERE);
   } else {
     // We've already reached or passed the time for the next frame to start.
     // See if we've also passed the time for frames after that to start, in
     // case we need to skip some frames entirely.  Remember not to advance
     // to an incomplete frame.
     for (size_t frameAfterNext = (nextFrame + 1) % frameCount();
          frameIsCompleteAtIndex(frameAfterNext);
@@ skipping 10 matching lines @@
         return;
       }
       m_desiredFrameStartTime = frameAfterNextStartTime;
       nextFrame = frameAfterNext;
     }
 
     // Post a task to advance the frame immediately. m_desiredFrameStartTime
     // may be in the past, meaning the next time through this function we'll
     // kick off the next advancement sooner than this frame's duration would
     // suggest.
-    m_frameTimer = wrapUnique(new Timer<BitmapImage>(
+    m_frameTimer = WTF::wrapUnique(new Timer<BitmapImage>(
         this, &BitmapImage::advanceAnimationWithoutCatchUp));
     m_frameTimer->startOneShot(0, BLINK_FROM_HERE);
   }
 }
 
 void BitmapImage::stopAnimation() {
   // This timer is used to animate all occurrences of this image.  Don't
   // invalidate the timer unless all renderers have stopped drawing.
   m_frameTimer.reset();
 }
@@ skipping 62 matching lines @@
         m_animationPolicy == ImageAnimationPolicyAnimateOnce) {
       m_animationFinished = true;
       m_desiredFrameStartTime = 0;
 
       // We skipped to the last frame and cannot advance further. The
       // observer will not receive animationAdvanced notifications while
       // skipping but we still need to notify the observer to draw the
       // last frame. Skipping frames occurs while painting so we do not
       // synchronously notify the observer which could cause a layout.
       if (advancement == SkipFramesToCatchUp) {
-        m_frameTimer = wrapUnique(new Timer<BitmapImage>(
+        m_frameTimer = WTF::wrapUnique(new Timer<BitmapImage>(
             this, &BitmapImage::notifyObserversOfAnimationAdvance));
         m_frameTimer->startOneShot(0, BLINK_FROM_HERE);
       }
 
       return false;
     }
 
     // Loop the animation back to the first frame.
     m_currentFrame = 0;
   }
 
   // We need to draw this frame if we advanced to it while not skipping.
   if (advancement != SkipFramesToCatchUp)
     getImageObserver()->animationAdvanced(this);
 
   return true;
 }
 
 void BitmapImage::notifyObserversOfAnimationAdvance(TimerBase*) {
   getImageObserver()->animationAdvanced(this);
 }
 
 }  // namespace blink