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

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

 /*
  * Copyright (c) 2008, Google Inc. All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. 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
@@ skipping 54 matching lines @@
 #include "wtf/text/WTFString.h"
 #include "wtf/typed_arrays/ArrayBufferContents.h"
 #include <memory>
 
 namespace blink {
 
 std::unique_ptr<ImageBuffer> ImageBuffer::create(
     std::unique_ptr<ImageBufferSurface> surface) {
   if (!surface->isValid())
     return nullptr;
-  return wrapUnique(new ImageBuffer(std::move(surface)));
+  return WTF::wrapUnique(new ImageBuffer(std::move(surface)));
 }
 
 std::unique_ptr<ImageBuffer> ImageBuffer::create(
     const IntSize& size,
     OpacityMode opacityMode,
     ImageInitializationMode initializationMode,
     sk_sp<SkColorSpace> colorSpace) {
   std::unique_ptr<ImageBufferSurface> surface(
-      wrapUnique(new UnacceleratedImageBufferSurface(
+      WTF::wrapUnique(new UnacceleratedImageBufferSurface(
           size, opacityMode, initializationMode, std::move(colorSpace))));
   if (!surface->isValid())
     return nullptr;
-  return wrapUnique(new ImageBuffer(std::move(surface)));
+  return WTF::wrapUnique(new ImageBuffer(std::move(surface)));
 }
 
 ImageBuffer::ImageBuffer(std::unique_ptr<ImageBufferSurface> surface)
     : m_weakPtrFactory(this),
       m_snapshotState(InitialSnapshotState),
       m_surface(std::move(surface)),
       m_client(0),
       m_gpuMemoryUsage(0) {
   m_surface->setImageBuffer(this);
   updateGPUMemoryUsage();
@@ skipping 134 matching lines @@
     return false;
 
   DCHECK(textureImage->isTextureBacked());  // The isAccelerated() check above
                                             // should guarantee this.
   // Get the texture ID, flushing pending operations if needed.
   const GrGLTextureInfo* textureInfo = skia::GrBackendObjectToGrGLTextureInfo(
       textureImage->getTextureHandle(true));
   if (!textureInfo || !textureInfo->fID)
     return false;
 
-  std::unique_ptr<WebGraphicsContext3DProvider> provider = wrapUnique(
+  std::unique_ptr<WebGraphicsContext3DProvider> provider = WTF::wrapUnique(
       Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
   if (!provider || !provider->grContext())
     return false;
   gpu::gles2::GLES2Interface* sharedGL = provider->contextGL();
 
   gpu::Mailbox mailbox;
 
   // Contexts may be in a different share group. We must transfer the texture
   // through a mailbox first.
   sharedGL->GenMailboxCHROMIUM(mailbox.name);
@@ skipping 40 matching lines @@
   grContext->resetContext(kTextureBinding_GrGLBackendState);
 
   return true;
 }
 
 bool ImageBuffer::copyRenderingResultsFromDrawingBuffer(
     DrawingBuffer* drawingBuffer,
     SourceDrawingBuffer sourceBuffer) {
   if (!drawingBuffer || !m_surface->isAccelerated())
     return false;
-  std::unique_ptr<WebGraphicsContext3DProvider> provider = wrapUnique(
+  std::unique_ptr<WebGraphicsContext3DProvider> provider = WTF::wrapUnique(
       Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
   if (!provider)
     return false;
   gpu::gles2::GLES2Interface* gl = provider->contextGL();
   GLuint textureId = m_surface->getBackingTextureHandleForOverwrite();
   if (!textureId)
     return false;
 
   gl->Flush();
 
@@ skipping 180 matching lines @@
 }
 
 class UnacceleratedSurfaceFactory
     : public RecordingImageBufferFallbackSurfaceFactory {
  public:
   virtual std::unique_ptr<ImageBufferSurface> createSurface(
       const IntSize& size,
       OpacityMode opacityMode,
       sk_sp<SkColorSpace> colorSpace,
       SkColorType colorType) {
-    return wrapUnique(new UnacceleratedImageBufferSurface(
+    return WTF::wrapUnique(new UnacceleratedImageBufferSurface(
         size, opacityMode, InitializeImagePixels, std::move(colorSpace),
         colorType));
   }
 
   virtual ~UnacceleratedSurfaceFactory() {}
 };
 
 void ImageBuffer::disableAcceleration() {
   if (!isAccelerated())
     return;
 
   sk_sp<SkImage> image =
       m_surface->newImageSnapshot(PreferNoAcceleration, SnapshotReasonPaint);
   // Using a GPU-backed image with RecordingImageBufferSurface
   // will fail at playback time.
   image = image->makeNonTextureImage();
 
   // Create and configure a recording (unaccelerated) surface.
   std::unique_ptr<RecordingImageBufferFallbackSurfaceFactory> surfaceFactory =
-      makeUnique<UnacceleratedSurfaceFactory>();
+      WTF::makeUnique<UnacceleratedSurfaceFactory>();
   std::unique_ptr<ImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           m_surface->size(), std::move(surfaceFactory),
           m_surface->getOpacityMode(), m_surface->colorSpace()));
   surface->canvas()->drawImage(image.get(), 0, 0);
   surface->setImageBuffer(this);
   if (m_client)
     m_client->restoreCanvasMatrixClipStack(surface->canvas());
   m_surface = std::move(surface);
 
   didDisableAcceleration();
 }
@@ skipping 24 matching lines @@
   ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
 
   Vector<unsigned char> result;
   if (!encodeImage(mimeType, quality, &result))
     return "data:,";
 
   return "data:" + mimeType + ";base64," + base64Encode(result);
 }
 
 }  // namespace blink