Make platform/graphics to use USING_FAST_MALLOC.

third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.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 "config.h"
 #include "platform/graphics/gpu/WebGLImageConversion.h"
 
 #include "platform/CheckedInt.h"
 #include "platform/graphics/ImageObserver.h"
 #include "platform/graphics/cpu/arm/WebGLImageConversionNEON.h"
@@ skipping 1411 matching lines @@
         || format == WebGLImageConversion::DataFormatRG32F
         || format == WebGLImageConversion::DataFormatR8_S
         || format == WebGLImageConversion::DataFormatR16
         || format == WebGLImageConversion::DataFormatR16_S
         || format == WebGLImageConversion::DataFormatR32
         || format == WebGLImageConversion::DataFormatR32_S;
 }
 
 template<int Format>
 struct IsInt8Format {
+    STATIC_ONLY(IsInt8Format);
     static const bool Value =
         Format == WebGLImageConversion::DataFormatRGBA8_S
         || Format == WebGLImageConversion::DataFormatRGB8_S
         || Format == WebGLImageConversion::DataFormatRG8_S
         || Format == WebGLImageConversion::DataFormatR8_S;
 };
 
 template<int Format>
 struct IsInt16Format {
+    STATIC_ONLY(IsInt16Format);
     static const bool Value =
         Format == WebGLImageConversion::DataFormatRGBA16_S
         || Format == WebGLImageConversion::DataFormatRGB16_S
         || Format == WebGLImageConversion::DataFormatRG16_S
         || Format == WebGLImageConversion::DataFormatR16_S;
 };
 
 template<int Format>
 struct IsInt32Format {
+    STATIC_ONLY(IsInt32Format);
     static const bool Value =
         Format == WebGLImageConversion::DataFormatRGBA32_S
         || Format == WebGLImageConversion::DataFormatRGB32_S
         || Format == WebGLImageConversion::DataFormatRG32_S
         || Format == WebGLImageConversion::DataFormatR32_S;
 };
 
 template<int Format>
 struct IsUInt8Format {
+    STATIC_ONLY(IsUInt8Format);
     static const bool Value =
         Format == WebGLImageConversion::DataFormatRGBA8
         || Format == WebGLImageConversion::DataFormatRGB8
         || Format == WebGLImageConversion::DataFormatRG8
         || Format == WebGLImageConversion::DataFormatR8
         || Format == WebGLImageConversion::DataFormatBGRA8
         || Format == WebGLImageConversion::DataFormatBGR8
         || Format == WebGLImageConversion::DataFormatARGB8
         || Format == WebGLImageConversion::DataFormatABGR8
         || Format == WebGLImageConversion::DataFormatRA8
         || Format == WebGLImageConversion::DataFormatAR8
         || Format == WebGLImageConversion::DataFormatA8;
 };
 
 template<int Format>
 struct IsUInt16Format {
+    STATIC_ONLY(IsUInt16Format);
     static const bool Value =
         Format == WebGLImageConversion::DataFormatRGBA16
         || Format == WebGLImageConversion::DataFormatRGB16
         || Format == WebGLImageConversion::DataFormatRG16
         || Format == WebGLImageConversion::DataFormatR16;
 };
 
 template<int Format>
 struct IsUInt32Format {
+    STATIC_ONLY(IsUInt32Format);
     static const bool Value =
         Format == WebGLImageConversion::DataFormatRGBA32
         || Format == WebGLImageConversion::DataFormatRGB32
         || Format == WebGLImageConversion::DataFormatRG32
         || Format == WebGLImageConversion::DataFormatR32;
 };
 
 template<int Format>
 struct IsFloatFormat {
+    STATIC_ONLY(IsFloatFormat);
     static const bool Value =
         Format == WebGLImageConversion::DataFormatRGBA32F
         || Format == WebGLImageConversion::DataFormatRGB32F
         || Format == WebGLImageConversion::DataFormatRA32F
         || Format == WebGLImageConversion::DataFormatR32F
         || Format == WebGLImageConversion::DataFormatA32F
         || Format == WebGLImageConversion::DataFormatRG32F;
 };
 
 template<int Format>
 struct IsHalfFloatFormat {
+    STATIC_ONLY(IsHalfFloatFormat);
     static const bool Value =
         Format == WebGLImageConversion::DataFormatRGBA16F
         || Format == WebGLImageConversion::DataFormatRGB16F
         || Format == WebGLImageConversion::DataFormatRA16F
         || Format == WebGLImageConversion::DataFormatR16F
         || Format == WebGLImageConversion::DataFormatA16F
         || Format == WebGLImageConversion::DataFormatRG16F;
 };
 
 template<int Format>
 struct Is32bppFormat {
+    STATIC_ONLY(Is32bppFormat);
     static const bool Value =
         Format == WebGLImageConversion::DataFormatRGBA2_10_10_10
         || Format == WebGLImageConversion::DataFormatRGB5999
         || Format == WebGLImageConversion::DataFormatRGB10F11F11F;
 };
 
 template<int Format>
 struct Is16bppFormat {
+    STATIC_ONLY(Is16bppFormat);
     static const bool Value =
         Format == WebGLImageConversion::DataFormatRGBA5551
         || Format == WebGLImageConversion::DataFormatRGBA4444
         || Format == WebGLImageConversion::DataFormatRGB565;
 };
 
 template<int Format,
     bool IsInt8Format = IsInt8Format<Format>::Value,
     bool IsUInt8Format = IsUInt8Format<Format>::Value,
     bool IsInt16Format = IsInt16Format<Format>::Value,
     bool IsUInt16Format = IsUInt16Format<Format>::Value,
     bool IsInt32Format = IsInt32Format<Format>::Value,
     bool IsUInt32Format = IsUInt32Format<Format>::Value,
     bool IsFloat = IsFloatFormat<Format>::Value,
     bool IsHalfFloat = IsHalfFloatFormat<Format>::Value,
     bool Is16bpp = Is16bppFormat<Format>::Value,
     bool Is32bpp = Is32bppFormat<Format>::Value>
 struct DataTypeForFormat {
+    STATIC_ONLY(DataTypeForFormat);
     typedef double Type; // Use a type that's not used in unpack/pack.
 };
 
 template<int Format>
 struct DataTypeForFormat<Format, true, false, false, false, false, false, false, false, false, false> {
+    STATIC_ONLY(DataTypeForFormat);
     typedef int8_t Type;
 };
 
 template<int Format>
 struct DataTypeForFormat<Format, false, true, false, false, false, false, false, false, false, false> {
+    STATIC_ONLY(DataTypeForFormat);
     typedef uint8_t Type;
 };
 
 template<int Format>
 struct DataTypeForFormat<Format, false, false, true, false, false, false, false, false, false, false> {
+    STATIC_ONLY(DataTypeForFormat);
     typedef int16_t Type;
 };
 
 template<int Format>
 struct DataTypeForFormat<Format, false, false, false, true, false, false, false, false, false, false> {
+    STATIC_ONLY(DataTypeForFormat);
     typedef uint16_t Type;
 };
 
 template<int Format>
 struct DataTypeForFormat<Format, false, false, false, false, true, false, false, false, false, false> {
+    STATIC_ONLY(DataTypeForFormat);
     typedef int32_t Type;
 };
 
 template<int Format>
 struct DataTypeForFormat<Format, false, false, false, false, false, true, false, false, false, false> {
+    STATIC_ONLY(DataTypeForFormat);
     typedef uint32_t Type;
 };
 
 template<int Format>
 struct DataTypeForFormat<Format, false, false, false, false, false, false, true, false, false, false> {
+    STATIC_ONLY(DataTypeForFormat);
     typedef float Type;
 };
 
 template<int Format>
 struct DataTypeForFormat<Format, false, false, false, false, false, false, false, true, false, false> {
+    STATIC_ONLY(DataTypeForFormat);
     typedef uint16_t Type;
 };
 
 template<int Format>
 struct DataTypeForFormat<Format, false, false, false, false, false, false, false, false, true, false> {
+    STATIC_ONLY(DataTypeForFormat);
     typedef uint16_t Type;
 };
 
 template<int Format>
 struct DataTypeForFormat<Format, false, false, false, false, false, false, false, false, false, true> {
+    STATIC_ONLY(DataTypeForFormat);
     typedef uint32_t Type;
 };
 
 template<int Format>
 struct UsesFloatIntermediateFormat {
+    STATIC_ONLY(UsesFloatIntermediateFormat);
     static const bool Value =
         IsFloatFormat<Format>::Value
         || IsHalfFloatFormat<Format>::Value
         || Format == WebGLImageConversion::DataFormatRGBA2_10_10_10
         || Format == WebGLImageConversion::DataFormatRGB10F11F11F
         || Format == WebGLImageConversion::DataFormatRGB5999;
 };
 
 template<int Format>
 struct IntermediateFormat {
+    STATIC_ONLY(IntermediateFormat);
     static const int Value =
         UsesFloatIntermediateFormat<Format>::Value ? WebGLImageConversion::DataFormatRGBA32F
         : IsInt32Format<Format>::Value ? WebGLImageConversion::DataFormatRGBA32_S
         : IsUInt32Format<Format>::Value ? WebGLImageConversion::DataFormatRGBA32
         : IsInt16Format<Format>::Value ? WebGLImageConversion::DataFormatRGBA16_S
         : (IsUInt16Format<Format>::Value || Is32bppFormat<Format>::Value) ? WebGLImageConversion::DataFormatRGBA16
         : IsInt8Format<Format>::Value ? WebGLImageConversion::DataFormatRGBA8_S : WebGLImageConversion::DataFormatRGBA8;
 };
 
 unsigned TexelBytesForFormat(WebGLImageConversion::DataFormat format)
@@ skipping 61 matching lines @@
     case WebGLImageConversion::DataFormatRGBA32F:
         return 16;
     default:
         return 0;
     }
 }
 
 /* END CODE SHARED WITH MOZILLA FIREFOX */
 
 class FormatConverter {
+    STACK_ALLOCATED();
 public:
     FormatConverter(unsigned width, unsigned height,
         const void* srcStart, void* dstStart, int srcStride, int dstStride)
         : m_width(width), m_height(height), m_srcStart(srcStart), m_dstStart(dstStart), m_srcStride(srcStride), m_dstStride(dstStride), m_success(false)
     {
         const unsigned MaxNumberOfComponents = 4;
         const unsigned MaxBytesPerComponent  = 4;
         m_unpackedIntermediateSrcData = adoptArrayPtr(new uint8_t[m_width * MaxNumberOfComponents *MaxBytesPerComponent]);
         ASSERT(m_unpackedIntermediateSrcData.get());
     }
@@ skipping 97 matching lines @@
             FORMATCONVERTER_CASE_ALPHAOP(WebGLImageConversion::AlphaDoPremultiply)
             FORMATCONVERTER_CASE_ALPHAOP(WebGLImageConversion::AlphaDoUnmultiply)
         default:
             ASSERT_NOT_REACHED();
         }
 #undef FORMATCONVERTER_CASE_ALPHAOP
 }
 
 template<int Format>
 struct SupportsConversionFromDomElements {
+    STATIC_ONLY(SupportsConversionFromDomElements);
     static const bool Value =
         Format == WebGLImageConversion::DataFormatRGBA8
         || Format == WebGLImageConversion::DataFormatRGB8
         || Format == WebGLImageConversion::DataFormatRG8
         || Format == WebGLImageConversion::DataFormatRA8
         || Format == WebGLImageConversion::DataFormatR8
         || Format == WebGLImageConversion::DataFormatRGBA32F
         || Format == WebGLImageConversion::DataFormatRGB32F
         || Format == WebGLImageConversion::DataFormatRG32F
         || Format == WebGLImageConversion::DataFormatRA32F
@@ skipping 493 matching lines @@
     }
 
     FormatConverter converter(width, height, sourceData, destinationData, srcStride, dstStride);
     converter.convert(sourceDataFormat, dstDataFormat, alphaOp);
     if (!converter.Success())
         return false;
     return true;
 }
 
 } // namespace blink