Remove OwnPtr from Blink.

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

 // Copyright 2015 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/webgl/WebGL2RenderingContextBase.h"
 
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "modules/webgl/WebGLActiveInfo.h"
 #include "modules/webgl/WebGLBuffer.h"
 #include "modules/webgl/WebGLFenceSync.h"
 #include "modules/webgl/WebGLFramebuffer.h"
 #include "modules/webgl/WebGLProgram.h"
 #include "modules/webgl/WebGLQuery.h"
 #include "modules/webgl/WebGLRenderbuffer.h"
 #include "modules/webgl/WebGLSampler.h"
 #include "modules/webgl/WebGLSync.h"
 #include "modules/webgl/WebGLTexture.h"
 #include "modules/webgl/WebGLTransformFeedback.h"
 #include "modules/webgl/WebGLUniformLocation.h"
 #include "modules/webgl/WebGLVertexArrayObject.h"
 #include "platform/CheckedInt.h"
 #include "public/platform/WebGraphicsContext3DProvider.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/PassOwnPtr.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/text/WTFString.h"
+#include <memory>
 
 using WTF::String;
 
 namespace blink {
 
 namespace {
 
 GLsync syncObjectOrZero(const WebGLSync* object)
 {
     return object ? object->object() : nullptr;
@@ skipping 65 matching lines @@
     GL_COMPRESSED_RG11_EAC,
     GL_COMPRESSED_SIGNED_RG11_EAC,
     GL_COMPRESSED_RGB8_ETC2,
     GL_COMPRESSED_SRGB8_ETC2,
     GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
     GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
     GL_COMPRESSED_RGBA8_ETC2_EAC,
     GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
 };
 
-WebGL2RenderingContextBase::WebGL2RenderingContextBase(HTMLCanvasElement* passedCanvas, PassOwnPtr<WebGraphicsContext3DProvider> contextProvider, const WebGLContextAttributes& requestedAttributes)
+WebGL2RenderingContextBase::WebGL2RenderingContextBase(HTMLCanvasElement* passedCanvas, std::unique_ptr<WebGraphicsContext3DProvider> contextProvider, const WebGLContextAttributes& requestedAttributes)
     : WebGLRenderingContextBase(passedCanvas, std::move(contextProvider), requestedAttributes)
 {
     m_supportedInternalFormatsStorage.insert(kSupportedInternalFormatsStorage, kSupportedInternalFormatsStorage + WTF_ARRAY_LENGTH(kSupportedInternalFormatsStorage));
     m_supportedInternalFormatsStorage.insert(kCompressedTextureFormatsETC2EAC, kCompressedTextureFormatsETC2EAC + WTF_ARRAY_LENGTH(kCompressedTextureFormatsETC2EAC));
     m_compressedTextureFormatsETC2EAC.insert(kCompressedTextureFormatsETC2EAC, kCompressedTextureFormatsETC2EAC + WTF_ARRAY_LENGTH(kCompressedTextureFormatsETC2EAC));
     m_compressedTextureFormats.append(kCompressedTextureFormatsETC2EAC, WTF_ARRAY_LENGTH(kCompressedTextureFormatsETC2EAC));
 }
 
 WebGL2RenderingContextBase::~WebGL2RenderingContextBase()
 {
@@ skipping 270 matching lines @@
         floatType = true;
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getInternalformatParameter", "invalid internalformat");
         return ScriptValue::createNull(scriptState);
     }
 
     switch (pname) {
     case GL_SAMPLES:
         {
-            OwnPtr<GLint[]> values;
+            std::unique_ptr<GLint[]> values;
             GLint length = -1;
             if (!floatType) {
                 contextGL()->GetInternalformativ(target, internalformat, GL_NUM_SAMPLE_COUNTS, 1, &length);
                 if (length <= 0)
                     return WebGLAny(scriptState, DOMInt32Array::create(0));
 
-                values = adoptArrayPtr(new GLint[length]);
+                values = wrapArrayUnique(new GLint[length]);
                 for (GLint ii = 0; ii < length; ++ii)
                     values[ii] = 0;
                 contextGL()->GetInternalformativ(target, internalformat, GL_SAMPLES, length, values.get());
             } else {
                 length = 1;
-                values = adoptArrayPtr(new GLint[1]);
+                values = wrapArrayUnique(new GLint[1]);
                 values[0] = 1;
             }
             return WebGLAny(scriptState, DOMInt32Array::create(values.get(), length));
         }
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getInternalformatParameter", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
 }
 
@@ skipping 1715 matching lines @@
     if (index >= static_cast<GLuint>(maxIndex)) {
         synthesizeGLError(GL_INVALID_VALUE, "getTransformFeedbackVarying", "invalid index");
         return nullptr;
     }
 
     GLint maxNameLength = -1;
     contextGL()->GetProgramiv(objectOrZero(program), GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, &maxNameLength);
     if (maxNameLength <= 0) {
         return nullptr;
     }
-    OwnPtr<GLchar[]> name = adoptArrayPtr(new GLchar[maxNameLength]);
+    std::unique_ptr<GLchar[]> name = wrapArrayUnique(new GLchar[maxNameLength]);
     GLsizei length = 0;
     GLsizei size = 0;
     GLenum type = 0;
     contextGL()->GetTransformFeedbackVarying(objectOrZero(program), index, maxNameLength, &length, &size, &type, name.get());
 
     if (length == 0 || size == 0 || type == 0) {
         return nullptr;
     }
 
     return WebGLActiveInfo::create(String(name.get(), length), type, size);
@@ skipping 324 matching lines @@
     if (!validateUniformBlockIndex("getActiveUniformBlockName", program, uniformBlockIndex))
         return String();
 
     GLint maxNameLength = -1;
     contextGL()->GetProgramiv(objectOrZero(program), GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, &maxNameLength);
     if (maxNameLength <= 0) {
         // This state indicates that there are no active uniform blocks
         synthesizeGLError(GL_INVALID_VALUE, "getActiveUniformBlockName", "invalid uniform block index");
         return String();
     }
-    OwnPtr<GLchar[]> name = adoptArrayPtr(new GLchar[maxNameLength]);
+    std::unique_ptr<GLchar[]> name = wrapArrayUnique(new GLchar[maxNameLength]);
 
     GLsizei length = 0;
     contextGL()->GetActiveUniformBlockName(objectOrZero(program), uniformBlockIndex, maxNameLength, &length, name.get());
 
     return String(name.get(), length);
 }
 
 void WebGL2RenderingContextBase::uniformBlockBinding(WebGLProgram* program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
     if (isContextLost() || !validateWebGLObject("uniformBlockBinding", program))
@@ skipping 946 matching lines @@
     params.skipPixels = m_unpackSkipPixels;
     params.skipRows = m_unpackSkipRows;
     if (dimension == Tex3D) {
         params.imageHeight = m_unpackImageHeight;
         params.skipImages = m_unpackSkipImages;
     }
     return params;
 }
 
 } // namespace blink