Fix blits from multisampled renderbuffers to alpha:false WebGL back buffer.

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

 /*
  * 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 212 matching lines @@
   // Rebind the read and draw framebuffers that WebGL is expecting.
   void RestoreFramebufferBindings();
 
   // Restore all state that may have been dirtied by any call.
   void RestoreAllState();
 
   void AddNewMailboxCallback(std::unique_ptr<WTF::Closure> closure) {
     new_mailbox_callback_ = std::move(closure);
   }
 
+  // This class helps implement correct semantics for BlitFramebuffer
+  // when the DrawingBuffer is using a CHROMIUM image for its backing
+  // store and RGB emulation is in use (basically, macOS only).
+  class ScopedRGBEmulationForBlitFramebuffer {
+   public:
+    ScopedRGBEmulationForBlitFramebuffer(DrawingBuffer*);
+    ~ScopedRGBEmulationForBlitFramebuffer();
+
+   private:
+    RefPtr<DrawingBuffer> drawing_buffer_;
+    bool doing_work_ = false;
+  };
+
  protected:  // For unittests
   DrawingBuffer(std::unique_ptr<WebGraphicsContext3DProvider>,
                 std::unique_ptr<Extensions3DUtil>,
                 Client*,
                 bool discard_framebuffer_supported,
                 bool want_alpha_channel,
                 bool premultiplied_alpha,
                 PreserveDrawingBuffer,
                 WebGLVersion,
                 bool wants_depth,
                 bool wants_stencil,
                 ChromiumImageUsage);
 
   bool Initialize(const IntSize&, bool use_multisampling);
 
   // Shared memory bitmaps that were released by the compositor and can be used
   // again by this DrawingBuffer.
   struct RecycledBitmap {
     std::unique_ptr<cc::SharedBitmap> bitmap;
     IntSize size;
   };
   Vector<RecycledBitmap> recycled_bitmaps_;
 
  private:
+  friend class ScopedRGBEmulationForBlitFramebuffer;
   friend class ScopedStateRestorer;
   friend class ColorBuffer;
 
   // This structure should wrap all public entrypoints that may modify GL state.
   // It will restore all state when it drops out of scope.
   class ScopedStateRestorer {
    public:
     ScopedStateRestorer(DrawingBuffer*);
     ~ScopedStateRestorer();
 
@@ skipping 46 matching lines @@
     // ColorBuffers.
     RefPtr<DrawingBuffer> drawing_buffer;
 
     const ColorBufferParameters parameters;
     const IntSize size;
 
     const GLuint texture_id = 0;
     const GLuint image_id = 0;
     std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer;
 
+    // If we're emulating an RGB back buffer using an RGBA Chromium
+    // image (essentially macOS only), then when performing
+    // BlitFramebuffer calls, we have to swap in an RGB texture in
+    // place of the RGBA texture bound to the image. The reason is
+    // that BlitFramebuffer requires the internal formats of the
+    // source and destination to match (e.g. RGB8 on both sides).
+    // There are bugs in the semantics of RGB8 textures in this
+    // situation (the alpha channel is zeroed), requiring more fixups.
+    GLuint rgb_workaround_texture_id = 0;
+
     // The mailbox used to send this buffer to the compositor.
     gpu::Mailbox mailbox;
 
     // The sync token for when this buffer was sent to the compositor.
     gpu::SyncToken produce_sync_token;
 
     // The sync token for when this buffer was received back from the
     // compositor.
     gpu::SyncToken receive_sync_token;
 
@@ skipping 91 matching lines @@
   // implemented by forwarding all draw operations to a multisample
   // renderbuffer, which is resolved before any read operations or swaps.
   bool WantExplicitResolve();
 
   // Whether the WebGL client wants a depth or stencil buffer.
   bool WantDepthOrStencil();
 
   // The format to use when creating a multisampled renderbuffer.
   GLenum GetMultisampledRenderbufferFormat();
 
+  // Helpers to ensure correct behavior of BlitFramebuffer when using
+  // an emulated RGB CHROMIUM_image back buffer.
+  bool SetupRGBEmulationForBlitFramebuffer();
+  void CleanupRGBEmulationForBlitFramebuffer();
+
   // Weak, reset by beginDestruction.
   Client* client_ = nullptr;
 
   const PreserveDrawingBuffer preserve_drawing_buffer_;
   const WebGLVersion web_gl_version_;
 
   std::unique_ptr<WebGraphicsContext3DProviderWrapper> context_provider_;
   // Lifetime is tied to the m_contextProvider.
   gpu::gles2::GLES2Interface* gl_;
   std::unique_ptr<Extensions3DUtil> extensions_util_;
   IntSize size_ = {-1, -1};
   const bool discard_framebuffer_supported_;
   const bool want_alpha_channel_;
   const bool premultiplied_alpha_;
   const bool software_rendering_;
   bool has_implicit_stencil_buffer_ = false;
   bool storage_texture_supported_ = false;
 
   std::unique_ptr<WTF::Closure> new_mailbox_callback_;
 
-  // The current state restorer, which is used to track state dirtying. It is in
+  // The current state restorer, which is used to track state dirtying. It is an
   // error to dirty state shared with WebGL while there is no existing state
-  // restorer. It is also in error to instantiate two state restorers at once.
+  // restorer.
   ScopedStateRestorer* state_restorer_ = nullptr;
 
   // This is used when the user requests either a depth or stencil buffer.
   GLuint depth_stencil_buffer_ = 0;
 
   // When wantExplicitResolve() returns true, the target of all draw
   // operations.
   GLuint multisample_fbo_ = 0;
 
   // The id of the renderbuffer storage for |m_multisampleFBO|.
@@ skipping 61 matching lines @@
   // RuntimeEnabledFeatures::webGLImageChromiumEnabled() call with
   // shouldUseChromiumImage() calls, and set m_chromiumImageUsage to
   // DisallowChromiumImage in the case of OffscreenCanvas.
   ChromiumImageUsage chromium_image_usage_;
   bool ShouldUseChromiumImage();
 };
 
 }  // namespace blink
 
 #endif  // DrawingBuffer_h