Remove OwnPtr::release() calls in modules/ (part 3).

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 525 matching lines @@
     ContextProviderCreationInfo(Platform::ContextAttributes contextAttributes, Platform::GraphicsInfo glInfo, ScriptState* scriptState)
     {
         m_contextAttributes = contextAttributes;
         m_glInfo = glInfo;
         m_scriptState = scriptState;
     }
     Platform::ContextAttributes contextAttributes() { return m_contextAttributes; }
     Platform::GraphicsInfo glInfo() { return m_glInfo; }
     ScriptState* scriptState() { return m_scriptState; }
     void setContextProvider(PassOwnPtr<WebGraphicsContext3DProvider> provider) { m_provider = std::move(provider); }
-    PassOwnPtr<WebGraphicsContext3DProvider> releaseContextProvider() { return m_provider.release(); }
+    PassOwnPtr<WebGraphicsContext3DProvider> releaseContextProvider() { return std::move(m_provider); }
 private:
     Platform::ContextAttributes m_contextAttributes;
     Platform::GraphicsInfo m_glInfo;
     ScriptState* m_scriptState;
     OwnPtr<WebGraphicsContext3DProvider> m_provider;
 };
 
 void WebGLRenderingContextBase::createContextProviderOnMainThread(ContextProviderCreationInfo* creationInfo, WaitableEvent* waitableEvent)
 {
     ASSERT(isMainThread());
     Platform::GraphicsInfo glInfo = creationInfo->glInfo();
     OwnPtr<WebGraphicsContext3DProvider> provider = adoptPtr(Platform::current()->createOffscreenGraphicsContext3DProvider(
         creationInfo->contextAttributes(), creationInfo->scriptState()->getExecutionContext()->url(), 0, &glInfo, Platform::DoNotBindToCurrentThread));
-    creationInfo->setContextProvider(provider.release());
+    creationInfo->setContextProvider(std::move(provider));
     waitableEvent->signal();
 }
 
 PassOwnPtr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createContextProviderOnWorkerThread(Platform::ContextAttributes contextAttributes, Platform::GraphicsInfo glInfo, ScriptState* scriptState)
 {
     WaitableEvent waitableEvent;
     OwnPtr<ContextProviderCreationInfo> creationInfo = adoptPtr(new ContextProviderCreationInfo(contextAttributes, glInfo, scriptState));
     WebTaskRunner* taskRunner = Platform::current()->mainThread()->getWebTaskRunner();
     taskRunner->postTask(BLINK_FROM_HERE, threadSafeBind(&createContextProviderOnMainThread, AllowCrossThreadAccess(creationInfo.get()), AllowCrossThreadAccess(&waitableEvent)));
     waitableEvent.wait();
@@ skipping 23 matching lines @@
         if (canvas)
             canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, extractWebGLContextCreationError(glInfo)));
         return nullptr;
     }
     gpu::gles2::GLES2Interface* gl = contextProvider->contextGL();
     if (!String(gl->GetString(GL_EXTENSIONS)).contains("GL_OES_packed_depth_stencil")) {
         if (canvas)
             canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "OES_packed_depth_stencil support is required."));
         return nullptr;
     }
-    return contextProvider.release();
+    return contextProvider;
 }
 
 PassOwnPtr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createWebGraphicsContext3DProvider(HTMLCanvasElement* canvas, WebGLContextAttributes attributes, unsigned webGLVersion)
 {
     Document& document = canvas->document();
     LocalFrame* frame = document.frame();
     if (!frame) {
         canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Web page was not allowed to create a WebGL context."));
         return nullptr;
     }
@@ skipping 3643 matching lines @@
     // Otherwise, it will fall back to the normal SW path.
     if (GL_TEXTURE_2D == target) {
         if (Extensions3DUtil::canUseCopyTextureCHROMIUM(target, internalformat, type, level)
             && 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.
         OwnPtr<ImageBufferSurface> surface = adoptPtr(new AcceleratedImageBufferSurface(IntSize(video->videoWidth(), video->videoHeight())));
         if (surface->isValid()) {
-            OwnPtr<ImageBuffer> imageBuffer(ImageBuffer::create(surface.release()));
+            OwnPtr<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(imageBuffer->canvas(), IntRect(0, 0, video->videoWidth(), video->videoHeight()), nullptr);
 
                 // This is a straight GPU-GPU copy, any necessary color space conversion was handled in the paintCurrentFrameInContext() call.
                 if (imageBuffer->copyToPlatformTexture(contextGL(), texture->object(), internalformat, type,
                     level, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
                     return;
@@ skipping 1769 matching lines @@
         m_drawingBuffer.clear();
     }
 
     Platform::ContextAttributes attributes = toPlatformContextAttributes(m_requestedAttributes, version());
     Platform::GraphicsInfo glInfo;
     OwnPtr<WebGraphicsContext3DProvider> contextProvider = adoptPtr(Platform::current()->createOffscreenGraphicsContext3DProvider(
         attributes, canvas()->document().topDocument().url(), 0, &glInfo, Platform::BindToCurrentThread));
     RefPtr<DrawingBuffer> buffer;
     if (contextProvider) {
         // Construct a new drawing buffer with the new GL context.
-        buffer = createDrawingBuffer(contextProvider.release());
+        buffer = createDrawingBuffer(std::move(contextProvider));
         // If DrawingBuffer::create() fails to allocate a fbo, |drawingBuffer| is set to null.
     }
     if (!buffer) {
         if (m_contextLostMode == RealLostContext) {
             m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts, BLINK_FROM_HERE);
         } else {
             // This likely shouldn't happen but is the best way to report it to the WebGL app.
             synthesizeGLError(GL_INVALID_OPERATION, "", "error restoring context");
         }
         return;
@@ skipping 38 matching lines @@
         if (buf->size() != size)
             continue;
         bubbleToFront(i);
         return buf;
     }
 
     OwnPtr<ImageBuffer> temp(ImageBuffer::create(size));
     if (!temp)
         return nullptr;
     i = std::min(m_capacity - 1, i);
-    m_buffers[i] = temp.release();
+    m_buffers[i] = std::move(temp);
 
     ImageBuffer* buf = m_buffers[i].get();
     bubbleToFront(i);
     return buf;
 }
 
 void WebGLRenderingContextBase::LRUImageBufferCache::bubbleToFront(int idx)
 {
     for (int i = idx; i > 0; --i)
         m_buffers[i].swap(m_buffers[i-1]);
@@ skipping 256 matching lines @@
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 void WebGLRenderingContextBase::restoreUnpackParameters()
 {
     if (m_unpackAlignment != 1)
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 } // namespace blink