s/Value/value/g for type trait value field in WebGLImageConversion.cpp

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 "platform/graphics/gpu/WebGLImageConversion.h"
 
 #include "platform/CheckedInt.h"
 #include "platform/graphics/ImageObserver.h"
 #include "platform/graphics/cpu/arm/WebGLImageConversionNEON.h"
 #include "platform/graphics/cpu/mips/WebGLImageConversionMSA.h"
@@ skipping 1417 matching lines @@
         || 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 =
+    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 =
+    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 =
+    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 =
+    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 =
+    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 =
+    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 =
+    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 =
+    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 =
+    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 =
+    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>
+    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;
 };
@@ skipping 48 matching lines @@
 
 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
+    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;
+    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)
 {
     switch (format) {
     case WebGLImageConversion::DataFormatR8:
     case WebGLImageConversion::DataFormatR8_S:
     case WebGLImageConversion::DataFormatA8:
         return 1;
     case WebGLImageConversion::DataFormatRG8:
@@ skipping 173 matching lines @@
             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 =
+    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
         || Format == WebGLImageConversion::DataFormatR32F
         || Format == WebGLImageConversion::DataFormatRGBA16F
         || Format == WebGLImageConversion::DataFormatRGB16F
         || Format == WebGLImageConversion::DataFormatRG16F
         || Format == WebGLImageConversion::DataFormatRA16F
         || Format == WebGLImageConversion::DataFormatR16F
         || Format == WebGLImageConversion::DataFormatRGBA5551
         || Format == WebGLImageConversion::DataFormatRGBA4444
         || Format == WebGLImageConversion::DataFormatRGB565;
 };
 
 template<WebGLImageConversion::DataFormat SrcFormat, WebGLImageConversion::DataFormat DstFormat, WebGLImageConversion::AlphaOp alphaOp>
 void FormatConverter::convert()
 {
     // Many instantiations of this template function will never be entered, so we try
     // to return immediately in these cases to avoid the compiler to generate useless code.
     if (SrcFormat == DstFormat && alphaOp == WebGLImageConversion::AlphaDoNothing) {
         ASSERT_NOT_REACHED();
         return;
     }
-    if (!IsFloatFormat<DstFormat>::Value && IsFloatFormat<SrcFormat>::Value) {
+    if (!IsFloatFormat<DstFormat>::value && IsFloatFormat<SrcFormat>::value) {
         ASSERT_NOT_REACHED();
         return;
     }
 
     // Only textures uploaded from DOM elements or ImageData can allow DstFormat != SrcFormat.
     const bool srcFormatComesFromDOMElementOrImageData = WebGLImageConversion::srcFormatComeFromDOMElementOrImageData(SrcFormat);
     if (!srcFormatComesFromDOMElementOrImageData && SrcFormat != DstFormat) {
         ASSERT_NOT_REACHED();
         return;
     }
     // Likewise, only textures uploaded from DOM elements or ImageData can possibly have to be unpremultiplied.
     if (!srcFormatComesFromDOMElementOrImageData && alphaOp == WebGLImageConversion::AlphaDoUnmultiply) {
         ASSERT_NOT_REACHED();
         return;
     }
-    if (srcFormatComesFromDOMElementOrImageData && alphaOp == WebGLImageConversion::AlphaDoUnmultiply && !SupportsConversionFromDomElements<DstFormat>::Value) {
+    if (srcFormatComesFromDOMElementOrImageData && alphaOp == WebGLImageConversion::AlphaDoUnmultiply && !SupportsConversionFromDomElements<DstFormat>::value) {
         ASSERT_NOT_REACHED();
         return;
     }
     if ((!HasAlpha(SrcFormat) || !HasColor(SrcFormat) || !HasColor(DstFormat)) && alphaOp != WebGLImageConversion::AlphaDoNothing) {
         ASSERT_NOT_REACHED();
         return;
     }
     // If converting DOM element data to UNSIGNED_INT_5_9_9_9_REV or UNSIGNED_INT_10F_11F_11F_REV,
     // we should always switch to FLOAT instead to avoid unpack/pack to these two types.
     if (srcFormatComesFromDOMElementOrImageData && SrcFormat != DstFormat
         && (DstFormat == WebGLImageConversion::DataFormatRGB5999 || DstFormat == WebGLImageConversion::DataFormatRGB10F11F11F)) {
         ASSERT_NOT_REACHED();
         return;
     }
 
     typedef typename DataTypeForFormat<SrcFormat>::Type SrcType;
     typedef typename DataTypeForFormat<DstFormat>::Type DstType;
-    const int IntermFormat = IntermediateFormat<DstFormat>::Value;
+    const int IntermFormat = IntermediateFormat<DstFormat>::value;
     typedef typename DataTypeForFormat<IntermFormat>::Type IntermType;
     const ptrdiff_t srcStrideInElements = m_srcStride / sizeof(SrcType);
     const ptrdiff_t dstStrideInElements = m_dstStride / sizeof(DstType);
     const bool trivialUnpack = SrcFormat == IntermFormat;
     const bool trivialPack = DstFormat == IntermFormat && alphaOp == WebGLImageConversion::AlphaDoNothing;
     ASSERT(!trivialUnpack || !trivialPack);
 
     const SrcType *srcRowStart = static_cast<const SrcType*>(m_srcStart);
     DstType* dstRowStart = static_cast<DstType*>(m_dstStart);
     if (trivialUnpack) {
@@ skipping 498 matching lines @@
     }
 
     FormatConverter converter(width, height, sourceData, destinationData, srcStride, dstStride);
     converter.convert(sourceDataFormat, dstDataFormat, alphaOp);
     if (!converter.Success())
         return false;
     return true;
 }
 
 } // namespace blink