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

third_party/WebKit/Source/modules/canvas2d/CanvasRenderingContext2DTest.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/canvas2d/CanvasRenderingContext2D.h"
 
 #include "core/dom/Document.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/ImageBitmap.h"
@@ skipping 236 matching lines @@
     return true;
   }  // otherwise overwrites are not tracked
 
   MOCK_METHOD0(willOverwriteCanvas, void());
 };
 
 //============================================================================
 
 #define TEST_OVERDRAW_SETUP(EXPECTED_OVERDRAWS)                              \
   std::unique_ptr<MockImageBufferSurfaceForOverwriteTesting> mockSurface =   \
-      wrapUnique(new MockImageBufferSurfaceForOverwriteTesting(              \
+      WTF::wrapUnique(new MockImageBufferSurfaceForOverwriteTesting(         \
           IntSize(10, 10), NonOpaque));                                      \
   MockImageBufferSurfaceForOverwriteTesting* surfacePtr = mockSurface.get(); \
   canvasElement().createImageBufferUsingSurfaceForTesting(                   \
       std::move(mockSurface));                                               \
   EXPECT_CALL(*surfacePtr, willOverwriteCanvas()).Times(EXPECTED_OVERDRAWS); \
   context2d()->save();
 
 #define TEST_OVERDRAW_FINALIZE \
   context2d()->restore();      \
   Mock::VerifyAndClearExpectations(surfacePtr);
@@ skipping 32 matching lines @@
     TEST_OVERDRAW_FINALIZE                                              \
   } while (0)
 
 //============================================================================
 
 class MockSurfaceFactory : public RecordingImageBufferFallbackSurfaceFactory {
  public:
   enum FallbackExpectation { ExpectFallback, ExpectNoFallback };
   static std::unique_ptr<MockSurfaceFactory> create(
       FallbackExpectation expectation) {
-    return wrapUnique(new MockSurfaceFactory(expectation));
+    return WTF::wrapUnique(new MockSurfaceFactory(expectation));
   }
 
   std::unique_ptr<ImageBufferSurface> createSurface(
       const IntSize& size,
       OpacityMode mode,
       sk_sp<SkColorSpace> colorSpace,
       SkColorType colorType) override {
     EXPECT_EQ(ExpectFallback, m_expectation);
     m_didFallback = true;
-    return wrapUnique(new UnacceleratedImageBufferSurface(
+    return WTF::wrapUnique(new UnacceleratedImageBufferSurface(
         size, mode, InitializeImagePixels, colorSpace, colorType));
   }
 
   ~MockSurfaceFactory() override {
     if (m_expectation == ExpectFallback) {
       EXPECT_TRUE(m_didFallback);
     }
   }
 
  private:
@@ skipping 185 matching lines @@
                   fillRect(0, 0, 5, 5));
   TEST_OVERDRAW_2(0, setGlobalCompositeOperation(String("source-over")),
                   fillRect(0, 0, 5, 5));
   TEST_OVERDRAW_2(0, setGlobalCompositeOperation(String("source-in")),
                   fillRect(0, 0, 5, 5));
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionByDefault) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionUnderOverdrawLimit) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->setGlobalAlpha(0.5f);  // To prevent overdraw optimization
   for (int i = 0;
        i < ExpensiveCanvasHeuristicParameters::ExpensiveOverdrawThreshold - 1;
        i++) {
     context2d()->fillRect(0, 0, 10, 10);
   }
 
   EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionOverOverdrawLimit) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->setGlobalAlpha(0.5f);  // To prevent overdraw optimization
   for (int i = 0;
        i < ExpensiveCanvasHeuristicParameters::ExpensiveOverdrawThreshold;
        i++) {
     context2d()->fillRect(0, 0, 10, 10);
   }
 
   EXPECT_TRUE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionUnderImageSizeRatioLimit) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   NonThrowableExceptionState exceptionState;
   Element* sourceCanvasElement =
       document().createElement("canvas", exceptionState);
   EXPECT_FALSE(exceptionState.hadException());
   HTMLCanvasElement* sourceCanvas =
       static_cast<HTMLCanvasElement*>(sourceCanvasElement);
   IntSize sourceSize(
       10, 10 * ExpensiveCanvasHeuristicParameters::ExpensiveImageSizeRatio);
   std::unique_ptr<UnacceleratedImageBufferSurface> sourceSurface =
-      makeUnique<UnacceleratedImageBufferSurface>(sourceSize, NonOpaque);
+      WTF::makeUnique<UnacceleratedImageBufferSurface>(sourceSize, NonOpaque);
   sourceCanvas->createImageBufferUsingSurfaceForTesting(
       std::move(sourceSurface));
 
   const ImageBitmapOptions defaultOptions;
   Optional<IntRect> cropRect = IntRect(IntPoint(0, 0), sourceSize);
   // Go through an ImageBitmap to avoid triggering a display list fallback
   ImageBitmap* sourceImageBitmap =
       ImageBitmap::create(sourceCanvas, cropRect, defaultOptions);
 
   context2d()->drawImage(canvasElement().getExecutionContext(),
                          sourceImageBitmap, 0, 0, 1, 1, 0, 0, 1, 1,
                          exceptionState);
   EXPECT_FALSE(exceptionState.hadException());
 
   EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionOverImageSizeRatioLimit) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   NonThrowableExceptionState exceptionState;
   Element* sourceCanvasElement =
       document().createElement("canvas", exceptionState);
   EXPECT_FALSE(exceptionState.hadException());
   HTMLCanvasElement* sourceCanvas =
       static_cast<HTMLCanvasElement*>(sourceCanvasElement);
   IntSize sourceSize(
       10, 10 * ExpensiveCanvasHeuristicParameters::ExpensiveImageSizeRatio + 1);
   std::unique_ptr<UnacceleratedImageBufferSurface> sourceSurface =
-      makeUnique<UnacceleratedImageBufferSurface>(sourceSize, NonOpaque);
+      WTF::makeUnique<UnacceleratedImageBufferSurface>(sourceSize, NonOpaque);
   sourceCanvas->createImageBufferUsingSurfaceForTesting(
       std::move(sourceSurface));
 
   const ImageBitmapOptions defaultOptions;
   Optional<IntRect> cropRect = IntRect(IntPoint(0, 0), sourceSize);
   // Go through an ImageBitmap to avoid triggering a display list fallback
   ImageBitmap* sourceImageBitmap =
       ImageBitmap::create(sourceCanvas, cropRect, defaultOptions);
 
   context2d()->drawImage(canvasElement().getExecutionContext(),
                          sourceImageBitmap, 0, 0, 1, 1, 0, 0, 1, 1,
                          exceptionState);
   EXPECT_FALSE(exceptionState.hadException());
 
   EXPECT_TRUE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        NoLayerPromotionUnderExpensivePathPointCount) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->beginPath();
   context2d()->moveTo(7, 5);
   for (int i = 1;
        i < ExpensiveCanvasHeuristicParameters::ExpensivePathPointCount - 1;
        i++) {
     float angleRad =
         twoPiFloat * i /
         (ExpensiveCanvasHeuristicParameters::ExpensivePathPointCount - 1);
     context2d()->lineTo(5 + 2 * cos(angleRad), 5 + 2 * sin(angleRad));
   }
   context2d()->fill();
 
   EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        LayerPromotionOverExpensivePathPointCount) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->beginPath();
   context2d()->moveTo(7, 5);
   for (int i = 1;
        i < ExpensiveCanvasHeuristicParameters::ExpensivePathPointCount + 1;
        i++) {
     float angleRad =
         twoPiFloat * i /
         (ExpensiveCanvasHeuristicParameters::ExpensivePathPointCount + 1);
     context2d()->lineTo(5 + 2 * cos(angleRad), 5 + 2 * sin(angleRad));
   }
   context2d()->fill();
 
   EXPECT_TRUE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionWhenPathIsConcave) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->beginPath();
   context2d()->moveTo(1, 1);
   context2d()->lineTo(5, 5);
   context2d()->lineTo(9, 1);
   context2d()->lineTo(5, 9);
   context2d()->fill();
 
   if (ExpensiveCanvasHeuristicParameters::ConcavePathsAreExpensive) {
     EXPECT_TRUE(canvasElement().shouldBeDirectComposited());
   } else {
     EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
   }
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionWithRectangleClip) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->beginPath();
   context2d()->rect(1, 1, 2, 2);
   context2d()->clip();
   context2d()->fillRect(0, 0, 4, 4);
 
   EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionWithComplexClip) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->beginPath();
   context2d()->moveTo(1, 1);
   context2d()->lineTo(5, 5);
   context2d()->lineTo(9, 1);
   context2d()->lineTo(5, 9);
   context2d()->clip();
   context2d()->fillRect(0, 0, 4, 4);
 
   if (ExpensiveCanvasHeuristicParameters::ComplexClipsAreExpensive) {
     EXPECT_TRUE(canvasElement().shouldBeDirectComposited());
   } else {
     EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
   }
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionWithBlurredShadow) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->setShadowColor(String("red"));
   context2d()->setShadowBlur(1.0f);
   context2d()->fillRect(1, 1, 1, 1);
 
   if (ExpensiveCanvasHeuristicParameters::BlurredShadowsAreExpensive) {
     EXPECT_TRUE(canvasElement().shouldBeDirectComposited());
   } else {
     EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
   }
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionWithSharpShadow) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->setShadowColor(String("red"));
   context2d()->setShadowOffsetX(1.0f);
   context2d()->fillRect(1, 1, 1, 1);
 
   EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoFallbackWithSmallState) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->fillRect(0, 0, 1, 1);  // To have a non-empty dirty rect
   for (int i = 0;
        i < ExpensiveCanvasHeuristicParameters::ExpensiveRecordingStackDepth - 1;
        ++i) {
     context2d()->save();
     context2d()->translate(1.0f, 0.0f);
   }
   canvasElement().doDeferredPaintInvalidation();  // To close the current frame
 }
 
 TEST_F(CanvasRenderingContext2DTest, FallbackWithLargeState) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->fillRect(0, 0, 1, 1);  // To have a non-empty dirty rect
   for (int i = 0;
        i < ExpensiveCanvasHeuristicParameters::ExpensiveRecordingStackDepth;
        ++i) {
     context2d()->save();
     context2d()->translate(1.0f, 0.0f);
   }
   canvasElement().doDeferredPaintInvalidation();  // To close the current frame
 }
 
 TEST_F(CanvasRenderingContext2DTest, OpaqueDisplayListFallsBackForText) {
   // Verify that drawing text to an opaque canvas, which is expected to
   // render with subpixel text anti-aliasing, results in falling out
   // of display list mode because the current diplay list implementation
   // does not support pixel geometry settings.
   // See: crbug.com/583809
   createContext(Opaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectFallback),
           Opaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->fillText("Text", 0, 5);
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        NonOpaqueDisplayListDoesNotFallBackForText) {
   createContext(NonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      wrapUnique(new RecordingImageBufferSurface(
+      WTF::wrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback),
           NonOpaque, nullptr));
   canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
   context2d()->fillText("Text", 0, 5);
 }
 
 TEST_F(CanvasRenderingContext2DTest, ImageResourceLifetime) {
   NonThrowableExceptionState nonThrowableExceptionState;
@@ skipping 21 matching lines @@
   imageSource.setImageBitmap(imageBitmapDerived);
   context->drawImage(canvas->getExecutionContext(), imageSource, 0, 0,
                      exceptionState);
 }
 
 TEST_F(CanvasRenderingContext2DTest, GPUMemoryUpdateForAcceleratedCanvas) {
   createContext(NonOpaque);
 
   std::unique_ptr<FakeAcceleratedImageBufferSurfaceForTesting>
       fakeAccelerateSurface =
-          wrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
+          WTF::wrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
               IntSize(10, 10), NonOpaque));
   FakeAcceleratedImageBufferSurfaceForTesting* fakeAccelerateSurfacePtr =
       fakeAccelerateSurface.get();
   canvasElement().createImageBufferUsingSurfaceForTesting(
       std::move(fakeAccelerateSurface));
   // 800 = 10 * 10 * 4 * 2 where 10*10 is canvas size, 4 is num of bytes per
   // pixel per buffer, and 2 is an estimate of num of gpu buffers required
   EXPECT_EQ(800, getCurrentGPUMemoryUsage());
   EXPECT_EQ(800, getGlobalGPUMemoryUsage());
   EXPECT_EQ(1u, getGlobalAcceleratedImageBufferCount());
 
   // Switching accelerated mode to non-accelerated mode
   fakeAccelerateSurfacePtr->setIsAccelerated(false);
   canvasElement().buffer()->updateGPUMemoryUsage();
   EXPECT_EQ(0, getCurrentGPUMemoryUsage());
   EXPECT_EQ(0, getGlobalGPUMemoryUsage());
   EXPECT_EQ(0u, getGlobalAcceleratedImageBufferCount());
 
   // Switching non-accelerated mode to accelerated mode
   fakeAccelerateSurfacePtr->setIsAccelerated(true);
   canvasElement().buffer()->updateGPUMemoryUsage();
   EXPECT_EQ(800, getCurrentGPUMemoryUsage());
   EXPECT_EQ(800, getGlobalGPUMemoryUsage());
   EXPECT_EQ(1u, getGlobalAcceleratedImageBufferCount());
 
   // Creating a different accelerated image buffer
   std::unique_ptr<FakeAcceleratedImageBufferSurfaceForTesting>
       fakeAccelerateSurface2 =
-          wrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
+          WTF::wrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
               IntSize(10, 5), NonOpaque));
   std::unique_ptr<ImageBuffer> imageBuffer2 =
       ImageBuffer::create(std::move(fakeAccelerateSurface2));
   EXPECT_EQ(800, getCurrentGPUMemoryUsage());
   EXPECT_EQ(1200, getGlobalGPUMemoryUsage());
   EXPECT_EQ(2u, getGlobalAcceleratedImageBufferCount());
 
   // Tear down the first image buffer that resides in current canvas element
   canvasElement().setSize(IntSize(20, 20));
   Mock::VerifyAndClearExpectations(fakeAccelerateSurfacePtr);
@@ skipping 168 matching lines @@
   RuntimeEnabledFeatures::setCanvas2dFixedRenderingModeEnabled(
       savedFixedRenderingMode);
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        IsAccelerationOptimalForCanvasContentHeuristic) {
   createContext(NonOpaque);
 
   std::unique_ptr<FakeAcceleratedImageBufferSurfaceForTesting>
       fakeAccelerateSurface =
-          wrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
+          WTF::wrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
               IntSize(10, 10), NonOpaque));
   canvasElement().createImageBufferUsingSurfaceForTesting(
       std::move(fakeAccelerateSurface));
 
   NonThrowableExceptionState exceptionState;
 
   CanvasRenderingContext2D* context = context2d();
   EXPECT_TRUE(context->isAccelerationOptimalForCanvasContent());
 
   context->fillRect(10, 10, 100, 100);
@@ skipping 14 matching lines @@
     context->strokeText("Text", 10, 10, 1);  // faster with no acceleration
   }
   EXPECT_FALSE(context->isAccelerationOptimalForCanvasContent());
 }
 
 TEST_F(CanvasRenderingContext2DTest, DisableAcceleration) {
   createContext(NonOpaque);
 
   std::unique_ptr<FakeAcceleratedImageBufferSurfaceForTesting>
       fakeAccelerateSurface =
-          wrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
+          WTF::wrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
               IntSize(10, 10), NonOpaque));
   canvasElement().createImageBufferUsingSurfaceForTesting(
       std::move(fakeAccelerateSurface));
   CanvasRenderingContext2D* context = context2d();
 
   // 800 = 10 * 10 * 4 * 2 where 10*10 is canvas size, 4 is num of bytes per
   // pixel per buffer, and 2 is an estimate of num of gpu buffers required
   EXPECT_EQ(800, getCurrentGPUMemoryUsage());
   EXPECT_EQ(800, getGlobalGPUMemoryUsage());
   EXPECT_EQ(1u, getGlobalAcceleratedImageBufferCount());
 
   context->fillRect(10, 10, 100, 100);
   EXPECT_TRUE(canvasElement().buffer()->isAccelerated());
 
   canvasElement().buffer()->disableAcceleration();
   EXPECT_FALSE(canvasElement().buffer()->isAccelerated());
 
   context->fillRect(10, 10, 100, 100);
 
   EXPECT_EQ(0, getCurrentGPUMemoryUsage());
   EXPECT_EQ(0, getGlobalGPUMemoryUsage());
   EXPECT_EQ(0u, getGlobalAcceleratedImageBufferCount());
 }
 
 }  // namespace blink