Bind framebuffer to fbo_ object before readPixels, rather than multisample_fbo_

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

 /*
  * Copyright (C) 2013 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 55 matching lines @@
 }  // anonymous namespace
 
 class DrawingBufferTest : public Test {
  protected:
   void SetUp() override { Init(kDisableMultisampling); }
 
   void Init(UseMultisampling use_multisampling) {
     IntSize initial_size(kInitialWidth, kInitialHeight);
     std::unique_ptr<GLES2InterfaceForTests> gl =
         WTF::WrapUnique(new GLES2InterfaceForTests);
-    gl_ = gl.get();
-    SetAndSaveRestoreState(false);
     std::unique_ptr<WebGraphicsContext3DProviderForTests> provider =
         WTF::WrapUnique(
             new WebGraphicsContext3DProviderForTests(std::move(gl)));
+    GLES2InterfaceForTests* gl_ =
+        static_cast<GLES2InterfaceForTests*>(provider->ContextGL());
     drawing_buffer_ = DrawingBufferForTests::Create(
         std::move(provider), gl_, initial_size, DrawingBuffer::kPreserve,
         use_multisampling);
     CHECK(drawing_buffer_);
+    SetAndSaveRestoreState(false);
   }
 
   // Initialize GL state with unusual values, to verify that they are restored.
   // The |invert| parameter will reverse all boolean parameters, so that all
   // values are tested.
   void SetAndSaveRestoreState(bool invert) {
+    GLES2InterfaceForTests* gl_ = drawing_buffer_->ContextGLForTests();
     GLboolean scissor_enabled = !invert;
     GLfloat clear_color[4] = {0.1, 0.2, 0.3, 0.4};
     GLfloat clear_depth = 0.8;
     GLint clear_stencil = 37;
     GLboolean color_mask[4] = {invert, !invert, !invert, invert};
     GLboolean depth_mask = invert;
     GLboolean stencil_mask = invert;
     GLint pack_alignment = 7;
     GLuint active_texture2d_binding = 0xbeef1;
     GLuint renderbuffer_binding = 0xbeef2;
@@ skipping 16 matching lines @@
     gl_->PixelStorei(GL_PACK_ALIGNMENT, pack_alignment);
     gl_->BindTexture(GL_TEXTURE_2D, active_texture2d_binding);
     gl_->BindRenderbuffer(GL_RENDERBUFFER, renderbuffer_binding);
     gl_->BindFramebuffer(GL_DRAW_FRAMEBUFFER, draw_framebuffer_binding);
     gl_->BindFramebuffer(GL_READ_FRAMEBUFFER, read_framebuffer_binding);
     gl_->BindBuffer(GL_PIXEL_UNPACK_BUFFER, pixel_unpack_buffer_binding);
 
     gl_->SaveState();
   }
 
-  void VerifyStateWasRestored() { gl_->VerifyStateHasNotChangedSinceSave(); }
+  void VerifyStateWasRestored() {
+    GLES2InterfaceForTests* gl_ = drawing_buffer_->ContextGLForTests();
+    gl_->VerifyStateHasNotChangedSinceSave();
+  }
 
-  GLES2InterfaceForTests* gl_;
   RefPtr<DrawingBufferForTests> drawing_buffer_;
 };
 
 class DrawingBufferTestMultisample : public DrawingBufferTest {
  protected:
   void SetUp() override { Init(kEnableMultisampling); }
 };
 
 TEST_F(DrawingBufferTestMultisample, verifyMultisampleResolve) {
   // Initial state: already marked changed, multisampled
   EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->ExplicitResolveOfMultisampleData());
 
   // Resolve the multisample buffer
   drawing_buffer_->ResolveAndBindForReadAndDraw();
 
   // After resolve, acknowledge new content
   EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   // No new content
   EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
 
   drawing_buffer_->BeginDestruction();
 }
 
 TEST_F(DrawingBufferTest, verifyResizingProperlyAffectsMailboxes) {
+  GLES2InterfaceForTests* gl_ = drawing_buffer_->ContextGLForTests();
   VerifyStateWasRestored();
   cc::TextureMailbox texture_mailbox;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback;
 
   IntSize initial_size(kInitialWidth, kInitialHeight);
   IntSize alternate_size(kInitialWidth, kAlternateHeight);
 
   // Produce one mailbox at size 100x100.
   EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
@@ skipping 177 matching lines @@
   EXPECT_NE(texture_mailbox1.mailbox(), recycled_texture_mailbox2.mailbox());
   EXPECT_NE(texture_mailbox2.mailbox(), recycled_texture_mailbox2.mailbox());
   EXPECT_NE(texture_mailbox3.mailbox(), recycled_texture_mailbox2.mailbox());
 
   recycled_release_callback1->Run(gpu::SyncToken(), false /* lostResource */);
   recycled_release_callback2->Run(gpu::SyncToken(), false /* lostResource */);
   drawing_buffer_->BeginDestruction();
 }
 
 TEST_F(DrawingBufferTest, verifyInsertAndWaitSyncTokenCorrectly) {
+  GLES2InterfaceForTests* gl_ = drawing_buffer_->ContextGLForTests();
   cc::TextureMailbox texture_mailbox;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback;
 
   // Produce mailboxes.
   EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   EXPECT_EQ(gpu::SyncToken(), gl_->MostRecentlyWaitedSyncToken());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   // PrepareTextureMailbox() does not wait for any sync point.
   EXPECT_EQ(gpu::SyncToken(), gl_->MostRecentlyWaitedSyncToken());
@@ skipping 22 matching lines @@
 }
 
 class DrawingBufferImageChromiumTest : public DrawingBufferTest {
  protected:
   void SetUp() override {
     platform_.reset(new ScopedTestingPlatformSupport<FakePlatformSupport>);
 
     IntSize initial_size(kInitialWidth, kInitialHeight);
     std::unique_ptr<GLES2InterfaceForTests> gl =
         WTF::WrapUnique(new GLES2InterfaceForTests);
-    gl_ = gl.get();
-    SetAndSaveRestoreState(true);
     std::unique_ptr<WebGraphicsContext3DProviderForTests> provider =
         WTF::WrapUnique(
             new WebGraphicsContext3DProviderForTests(std::move(gl)));
     RuntimeEnabledFeatures::setWebGLImageChromiumEnabled(true);
+    GLES2InterfaceForTests* gl_ =
+        static_cast<GLES2InterfaceForTests*>(provider->ContextGL());
     image_id0_ = gl_->NextImageIdToBeCreated();
     EXPECT_CALL(*gl_, BindTexImage2DMock(image_id0_)).Times(1);
     drawing_buffer_ = DrawingBufferForTests::Create(
         std::move(provider), gl_, initial_size, DrawingBuffer::kPreserve,
         kDisableMultisampling);
     CHECK(drawing_buffer_);
+    SetAndSaveRestoreState(true);
     testing::Mock::VerifyAndClearExpectations(gl_);
   }
 
   void TearDown() override {
     RuntimeEnabledFeatures::setWebGLImageChromiumEnabled(false);
     platform_.reset();
   }
 
   GLuint image_id0_;
   std::unique_ptr<ScopedTestingPlatformSupport<FakePlatformSupport>> platform_;
 };
 
 TEST_F(DrawingBufferImageChromiumTest, verifyResizingReallocatesImages) {
+  GLES2InterfaceForTests* gl_ = drawing_buffer_->ContextGLForTests();
   cc::TextureMailbox texture_mailbox;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback;
 
   IntSize initial_size(kInitialWidth, kInitialHeight);
   IntSize alternate_size(kInitialWidth, kAlternateHeight);
 
   GLuint image_id1 = gl_->NextImageIdToBeCreated();
   EXPECT_CALL(*gl_, BindTexImage2DMock(image_id1)).Times(1);
   // Produce one mailbox at size 100x100.
   EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
@@ skipping 61 matching lines @@
 
   EXPECT_CALL(*gl_, DestroyImageMock(image_id5)).Times(1);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(image_id5)).Times(1);
   EXPECT_CALL(*gl_, DestroyImageMock(image_id4)).Times(1);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(image_id4)).Times(1);
   drawing_buffer_->BeginDestruction();
   testing::Mock::VerifyAndClearExpectations(gl_);
 }
 
 TEST_F(DrawingBufferImageChromiumTest, allocationFailure) {
+  GLES2InterfaceForTests* gl_ = drawing_buffer_->ContextGLForTests();
   cc::TextureMailbox texture_mailbox1;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback1;
   cc::TextureMailbox texture_mailbox2;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback2;
   cc::TextureMailbox texture_mailbox3;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback3;
 
   // Request a mailbox. An image should already be created. Everything works
   // as expected.
   EXPECT_CALL(*gl_, BindTexImage2DMock(_)).Times(1);
@@ skipping 178 matching lines @@
       EXPECT_EQ(0u, tracking_gl->DepthStencilAttachment());
       EXPECT_EQ(0u, tracking_gl->DepthAttachment());
       EXPECT_EQ(0u, tracking_gl->StencilAttachment());
     }
 
     drawing_buffer->BeginDestruction();
   }
 }
 
 TEST_F(DrawingBufferTest, verifySetIsHiddenProperlyAffectsMailboxes) {
+  GLES2InterfaceForTests* gl_ = drawing_buffer_->ContextGLForTests();
   cc::TextureMailbox texture_mailbox;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback;
 
   // Produce mailboxes.
   EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
 
   gpu::SyncToken wait_sync_token;
   gl_->GenSyncTokenCHROMIUM(gl_->InsertFenceSyncCHROMIUM(),
                             wait_sync_token.GetData());
   drawing_buffer_->SetIsHidden(true);
   release_callback->Run(wait_sync_token, false /* lostResource */);
   // m_drawingBuffer deletes mailbox immediately when hidden.
 
   EXPECT_EQ(wait_sync_token, gl_->MostRecentlyWaitedSyncToken());
 
   drawing_buffer_->BeginDestruction();
 }
 
 }  // namespace blink