--- a/dom/canvas/WebGLContextExtensions.cpp
+++ b/dom/canvas/WebGLContextExtensions.cpp
@@ -27,16 +27,17 @@ WebGLContext::GetExtensionString(WebGLEx
     if (!initialized) {
         initialized = true;
 
 #define WEBGL_EXTENSION_IDENTIFIER(x) \
         sExtensionNamesEnumeratedArray[WebGLExtensionID::x] = #x;
 
         WEBGL_EXTENSION_IDENTIFIER(ANGLE_instanced_arrays)
         WEBGL_EXTENSION_IDENTIFIER(EXT_blend_minmax)
+        WEBGL_EXTENSION_IDENTIFIER(EXT_color_buffer_float)
         WEBGL_EXTENSION_IDENTIFIER(EXT_color_buffer_half_float)
         WEBGL_EXTENSION_IDENTIFIER(EXT_frag_depth)
         WEBGL_EXTENSION_IDENTIFIER(EXT_shader_texture_lod)
         WEBGL_EXTENSION_IDENTIFIER(EXT_sRGB)
         WEBGL_EXTENSION_IDENTIFIER(EXT_texture_filter_anisotropic)
         WEBGL_EXTENSION_IDENTIFIER(EXT_disjoint_timer_query)
         WEBGL_EXTENSION_IDENTIFIER(OES_element_index_uint)
         WEBGL_EXTENSION_IDENTIFIER(OES_standard_derivatives)
@@ -146,17 +147,28 @@ WebGLContext::IsExtensionSupported(WebGL
         // We always support this extension.
         return true;
 
     default:
         // For warnings-as-errors.
         break;
     }
 
-    if (!IsWebGL2()) {
+    if (IsWebGL2()) {
+        // WebGL2-only extensions
+        switch (ext) {
+        // EXT_
+        case WebGLExtensionID::EXT_color_buffer_float:
+            return WebGLExtensionEXTColorBufferFloat::IsSupported(this);
+
+        default:
+            // For warnings-as-errors.
+            break;
+        }
+    } else {
         // WebGL1-only extensions
         switch (ext) {
         // ANGLE_
         case WebGLExtensionID::ANGLE_instanced_arrays:
             return WebGLExtensionInstancedArrays::IsSupported(this);
 
         // EXT_
         case WebGLExtensionID::EXT_blend_minmax:
@@ -326,16 +338,19 @@ WebGLContext::EnableExtension(WebGLExten
     case WebGLExtensionID::ANGLE_instanced_arrays:
         obj = new WebGLExtensionInstancedArrays(this);
         break;
 
     // EXT_
     case WebGLExtensionID::EXT_blend_minmax:
         obj = new WebGLExtensionBlendMinMax(this);
         break;
+    case WebGLExtensionID::EXT_color_buffer_float:
+        obj = new WebGLExtensionEXTColorBufferFloat(this);
+        break;
     case WebGLExtensionID::EXT_color_buffer_half_float:
         obj = new WebGLExtensionColorBufferHalfFloat(this);
         break;
     case WebGLExtensionID::EXT_disjoint_timer_query:
         obj = new WebGLExtensionDisjointTimerQuery(this);
         break;
     case WebGLExtensionID::EXT_frag_depth:
         obj = new WebGLExtensionFragDepth(this);

new file mode 100644
--- /dev/null
+++ b/dom/canvas/WebGLExtensionEXTColorBufferFloat.cpp
@@ -0,0 +1,51 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WebGLExtensions.h"
+
+#include "GLContext.h"
+#include "mozilla/dom/WebGL2RenderingContextBinding.h"
+#include "WebGLContext.h"
+#include "WebGLFormats.h"
+
+namespace mozilla {
+
+WebGLExtensionEXTColorBufferFloat::WebGLExtensionEXTColorBufferFloat(WebGLContext* webgl)
+    : WebGLExtensionBase(webgl)
+{
+    MOZ_ASSERT(IsSupported(webgl), "Don't construct extension if unsupported.");
+
+    auto& fua = webgl->mFormatUsage;
+
+    auto fnUpdateUsage = [&fua](GLenum sizedFormat, webgl::EffectiveFormat effFormat) {
+        auto usage = fua->EditUsage(effFormat);
+        usage->isRenderable = true;
+        fua->AllowRBFormat(sizedFormat, usage);
+    };
+
+#define FOO(x) fnUpdateUsage(LOCAL_GL_ ## x, webgl::EffectiveFormat::x)
+
+    FOO(R16F);
+    FOO(RG16F);
+    FOO(RGBA16F);
+
+    FOO(R32F);
+    FOO(RG32F);
+    FOO(RGBA32F);
+
+    FOO(R11F_G11F_B10F);
+
+#undef FOO
+}
+
+/*static*/ bool
+WebGLExtensionEXTColorBufferFloat::IsSupported(const WebGLContext* webgl)
+{
+    const gl::GLContext* gl = webgl->GL();
+    return gl->IsSupported(gl::GLFeature::EXT_color_buffer_float);
+}
+
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionEXTColorBufferFloat, EXT_color_buffer_float)
+
+} // namespace mozilla

--- a/dom/canvas/WebGLExtensions.h
+++ b/dom/canvas/WebGLExtensions.h
@@ -148,16 +148,28 @@ class WebGLExtensionElementIndexUint
 {
 public:
     explicit WebGLExtensionElementIndexUint(WebGLContext*);
     virtual ~WebGLExtensionElementIndexUint();
 
     DECL_WEBGL_EXTENSION_GOOP
 };
 
+class WebGLExtensionEXTColorBufferFloat
+    : public WebGLExtensionBase
+{
+public:
+    explicit WebGLExtensionEXTColorBufferFloat(WebGLContext*);
+    virtual ~WebGLExtensionEXTColorBufferFloat() { }
+
+    static bool IsSupported(const WebGLContext*);
+
+    DECL_WEBGL_EXTENSION_GOOP
+};
+
 class WebGLExtensionFragDepth
     : public WebGLExtensionBase
 {
 public:
     explicit WebGLExtensionFragDepth(WebGLContext*);
     virtual ~WebGLExtensionFragDepth();
 
     static bool IsSupported(const WebGLContext* context);

--- a/dom/canvas/WebGLProgram.cpp
+++ b/dom/canvas/WebGLProgram.cpp
@@ -5,16 +5,17 @@
 
 #include "WebGLProgram.h"
 
 #include "GLContext.h"
 #include "mozilla/CheckedInt.h"
 #include "mozilla/dom/WebGL2RenderingContextBinding.h"
 #include "mozilla/dom/WebGLRenderingContextBinding.h"
 #include "mozilla/RefPtr.h"
+#include "nsPrintfCString.h"
 #include "WebGLActiveInfo.h"
 #include "WebGLContext.h"
 #include "WebGLShader.h"
 #include "WebGLUniformLocation.h"
 #include "WebGLValidateStrings.h"
 
 namespace mozilla {
 

--- a/dom/canvas/WebGLTypes.h
+++ b/dom/canvas/WebGLTypes.h
@@ -134,16 +134,17 @@ enum class WebGLTexDimensions : uint8_t 
     Tex2D,
     Tex3D
 };
 
 // Please keep extensions in alphabetic order.
 enum class WebGLExtensionID : uint8_t {
     ANGLE_instanced_arrays,
     EXT_blend_minmax,
+    EXT_color_buffer_float,
     EXT_color_buffer_half_float,
     EXT_frag_depth,
     EXT_sRGB,
     EXT_shader_texture_lod,
     EXT_texture_filter_anisotropic,
     EXT_disjoint_timer_query,
     OES_element_index_uint,
     OES_standard_derivatives,

--- a/dom/canvas/moz.build
+++ b/dom/canvas/moz.build
@@ -106,16 +106,17 @@ UNIFIED_SOURCES += [
     'WebGLExtensionCompressedTexturePVRTC.cpp',
     'WebGLExtensionCompressedTextureS3TC.cpp',
     'WebGLExtensionDebugRendererInfo.cpp',
     'WebGLExtensionDebugShaders.cpp',
     'WebGLExtensionDepthTexture.cpp',
     'WebGLExtensionDisjointTimerQuery.cpp',
     'WebGLExtensionDrawBuffers.cpp',
     'WebGLExtensionElementIndexUint.cpp',
+    'WebGLExtensionEXTColorBufferFloat.cpp',
     'WebGLExtensionFragDepth.cpp',
     'WebGLExtensionInstancedArrays.cpp',
     'WebGLExtensionLoseContext.cpp',
     'WebGLExtensionShaderTextureLod.cpp',
     'WebGLExtensionSRGB.cpp',
     'WebGLExtensionStandardDerivatives.cpp',
     'WebGLExtensionTextureFilterAnisotropic.cpp',
     'WebGLExtensionTextureFloat.cpp',

--- a/gfx/gl/GLContext.h
+++ b/gfx/gl/GLContext.h
@@ -90,16 +90,17 @@ enum class GLFeature {
     copy_buffer,
     depth_texture,
     draw_buffers,
     draw_instanced,
     draw_range_elements,
     element_index_uint,
     ES2_compatibility,
     ES3_compatibility,
+    EXT_color_buffer_float,
     frag_color_float,
     frag_depth,
     framebuffer_blit,
     framebuffer_multisample,
     framebuffer_object,
     framebuffer_object_EXT_OES,
     get_integer_indexed,
     get_integer64_indexed,

--- a/gfx/gl/GLContextFeatures.cpp
+++ b/gfx/gl/GLContextFeatures.cpp
@@ -182,16 +182,26 @@ static const FeatureInfo sFeatureInfoArr
         kGLCoreVersionForES3Compat,
         GLESVersion::ES3, // OpenGL ES version
         GLContext::ARB_ES3_compatibility, // no suffix on ARB extension
         {
             GLContext::Extensions_End
         }
     },
     {
+        "EXT_color_buffer_float",
+        GLVersion::GL3,
+        GLESVersion::NONE,
+        GLContext::Extension_None,
+        {
+            GLContext::EXT_color_buffer_float,
+            GLContext::Extensions_End
+        }
+    },
+    {
         // Removes clamping for float color outputs from frag shaders.
         "frag_color_float",
         GLVersion::GL3,
         GLESVersion::ES3,
         GLContext::Extension_None,
         {
             GLContext::ARB_color_buffer_float,
             GLContext::EXT_color_buffer_float,