Add DrawingBuffer multisample resolve unit test.

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 48 matching lines @@
   }
 
  private:
   cc::TestGpuMemoryBufferManager test_gpu_memory_buffer_manager_;
 };
 
 }  // anonymous namespace
 
 class DrawingBufferTest : public Test {
  protected:
-  void SetUp() override {
+  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)));
     drawing_buffer_ = DrawingBufferForTests::Create(
-        std::move(provider), gl_, initial_size, DrawingBuffer::kPreserve);
+        std::move(provider), gl_, initial_size, DrawingBuffer::kPreserve,
+        use_multisampling);
     CHECK(drawing_buffer_);
   }
 
   // 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) {
     GLboolean scissor_enabled = !invert;
     GLfloat clear_color[4] = {0.1, 0.2, 0.3, 0.4};
     GLfloat clear_depth = 0.8;
@@ skipping 29 matching lines @@
 
     gl_->SaveState();
   }
 
   void VerifyStateWasRestored() { 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) {
   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.
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   VerifyStateWasRestored();
   EXPECT_EQ(initial_size, gl_->MostRecentlyProducedSize());
 
   // Resize to 100x50.
   drawing_buffer_->Resize(alternate_size);
   VerifyStateWasRestored();
   release_callback->Run(gpu::SyncToken(), false /* lostResource */);
   VerifyStateWasRestored();
 
   // Produce a mailbox at this size.
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   EXPECT_EQ(alternate_size, gl_->MostRecentlyProducedSize());
   VerifyStateWasRestored();
 
   // Reset to initial size.
   drawing_buffer_->Resize(initial_size);
   VerifyStateWasRestored();
   SetAndSaveRestoreState(true);
   release_callback->Run(gpu::SyncToken(), false /* lostResource */);
   VerifyStateWasRestored();
 
   // Prepare another mailbox and verify that it's the correct size.
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   EXPECT_EQ(initial_size, gl_->MostRecentlyProducedSize());
   VerifyStateWasRestored();
 
   // Prepare one final mailbox and verify that it's the correct size.
   release_callback->Run(gpu::SyncToken(), false /* lostResource */);
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   VerifyStateWasRestored();
   EXPECT_EQ(initial_size, gl_->MostRecentlyProducedSize());
   release_callback->Run(gpu::SyncToken(), false /* lostResource */);
   drawing_buffer_->BeginDestruction();
 }
 
 TEST_F(DrawingBufferTest, verifyDestructionCompleteAfterAllMailboxesReleased) {
   bool live = true;
   drawing_buffer_->live_ = &live;
 
   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;
 
   IntSize initial_size(kInitialWidth, kInitialHeight);
 
   // Produce mailboxes.
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   drawing_buffer_->ClearFramebuffers(GL_STENCIL_BUFFER_BIT);
   VerifyStateWasRestored();
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox1,
                                                      &release_callback1));
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   drawing_buffer_->ClearFramebuffers(GL_DEPTH_BUFFER_BIT);
   VerifyStateWasRestored();
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox2,
                                                      &release_callback2));
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   drawing_buffer_->ClearFramebuffers(GL_COLOR_BUFFER_BIT);
   VerifyStateWasRestored();
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox3,
                                                      &release_callback3));
 
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   release_callback1->Run(gpu::SyncToken(), false /* lostResource */);
 
   drawing_buffer_->BeginDestruction();
   ASSERT_EQ(live, true);
 
   DrawingBufferForTests* raw_pointer = drawing_buffer_.Get();
   drawing_buffer_.Clear();
   ASSERT_EQ(live, true);
 
-  raw_pointer->MarkContentsChanged();
+  EXPECT_FALSE(raw_pointer->MarkContentsChanged());
   release_callback2->Run(gpu::SyncToken(), false /* lostResource */);
   ASSERT_EQ(live, true);
 
-  raw_pointer->MarkContentsChanged();
+  EXPECT_FALSE(raw_pointer->MarkContentsChanged());
   release_callback3->Run(gpu::SyncToken(), false /* lostResource */);
   ASSERT_EQ(live, false);
 }
 
 TEST_F(DrawingBufferTest, verifyDrawingBufferStaysAliveIfResourcesAreLost) {
   bool live = true;
   drawing_buffer_->live_ = &live;
 
   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;
 
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox1,
                                                      &release_callback1));
   VerifyStateWasRestored();
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox2,
                                                      &release_callback2));
   VerifyStateWasRestored();
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox3,
                                                      &release_callback3));
   VerifyStateWasRestored();
 
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   release_callback1->Run(gpu::SyncToken(), true /* lostResource */);
   EXPECT_EQ(live, true);
 
   drawing_buffer_->BeginDestruction();
   EXPECT_EQ(live, true);
 
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   release_callback2->Run(gpu::SyncToken(), false /* lostResource */);
   EXPECT_EQ(live, true);
 
   DrawingBufferForTests* raw_ptr = drawing_buffer_.Get();
   drawing_buffer_.Clear();
   EXPECT_EQ(live, true);
 
-  raw_ptr->MarkContentsChanged();
+  EXPECT_FALSE(raw_ptr->MarkContentsChanged());
   release_callback3->Run(gpu::SyncToken(), true /* lostResource */);
   EXPECT_EQ(live, false);
 }
 
 TEST_F(DrawingBufferTest, verifyOnlyOneRecycledMailboxMustBeKept) {
   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;
 
   // Produce mailboxes.
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox1,
                                                      &release_callback1));
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox2,
                                                      &release_callback2));
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox3,
                                                      &release_callback3));
 
   // Release mailboxes by specific order; 1, 3, 2.
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   release_callback1->Run(gpu::SyncToken(), false /* lostResource */);
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   release_callback3->Run(gpu::SyncToken(), false /* lostResource */);
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   release_callback2->Run(gpu::SyncToken(), false /* lostResource */);
 
   // The first recycled mailbox must be 2. 1 and 3 were deleted by FIFO order
   // because DrawingBuffer never keeps more than one mailbox.
   cc::TextureMailbox recycled_texture_mailbox1;
   std::unique_ptr<cc::SingleReleaseCallback> recycled_release_callback1;
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(
       &recycled_texture_mailbox1, &recycled_release_callback1));
   EXPECT_EQ(texture_mailbox2.mailbox(), recycled_texture_mailbox1.mailbox());
 
   // The second recycled mailbox must be a new mailbox.
   cc::TextureMailbox recycled_texture_mailbox2;
   std::unique_ptr<cc::SingleReleaseCallback> recycled_release_callback2;
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(
       &recycled_texture_mailbox2, &recycled_release_callback2));
   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) {
   cc::TextureMailbox texture_mailbox;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback;
 
   // Produce mailboxes.
-  drawing_buffer_->MarkContentsChanged();
+  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());
 
   gpu::SyncToken wait_sync_token;
   gl_->GenSyncTokenCHROMIUM(gl_->InsertFenceSyncCHROMIUM(),
                             wait_sync_token.GetData());
   release_callback->Run(wait_sync_token, false /* lostResource */);
   // m_drawingBuffer will wait for the sync point when recycling.
   EXPECT_EQ(gpu::SyncToken(), gl_->MostRecentlyWaitedSyncToken());
 
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   // m_drawingBuffer waits for the sync point when recycling in
   // PrepareTextureMailbox().
   EXPECT_EQ(wait_sync_token, gl_->MostRecentlyWaitedSyncToken());
 
   drawing_buffer_->BeginDestruction();
   gl_->GenSyncTokenCHROMIUM(gl_->InsertFenceSyncCHROMIUM(),
                             wait_sync_token.GetData());
   release_callback->Run(wait_sync_token, false /* lostResource */);
@@ skipping 12 matching lines @@
         WTF::WrapUnique(new GLES2InterfaceForTests);
     gl_ = gl.get();
     SetAndSaveRestoreState(true);
     std::unique_ptr<WebGraphicsContext3DProviderForTests> provider =
         WTF::WrapUnique(
             new WebGraphicsContext3DProviderForTests(std::move(gl)));
     RuntimeEnabledFeatures::setWebGLImageChromiumEnabled(true);
     image_id0_ = gl_->NextImageIdToBeCreated();
     EXPECT_CALL(*gl_, BindTexImage2DMock(image_id0_)).Times(1);
     drawing_buffer_ = DrawingBufferForTests::Create(
-        std::move(provider), gl_, initial_size, DrawingBuffer::kPreserve);
+        std::move(provider), gl_, initial_size, DrawingBuffer::kPreserve,
+        kDisableMultisampling);
     CHECK(drawing_buffer_);
     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) {
   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.
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   EXPECT_EQ(initial_size, gl_->MostRecentlyProducedSize());
   EXPECT_TRUE(texture_mailbox.is_overlay_candidate());
   testing::Mock::VerifyAndClearExpectations(gl_);
   VerifyStateWasRestored();
 
   GLuint image_id2 = gl_->NextImageIdToBeCreated();
   EXPECT_CALL(*gl_, BindTexImage2DMock(image_id2)).Times(1);
   EXPECT_CALL(*gl_, DestroyImageMock(image_id0_)).Times(1);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(image_id0_)).Times(1);
   EXPECT_CALL(*gl_, DestroyImageMock(image_id1)).Times(1);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(image_id1)).Times(1);
   // Resize to 100x50.
   drawing_buffer_->Resize(alternate_size);
   VerifyStateWasRestored();
   release_callback->Run(gpu::SyncToken(), false /* lostResource */);
   VerifyStateWasRestored();
   testing::Mock::VerifyAndClearExpectations(gl_);
 
   GLuint image_id3 = gl_->NextImageIdToBeCreated();
   EXPECT_CALL(*gl_, BindTexImage2DMock(image_id3)).Times(1);
   // Produce a mailbox at this size.
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   EXPECT_EQ(alternate_size, gl_->MostRecentlyProducedSize());
   EXPECT_TRUE(texture_mailbox.is_overlay_candidate());
   testing::Mock::VerifyAndClearExpectations(gl_);
 
   GLuint image_id4 = gl_->NextImageIdToBeCreated();
   EXPECT_CALL(*gl_, BindTexImage2DMock(image_id4)).Times(1);
   EXPECT_CALL(*gl_, DestroyImageMock(image_id2)).Times(1);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(image_id2)).Times(1);
   EXPECT_CALL(*gl_, DestroyImageMock(image_id3)).Times(1);
   EXPECT_CALL(*gl_, ReleaseTexImage2DMock(image_id3)).Times(1);
   // Reset to initial size.
   drawing_buffer_->Resize(initial_size);
   VerifyStateWasRestored();
   release_callback->Run(gpu::SyncToken(), false /* lostResource */);
   VerifyStateWasRestored();
   testing::Mock::VerifyAndClearExpectations(gl_);
 
   GLuint image_id5 = gl_->NextImageIdToBeCreated();
   EXPECT_CALL(*gl_, BindTexImage2DMock(image_id5)).Times(1);
   // Prepare another mailbox and verify that it's the correct size.
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   EXPECT_EQ(initial_size, gl_->MostRecentlyProducedSize());
   EXPECT_TRUE(texture_mailbox.is_overlay_candidate());
   testing::Mock::VerifyAndClearExpectations(gl_);
 
   // Prepare one final mailbox and verify that it's the correct size.
   release_callback->Run(gpu::SyncToken(), false /* lostResource */);
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox,
                                                      &release_callback));
   EXPECT_EQ(initial_size, gl_->MostRecentlyProducedSize());
   EXPECT_TRUE(texture_mailbox.is_overlay_candidate());
   release_callback->Run(gpu::SyncToken(), false /* lostResource */);
 
   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) {
   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);
   IntSize initial_size(kInitialWidth, kInitialHeight);
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox1,
                                                      &release_callback1));
   EXPECT_TRUE(texture_mailbox1.is_overlay_candidate());
   testing::Mock::VerifyAndClearExpectations(gl_);
   VerifyStateWasRestored();
 
   // Force image CHROMIUM creation failure. Request another mailbox. It should
   // still be provided, but this time with allowOverlay = false.
   gl_->SetCreateImageChromiumFail(true);
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox2,
                                                      &release_callback2));
   EXPECT_FALSE(texture_mailbox2.is_overlay_candidate());
   VerifyStateWasRestored();
 
   // Check that if image CHROMIUM starts working again, mailboxes are
   // correctly created with allowOverlay = true.
   EXPECT_CALL(*gl_, BindTexImage2DMock(_)).Times(1);
   gl_->SetCreateImageChromiumFail(false);
-  drawing_buffer_->MarkContentsChanged();
+  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
   EXPECT_TRUE(drawing_buffer_->PrepareTextureMailbox(&texture_mailbox3,
                                                      &release_callback3));
   EXPECT_TRUE(texture_mailbox3.is_overlay_candidate());
   testing::Mock::VerifyAndClearExpectations(gl_);
   VerifyStateWasRestored();
 
   release_callback1->Run(gpu::SyncToken(), false /* lostResource */);
   release_callback2->Run(gpu::SyncToken(), false /* lostResource */);
   release_callback3->Run(gpu::SyncToken(), false /* lostResource */);
 
@@ skipping 150 matching lines @@
 
     drawing_buffer->BeginDestruction();
   }
 }
 
 TEST_F(DrawingBufferTest, verifySetIsHiddenProperlyAffectsMailboxes) {
   cc::TextureMailbox texture_mailbox;
   std::unique_ptr<cc::SingleReleaseCallback> release_callback;
 
   // Produce mailboxes.
-  drawing_buffer_->MarkContentsChanged();
+  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