WebGL: Tidy up buffer allocation logic

third_party/WebKit/Source/platform/graphics/gpu/DrawingBuffer.cpp

 /*
  * Copyright (c) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 514 matching lines @@
 
 DrawingBuffer::ColorBufferParameters
 DrawingBuffer::GpuMemoryBufferColorBufferParameters() {
 #if OS(MACOSX)
   // A CHROMIUM_image backed texture requires a specialized set of parameters
   // on OSX.
   ColorBufferParameters parameters;
   parameters.target = GC3D_TEXTURE_RECTANGLE_ARB;
 
   if (want_alpha_channel_) {
-    parameters.creation_internal_color_format = GL_RGBA;
-    parameters.internal_color_format = GL_RGBA;
+    parameters.allocate_alpha_channel = true;
   } else if (ContextProvider()
                  ->GetCapabilities()
                  .chromium_image_rgb_emulation) {
-    parameters.creation_internal_color_format = GL_RGB;
-    parameters.internal_color_format = GL_RGBA;
+    parameters.allocate_alpha_channel = true;
   } else {
-    GLenum format =
-        DefaultBufferRequiresAlphaChannelToBePreserved() ? GL_RGBA : GL_RGB;
-    parameters.creation_internal_color_format = format;
-    parameters.internal_color_format = format;
+    parameters.allocate_alpha_channel =
+        DefaultBufferRequiresAlphaChannelToBePreserved();
   }
-
-  // Unused when CHROMIUM_image is being used.
-  parameters.color_format = 0;
   return parameters;
 #else
   return TextureColorBufferParameters();
 #endif
 }
 
 DrawingBuffer::ColorBufferParameters
 DrawingBuffer::TextureColorBufferParameters() {
   ColorBufferParameters parameters;
   parameters.target = GL_TEXTURE_2D;
   if (want_alpha_channel_) {
-    parameters.internal_color_format = GL_RGBA;
-    parameters.creation_internal_color_format = GL_RGBA;
-    parameters.color_format = GL_RGBA;
+    parameters.allocate_alpha_channel = true();
   } else if (ContextProvider()
                  ->GetCapabilities()
                  .emulate_rgb_buffer_with_rgba) {
-    parameters.internal_color_format = GL_RGBA;
-    parameters.creation_internal_color_format = GL_RGBA;
-    parameters.color_format = GL_RGBA;
+    parameters.allocate_alpha_channel = true();
   } else {
-    GLenum format =
-        DefaultBufferRequiresAlphaChannelToBePreserved() ? GL_RGBA : GL_RGB;
-    parameters.creation_internal_color_format = format;
-    parameters.internal_color_format = format;
-    parameters.color_format = format;
+    parameters.allocate_alpha_channel =
+        DefaultBufferRequiresAlphaChannelToBePreserved();
   }
   return parameters;
 }
 
 PassRefPtr<DrawingBuffer::ColorBuffer>
 DrawingBuffer::CreateOrRecycleColorBuffer() {
   DCHECK(state_restorer_);
   if (!recycled_color_buffer_queue_.IsEmpty()) {
     RefPtr<ColorBuffer> recycled = recycled_color_buffer_queue_.TakeLast();
     if (recycled->receive_sync_token.HasData())
@@ skipping 562 matching lines @@
 
   // Select the Parameters for the texture object. Allocate the backing
   // GpuMemoryBuffer and GLImage, if one is going to be used.
   ColorBufferParameters parameters;
   GLuint image_id = 0;
   std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer;
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager =
       Platform::Current()->GetGpuMemoryBufferManager();
   if (ShouldUseChromiumImage() && gpu_memory_buffer_manager) {
     parameters = GpuMemoryBufferColorBufferParameters();
-    gfx::BufferFormat buffer_format = gpu::DefaultBufferFormatForImageFormat(
-        parameters.creation_internal_color_format);
+    gfx::BufferFormat buffer_format;
+    GLenum gl_format = GL_NONE;
+    if (parameters.allocate_alpha_channel) {
+      buffer_format = gfx::BufferFormat::gfx::BufferFormat::RGBA_8888;
+      gl_format = GL_RGBA;
+    } else {
+      buffer_format = gfx::BufferFormat::gfx::BufferFormat::BGRX_8888;
+      gl_format = GL_RGB;
+    }
     gpu_memory_buffer = gpu_memory_buffer_manager->CreateGpuMemoryBuffer(
         gfx::Size(size), buffer_format, gfx::BufferUsage::SCANOUT,
         gpu::kNullSurfaceHandle);
     if (gpu_memory_buffer) {
       if (RuntimeEnabledFeatures::colorCorrectRenderingEnabled())
         gpu_memory_buffer->SetColorSpaceForScanout(color_space_);
-      image_id = gl_->CreateImageCHROMIUM(
-          gpu_memory_buffer->AsClientBuffer(), size.Width(), size.Height(),
-          parameters.creation_internal_color_format);
+      image_id =
+          gl_->CreateImageCHROMIUM(gpu_memory_buffer->AsClientBuffer(),
+                                   size.Width(), size.Height(), gl_format);
       if (!image_id)
         gpu_memory_buffer.reset();
     }
-  } else {
+  }

[ccameron, 2017/04/19 06:09:03]

This line here is the only logic change -- if we fail to allocate the image, we
should compute the texture parameters.

+  if (!image_id)
     parameters = TextureColorBufferParameters();
-  }
 
   // Allocate the texture for this object.
   GLuint texture_id = 0;
   {
     gl_->GenTextures(1, &texture_id);
     gl_->BindTexture(parameters.target, texture_id);
     gl_->TexParameteri(parameters.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     gl_->TexParameteri(parameters.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     gl_->TexParameteri(parameters.target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     gl_->TexParameteri(parameters.target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   }
 
   // If this is GpuMemoryBuffer-backed, then bind the texture to the
   // GpuMemoryBuffer's GLImage. Otherwise, allocate ordinary texture storage.
   if (image_id) {
     gl_->BindTexImage2DCHROMIUM(parameters.target, image_id);
   } else {
     if (storage_texture_supported_) {
       GLenum internal_storage_format = GL_NONE;
-      if (parameters.creation_internal_color_format == GL_RGB) {
+      if (parameters.allocate_alpha_channel)
+        internal_storage_format = GL_RGBA8;
+      else
         internal_storage_format = GL_RGB8;
-      } else if (parameters.creation_internal_color_format == GL_RGBA) {
-        internal_storage_format = GL_RGBA8;
-      } else {
-        NOTREACHED();
-      }
       gl_->TexStorage2DEXT(GL_TEXTURE_2D, 1, internal_storage_format,
                            size.Width(), size.Height());
     } else {
-      gl_->TexImage2D(parameters.target, 0,
-                      parameters.creation_internal_color_format, size.Width(),
-                      size.Height(), 0, parameters.color_format,
-                      GL_UNSIGNED_BYTE, 0);
+      GLenum gl_format = GL_NONE;
+      if (parameters.allocate_alpha_channel)
+        gl_format = GL_RGBA;
+      else
+        gl_format = GL_RGB;
+      gl_->TexImage2D(parameters.target, 0, gl_format, size.Width(),
+                      size.Height(), 0, gl_format, GL_UNSIGNED_BYTE, 0);
     }
   }
 
   // Clear the alpha channel if this is RGB emulated.
   if (image_id && !want_alpha_channel_ &&
       ContextProvider()->GetCapabilities().chromium_image_rgb_emulation) {
     GLuint fbo = 0;
 
     state_restorer_->SetClearStateDirty();
     gl_->GenFramebuffers(1, &fbo);
@@ skipping 84 matching lines @@
   if (pixel_unpack_buffer_binding_dirty_)
     client->DrawingBufferClientRestorePixelUnpackBufferBinding();
 }
 
 bool DrawingBuffer::ShouldUseChromiumImage() {
   return RuntimeEnabledFeatures::webGLImageChromiumEnabled() &&
          chromium_image_usage_ == kAllowChromiumImage;
 }
 
 }  // namespace blink