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

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 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 564 matching lines @@
   Platform::GraphicsInfo* glInfo;
   KURL url;
   // Outputs.
   std::unique_ptr<WebGraphicsContext3DProvider> createdContextProvider;
 };
 
 static void createContextProviderOnMainThread(
     ContextProviderCreationInfo* creationInfo,
     WaitableEvent* waitableEvent) {
   ASSERT(isMainThread());
-  creationInfo->createdContextProvider =
-      wrapUnique(Platform::current()->createOffscreenGraphicsContext3DProvider(
+  creationInfo->createdContextProvider = WTF::wrapUnique(
+      Platform::current()->createOffscreenGraphicsContext3DProvider(
           creationInfo->contextAttributes, creationInfo->url, 0,
           creationInfo->glInfo));
   waitableEvent->signal();
 }
 
 static std::unique_ptr<WebGraphicsContext3DProvider>
 createContextProviderOnWorkerThread(
     Platform::ContextAttributes contextAttributes,
     Platform::GraphicsInfo* glInfo,
     const KURL& url) {
@@ skipping 23 matching lines @@
   // The canvas is only given on the main thread.
   DCHECK(!canvas || isMainThread());
 
   Platform::ContextAttributes contextAttributes =
       toPlatformContextAttributes(attributes, webGLVersion);
   Platform::GraphicsInfo glInfo;
   std::unique_ptr<WebGraphicsContext3DProvider> contextProvider;
   const auto& url = canvas ? canvas->document().topDocument().url()
                            : scriptState->getExecutionContext()->url();
   if (isMainThread()) {
-    contextProvider = wrapUnique(
+    contextProvider = WTF::wrapUnique(
         Platform::current()->createOffscreenGraphicsContext3DProvider(
             contextAttributes, url, 0, &glInfo));
   } else {
     contextProvider =
         createContextProviderOnWorkerThread(contextAttributes, &glInfo, url);
   }
   if (contextProvider && !contextProvider->bindToCurrentThread()) {
     contextProvider = nullptr;
     String errorString(glInfo.errorMessage.utf8().data());
     errorString.insert("bindToCurrentThread failed: ", 0);
@@ skipping 106 matching lines @@
     AccelerationHint hint,
     SnapshotReason reason) const {
   if (!drawingBuffer())
     return nullptr;
 
   drawingBuffer()->resolveAndBindForReadAndDraw();
   IntSize size = clampedCanvasSize();
   OpacityMode opacityMode =
       creationAttributes().hasAlpha() ? NonOpaque : Opaque;
   std::unique_ptr<AcceleratedImageBufferSurface> surface =
-      makeUnique<AcceleratedImageBufferSurface>(size, opacityMode);
+      WTF::makeUnique<AcceleratedImageBufferSurface>(size, opacityMode);
   if (!surface->isValid())
     return nullptr;
   std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(std::move(surface));
   if (!buffer->copyRenderingResultsFromDrawingBuffer(drawingBuffer(),
                                                      BackBuffer)) {
     // copyRenderingResultsFromDrawingBuffer is expected to always succeed
     // because we've explicitly created an Accelerated surface and have already
     // validated it.
     NOTREACHED();
     return nullptr;
@@ skipping 4377 matching lines @@
     // SW path.
     if (video->copyVideoTextureToPlatformTexture(
             contextGL(), texture->object(), internalformat, type,
             m_unpackPremultiplyAlpha, m_unpackFlipY)) {
       return;
     }
 
     // Try using an accelerated image buffer, this allows YUV conversion to be
     // done on the GPU.
     std::unique_ptr<ImageBufferSurface> surface =
-        wrapUnique(new AcceleratedImageBufferSurface(
+        WTF::wrapUnique(new AcceleratedImageBufferSurface(
             IntSize(video->videoWidth(), video->videoHeight())));
     if (surface->isValid()) {
       std::unique_ptr<ImageBuffer> imageBuffer(
           ImageBuffer::create(std::move(surface)));
       if (imageBuffer) {
         // The video element paints an RGBA frame into our surface here. By
         // using an AcceleratedImageBufferSurface, we enable the WebMediaPlayer
         // implementation to do any necessary color space conversion on the GPU
         // (though it may still do a CPU conversion and upload the results).
         video->paintCurrentFrame(
@@ skipping 2229 matching lines @@
   }
 
   Platform::ContextAttributes attributes =
       toPlatformContextAttributes(creationAttributes(), version());
   Platform::GraphicsInfo glInfo;
   std::unique_ptr<WebGraphicsContext3DProvider> contextProvider;
   const auto& url = canvas()
                         ? canvas()->document().topDocument().url()
                         : getOffscreenCanvas()->getExecutionContext()->url();
   if (isMainThread()) {
-    contextProvider = wrapUnique(
+    contextProvider = WTF::wrapUnique(
         Platform::current()->createOffscreenGraphicsContext3DProvider(
             attributes, url, 0, &glInfo));
   } else {
     contextProvider =
         createContextProviderOnWorkerThread(attributes, &glInfo, url);
   }
   RefPtr<DrawingBuffer> buffer;
   if (contextProvider && contextProvider->bindToCurrentThread()) {
     // Construct a new drawing buffer with the new GL context.
     if (canvas()) {
@@ skipping 325 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink