Changed GL enums from GraphicsContext3D to standard versions (Take 2)

Source/platform/graphics/GraphicsContext3D.cpp

 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2010 Mozilla Corporation. 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.
@@ skipping 411 matching lines @@
 DELEGATE_TO_WEBCONTEXT_1R(isFramebuffer, Platform3DObject, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_1R(isProgram, Platform3DObject, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_1R(isRenderbuffer, Platform3DObject, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_1R(isShader, Platform3DObject, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_1R(isTexture, Platform3DObject, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_1(lineWidth, GC3Dfloat)
 DELEGATE_TO_WEBCONTEXT_1(linkProgram, Platform3DObject)
 
 void GraphicsContext3D::pixelStorei(GC3Denum pname, GC3Dint param)
 {
-    if (pname == PACK_ALIGNMENT)
+    if (pname == GL_PACK_ALIGNMENT)
         m_packAlignment = param;
     m_impl->pixelStorei(pname, param);
 }
 
 DELEGATE_TO_WEBCONTEXT_2(polygonOffset, GC3Dfloat, GC3Dfloat)
 
 DELEGATE_TO_WEBCONTEXT_7(readPixels, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Denum, GC3Denum, void*)
 
 DELEGATE_TO_WEBCONTEXT(releaseShaderCompiler)
 DELEGATE_TO_WEBCONTEXT_4(renderbufferStorage, GC3Denum, GC3Denum, GC3Dsizei, GC3Dsizei)
@@ skipping 84 matching lines @@
     getDrawingParameters(drawingBuffer, m_impl, &framebufferId, &width, &height);
 
     Checked<int, RecordOverflow> dataSize = 4;
     dataSize *= width;
     dataSize *= height;
     if (dataSize.hasOverflowed())
         return 0;
 
     RefPtr<Uint8ClampedArray> pixels = Uint8ClampedArray::createUninitialized(width * height * 4);
 
-    m_impl->bindFramebuffer(FRAMEBUFFER, framebufferId);
+    m_impl->bindFramebuffer(GL_FRAMEBUFFER, framebufferId);
     readBackFramebuffer(pixels->data(), width, height, ReadbackRGBA, AlphaDoNothing);
     flipVertically(pixels->data(), width, height);
 
     return pixels.release();
 }
 
 void GraphicsContext3D::readBackFramebuffer(unsigned char* pixels, int width, int height, ReadbackOrder readbackOrder, AlphaOp op)
 {
     if (m_packAlignment > 4)
-        m_impl->pixelStorei(PACK_ALIGNMENT, 1);
-    m_impl->readPixels(0, 0, width, height, RGBA, UNSIGNED_BYTE, pixels);
+        m_impl->pixelStorei(GL_PACK_ALIGNMENT, 1);
+    m_impl->readPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
     if (m_packAlignment > 4)
-        m_impl->pixelStorei(PACK_ALIGNMENT, m_packAlignment);
+        m_impl->pixelStorei(GL_PACK_ALIGNMENT, m_packAlignment);
 
     size_t bufferSize = 4 * width * height;
 
     if (readbackOrder == ReadbackSkia) {
 #if (SK_R32_SHIFT == 16) && !SK_B32_SHIFT
         // Swizzle red and blue channels to match SkBitmap's byte ordering.
         // TODO(kbr): expose GL_BGRA as extension.
         for (size_t i = 0; i < bufferSize; i += 4) {
             std::swap(pixels[i], pixels[i + 2]);
         }
@@ skipping 40 matching lines @@
     texImage2D(target, level, internalformat, width, height, border, format, type, 0);
     return true;
 }
 
 bool GraphicsContext3D::computeFormatAndTypeParameters(GC3Denum format,
                                                        GC3Denum type,
                                                        unsigned int* componentsPerPixel,
                                                        unsigned int* bytesPerComponent)
 {
     switch (format) {
-    case GraphicsContext3D::ALPHA:
-    case GraphicsContext3D::LUMINANCE:
-    case GraphicsContext3D::DEPTH_COMPONENT:
-    case GraphicsContext3D::DEPTH_STENCIL:
+    case GL_ALPHA:
+    case GL_LUMINANCE:
+    case GL_DEPTH_COMPONENT:
+    case GL_DEPTH_STENCIL_OES:
         *componentsPerPixel = 1;
         break;
-    case GraphicsContext3D::LUMINANCE_ALPHA:
+    case GL_LUMINANCE_ALPHA:
         *componentsPerPixel = 2;
         break;
-    case GraphicsContext3D::RGB:
+    case GL_RGB:
         *componentsPerPixel = 3;
         break;
-    case GraphicsContext3D::RGBA:
+    case GL_RGBA:
     case Extensions3D::BGRA_EXT: // GL_EXT_texture_format_BGRA8888
         *componentsPerPixel = 4;
         break;
     default:
         return false;
     }
     switch (type) {
-    case GraphicsContext3D::UNSIGNED_BYTE:
+    case GL_UNSIGNED_BYTE:
         *bytesPerComponent = sizeof(GC3Dubyte);
         break;
-    case GraphicsContext3D::UNSIGNED_SHORT:
+    case GL_UNSIGNED_SHORT:
         *bytesPerComponent = sizeof(GC3Dushort);
         break;
-    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:
-    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:
-    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:
+    case GL_UNSIGNED_SHORT_5_6_5:
+    case GL_UNSIGNED_SHORT_4_4_4_4:
+    case GL_UNSIGNED_SHORT_5_5_5_1:
         *componentsPerPixel = 1;
         *bytesPerComponent = sizeof(GC3Dushort);
         break;
-    case GraphicsContext3D::UNSIGNED_INT_24_8:
-    case GraphicsContext3D::UNSIGNED_INT:
+    case GL_UNSIGNED_INT_24_8_OES:
+    case GL_UNSIGNED_INT:
         *bytesPerComponent = sizeof(GC3Duint);
         break;
-    case GraphicsContext3D::FLOAT: // OES_texture_float
+    case GL_FLOAT: // OES_texture_float
         *bytesPerComponent = sizeof(GC3Dfloat);
         break;
-    case GraphicsContext3D::HALF_FLOAT_OES: // OES_texture_half_float
+    case GL_HALF_FLOAT_OES: // OES_texture_half_float
         *bytesPerComponent = sizeof(GC3Dhalffloat);
         break;
     default:
         return false;
     }
     return true;
 }
 
 GC3Denum GraphicsContext3D::computeImageSizeInBytes(GC3Denum format, GC3Denum type, GC3Dsizei width, GC3Dsizei height, GC3Dint alignment,
                                                     unsigned int* imageSizeInBytes, unsigned int* paddingInBytes)
 {
     ASSERT(imageSizeInBytes);
     ASSERT(alignment == 1 || alignment == 2 || alignment == 4 || alignment == 8);
     if (width < 0 || height < 0)
-        return GraphicsContext3D::INVALID_VALUE;
+        return GL_INVALID_VALUE;
     unsigned int bytesPerComponent, componentsPerPixel;
     if (!computeFormatAndTypeParameters(format, type, &bytesPerComponent, &componentsPerPixel))
-        return GraphicsContext3D::INVALID_ENUM;
+        return GL_INVALID_ENUM;
     if (!width || !height) {
         *imageSizeInBytes = 0;
         if (paddingInBytes)
             *paddingInBytes = 0;
-        return GraphicsContext3D::NO_ERROR;
+        return GL_NO_ERROR;
     }
     CheckedInt<uint32_t> checkedValue(bytesPerComponent * componentsPerPixel);
     checkedValue *=  width;
     if (!checkedValue.isValid())
-        return GraphicsContext3D::INVALID_VALUE;
+        return GL_INVALID_VALUE;
     unsigned int validRowSize = checkedValue.value();
     unsigned int padding = 0;
     unsigned int residual = validRowSize % alignment;
     if (residual) {
         padding = alignment - residual;
         checkedValue += padding;
     }
     // Last row needs no padding.
     checkedValue *= (height - 1);
     checkedValue += validRowSize;
     if (!checkedValue.isValid())
-        return GraphicsContext3D::INVALID_VALUE;
+        return GL_INVALID_VALUE;
     *imageSizeInBytes = checkedValue.value();
     if (paddingInBytes)
         *paddingInBytes = padding;
-    return GraphicsContext3D::NO_ERROR;
+    return GL_NO_ERROR;
 }
 
 GraphicsContext3D::ImageExtractor::ImageExtractor(Image* image, ImageHtmlDomSource imageHtmlDomSource, bool premultiplyAlpha, bool ignoreGammaAndColorProfile)
 {
     m_image = image;
     m_imageHtmlDomSource = imageHtmlDomSource;
     m_extractSucceeded = extractImage(premultiplyAlpha, ignoreGammaAndColorProfile);
 }
 
 GraphicsContext3D::ImageExtractor::~ImageExtractor()
@@ skipping 50 matching lines @@
         return false;
     m_imageSourceUnpackAlignment = 0;
     m_skiaImage->bitmap().lockPixels();
     m_imagePixelData = m_skiaImage->bitmap().getPixels();
     return true;
 }
 
 unsigned GraphicsContext3D::getClearBitsByFormat(GC3Denum format)
 {
     switch (format) {
-    case GraphicsContext3D::ALPHA:
-    case GraphicsContext3D::LUMINANCE:
-    case GraphicsContext3D::LUMINANCE_ALPHA:
-    case GraphicsContext3D::RGB:
-    case GraphicsContext3D::RGB565:
-    case GraphicsContext3D::RGBA:
-    case GraphicsContext3D::RGBA4:
-    case GraphicsContext3D::RGB5_A1:
-        return GraphicsContext3D::COLOR_BUFFER_BIT;
-    case GraphicsContext3D::DEPTH_COMPONENT16:
-    case GraphicsContext3D::DEPTH_COMPONENT:
-        return GraphicsContext3D::DEPTH_BUFFER_BIT;
-    case GraphicsContext3D::STENCIL_INDEX8:
-        return GraphicsContext3D::STENCIL_BUFFER_BIT;
-    case GraphicsContext3D::DEPTH_STENCIL:
-        return GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT;
+    case GL_ALPHA:
+    case GL_LUMINANCE:
+    case GL_LUMINANCE_ALPHA:
+    case GL_RGB:
+    case GL_RGB565:
+    case GL_RGBA:
+    case GL_RGBA4:
+    case GL_RGB5_A1:
+        return GL_COLOR_BUFFER_BIT;
+    case GL_DEPTH_COMPONENT16:
+    case GL_DEPTH_COMPONENT:
+        return GL_DEPTH_BUFFER_BIT;
+    case GL_STENCIL_INDEX8:
+        return GL_STENCIL_BUFFER_BIT;
+    case GL_DEPTH_STENCIL_OES:
+        return GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
     default:
         return 0;
     }
 }
 
 unsigned GraphicsContext3D::getChannelBitsByFormat(GC3Denum format)
 {
     switch (format) {
-    case GraphicsContext3D::ALPHA:
+    case GL_ALPHA:
         return ChannelAlpha;
-    case GraphicsContext3D::LUMINANCE:
+    case GL_LUMINANCE:
         return ChannelRGB;
-    case GraphicsContext3D::LUMINANCE_ALPHA:
+    case GL_LUMINANCE_ALPHA:
         return ChannelRGBA;
-    case GraphicsContext3D::RGB:
-    case GraphicsContext3D::RGB565:
+    case GL_RGB:
+    case GL_RGB565:
         return ChannelRGB;
-    case GraphicsContext3D::RGBA:
-    case GraphicsContext3D::RGBA4:
-    case GraphicsContext3D::RGB5_A1:
+    case GL_RGBA:
+    case GL_RGBA4:
+    case GL_RGB5_A1:
         return ChannelRGBA;
-    case GraphicsContext3D::DEPTH_COMPONENT16:
-    case GraphicsContext3D::DEPTH_COMPONENT:
+    case GL_DEPTH_COMPONENT16:
+    case GL_DEPTH_COMPONENT:
         return ChannelDepth;
-    case GraphicsContext3D::STENCIL_INDEX8:
+    case GL_STENCIL_INDEX8:
         return ChannelStencil;
-    case GraphicsContext3D::DEPTH_STENCIL:
+    case GL_DEPTH_STENCIL_OES:
         return ChannelDepth | ChannelStencil;
     default:
         return 0;
     }
 }
 
 void GraphicsContext3D::paintFramebufferToCanvas(int framebuffer, int width, int height, bool premultiplyAlpha, ImageBuffer* imageBuffer)
 {
     unsigned char* pixels = 0;
 
@@ skipping 14 matching lines @@
             if (!m_resizingBitmap.allocPixels())
                 return;
         }
         readbackBitmap = &m_resizingBitmap;
     }
 
     // Read back the frame buffer.
     SkAutoLockPixels bitmapLock(*readbackBitmap);
     pixels = static_cast<unsigned char*>(readbackBitmap->getPixels());
 
-    m_impl->bindFramebuffer(FRAMEBUFFER, framebuffer);
+    m_impl->bindFramebuffer(GL_FRAMEBUFFER, framebuffer);
     readBackFramebuffer(pixels, width, height, ReadbackSkia, premultiplyAlpha ? AlphaDoPremultiply : AlphaDoNothing);
     flipVertically(pixels, width, height);
 
     readbackBitmap->notifyPixelsChanged();
     if (m_resizingBitmap.readyToDraw()) {
         // We need to draw the resizing bitmap into the canvas's backing store.
         SkCanvas canvas(*canvasBitmap);
         SkRect dst;
         dst.set(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(canvasBitmap->width()), SkIntToScalar(canvasBitmap->height()));
         canvas.drawBitmapRect(m_resizingBitmap, 0, dst);
@@ skipping 24 matching lines @@
 {
     if (m_initializedAvailableExtensions)
         return;
 
     m_initializedAvailableExtensions = true;
     bool success = m_impl->makeContextCurrent();
     ASSERT(success);
     if (!success)
         return;
 
-    String extensionsString = m_impl->getString(GraphicsContext3D::EXTENSIONS);
+    String extensionsString = m_impl->getString(GL_EXTENSIONS);
     splitStringHelper(extensionsString, m_enabledExtensions);
 
     String requestableExtensionsString = m_impl->getRequestableExtensionsCHROMIUM();
     splitStringHelper(requestableExtensionsString, m_requestableExtensions);
 }
 
 
 bool GraphicsContext3D::supportsExtension(const String& name)
 {
     initializeExtensions();
@@ skipping 37 matching lines @@
     for (unsigned i = 0; i < count; i++) {
         uint8* rowA = framebuffer + i * rowBytes;
         uint8* rowB = framebuffer + (height - i - 1) * rowBytes;
         memcpy(scanline, rowB, rowBytes);
         memcpy(rowB, rowA, rowBytes);
         memcpy(rowA, scanline, rowBytes);
     }
 }
 
 } // namespace WebCore