Revert "Remove OwnPtr from Blink."

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

 /*
  * Copyright (C) 2012 Google 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 27 matching lines @@
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebGraphicsContext3DProvider.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebTraceLocation.h"
 #include "skia/ext/texture_handle.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/gl/GrGLTypes.h"
-#include "wtf/PtrUtil.h"
-#include <memory>
 
 namespace {
 enum {
     InvalidMailboxIndex = -1,
     MaxCanvasAnimationBacklog = 2, // Make sure the the GPU is never more than two animation frames behind.
 };
 } // namespace
 
 namespace blink {
 
@@ skipping 23 matching lines @@
         } else {
             surface->getCanvas()->clear(SK_ColorTRANSPARENT);
         }
     }
     return fromSkSp(surface);
 }
 
 PassRefPtr<Canvas2DLayerBridge> Canvas2DLayerBridge::create(const IntSize& size, int msaaSampleCount, OpacityMode opacityMode, AccelerationMode accelerationMode)
 {
     TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation", TRACE_EVENT_SCOPE_GLOBAL);
-    std::unique_ptr<WebGraphicsContext3DProvider> contextProvider = wrapUnique(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
+    OwnPtr<WebGraphicsContext3DProvider> contextProvider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
     if (!contextProvider)
         return nullptr;
     RefPtr<Canvas2DLayerBridge> layerBridge;
     layerBridge = adoptRef(new Canvas2DLayerBridge(std::move(contextProvider), size, msaaSampleCount, opacityMode, accelerationMode));
     return layerBridge.release();
 }
 
-Canvas2DLayerBridge::Canvas2DLayerBridge(std::unique_ptr<WebGraphicsContext3DProvider> contextProvider, const IntSize& size, int msaaSampleCount, OpacityMode opacityMode, AccelerationMode accelerationMode)
+Canvas2DLayerBridge::Canvas2DLayerBridge(PassOwnPtr<WebGraphicsContext3DProvider> contextProvider, const IntSize& size, int msaaSampleCount, OpacityMode opacityMode, AccelerationMode accelerationMode)
     : m_contextProvider(std::move(contextProvider))
-    , m_logger(wrapUnique(new Logger))
+    , m_logger(adoptPtr(new Logger))
     , m_weakPtrFactory(this)
     , m_imageBuffer(0)
     , m_msaaSampleCount(msaaSampleCount)
     , m_bytesAllocated(0)
     , m_haveRecordedDrawCommands(false)
     , m_destructionInProgress(false)
     , m_filterQuality(kLow_SkFilterQuality)
     , m_isHidden(false)
     , m_isDeferralEnabled(true)
     , m_isRegisteredTaskObserver(false)
@@ skipping 18 matching lines @@
     clearCHROMIUMImageCache();
 #endif // USE_IOSURFACE_FOR_2D_CANVAS
 
     m_layer.reset();
     DCHECK_EQ(0u, m_mailboxes.size());
 }
 
 void Canvas2DLayerBridge::startRecording()
 {
     DCHECK(m_isDeferralEnabled);
-    m_recorder = wrapUnique(new SkPictureRecorder);
+    m_recorder = adoptPtr(new SkPictureRecorder);
     m_recorder->beginRecording(m_size.width(), m_size.height(), nullptr);
     if (m_imageBuffer) {
         m_imageBuffer->resetCanvas(m_recorder->getRecordingCanvas());
     }
     m_recordingPixelCount = 0;
 }
 
-void Canvas2DLayerBridge::setLoggerForTesting(std::unique_ptr<Logger> logger)
+void Canvas2DLayerBridge::setLoggerForTesting(PassOwnPtr<Logger> logger)
 {
     m_logger = std::move(logger);
 }
 
 bool Canvas2DLayerBridge::shouldAccelerate(AccelerationHint hint) const
 {
     bool accelerate;
     if (m_softwareRenderingWhileHidden)
         accelerate = false;
     else if (m_accelerationMode == ForceAccelerationForTesting)
@@ skipping 318 matching lines @@
         wantAcceleration = false;
         m_softwareRenderingWhileHidden = true;
     }
 
     m_surface = createSkSurface(wantAcceleration ? m_contextProvider->grContext() : nullptr, m_size, m_msaaSampleCount, m_opacityMode, &surfaceIsAccelerated);
 
     if (!m_surface)
         reportSurfaceCreationFailure();
 
     if (m_surface && surfaceIsAccelerated && !m_layer) {
-        m_layer = wrapUnique(Platform::current()->compositorSupport()->createExternalTextureLayer(this));
+        m_layer = adoptPtr(Platform::current()->compositorSupport()->createExternalTextureLayer(this));
         m_layer->setOpaque(m_opacityMode == Opaque);
         m_layer->setBlendBackgroundColor(m_opacityMode != Opaque);
         GraphicsLayer::registerContentsLayer(m_layer->layer());
         m_layer->setNearestNeighbor(m_filterQuality == kNone_SkFilterQuality);
     }
 
     if (m_surface && isHibernating()) {
         if (surfaceIsAccelerated) {
             m_logger->reportHibernationEvent(HibernationEndedNormally);
         } else {
@@ skipping 243 matching lines @@
 
 bool Canvas2DLayerBridge::restoreSurface()
 {
     DCHECK(!m_destructionInProgress);
     if (m_destructionInProgress)
         return false;
     DCHECK(isAccelerated() && !m_surface);
 
     gpu::gles2::GLES2Interface* sharedGL = nullptr;
     m_layer->clearTexture();
-    m_contextProvider = wrapUnique(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
+    m_contextProvider = adoptPtr(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
     if (m_contextProvider)
         sharedGL = m_contextProvider->contextGL();
 
     if (sharedGL && sharedGL->GetGraphicsResetStatusKHR() == GL_NO_ERROR) {
         GrContext* grCtx = m_contextProvider->grContext();
         bool surfaceIsAccelerated;
         RefPtr<SkSurface> surface(createSkSurface(grCtx, m_size, m_msaaSampleCount, m_opacityMode, &surfaceIsAccelerated));
 
         if (!m_surface)
             reportSurfaceCreationFailure();
@@ skipping 232 matching lines @@
 #endif // USE_IOSURFACE_FOR_2D_CANVAS
 }
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(HibernationEvent event)
 {
     DEFINE_STATIC_LOCAL(EnumerationHistogram, hibernationHistogram, ("Canvas.HibernationEvents", HibernationEventCount));
     hibernationHistogram.count(event);
 }
 
 } // namespace blink