Add a test for not signaling sync points after context loss

gpu/command_buffer/client/gles2_implementation_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Tests for GLES2Implementation.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 23 matching lines @@
 #endif
 
 using testing::_;
 using testing::AtLeast;
 using testing::AnyNumber;
 using testing::DoAll;
 using testing::InSequence;
 using testing::Invoke;
 using testing::Mock;
 using testing::Pointee;
+using testing::SaveArg;
 using testing::Sequence;
 using testing::StrictMock;
 using testing::Truly;
 using testing::Return;
 
 namespace gpu {
 namespace gles2 {
 
 ACTION_P2(SetMemory, dst, obj) {
   memcpy(dst, &obj, sizeof(obj));
@@ skipping 421 matching lines @@
           kMaxTransformFeedbackSeparateAttribs;
       capabilities.max_uniform_buffer_bindings = kMaxUniformBufferBindings;
       capabilities.bind_generates_resource_chromium =
           bind_generates_resource_service ? 1 : 0;
       capabilities.sync_query = sync_query;
       capabilities.occlusion_query_boolean = occlusion_query_boolean;
       capabilities.timer_queries = timer_queries;
       capabilities.major_version = major_version;
       capabilities.minor_version = minor_version;
       EXPECT_CALL(*gpu_control_, GetCapabilities())
-          .WillOnce(testing::Return(capabilities));
+          .WillOnce(Return(capabilities));
 
       {
         InSequence sequence;
 
         const bool support_client_side_arrays = true;
         gl_.reset(new GLES2Implementation(helper_.get(),
                                           share_group,
                                           transfer_buffer_.get(),
                                           bind_generates_resource_client,
                                           lose_context_when_out_of_memory,
                                           support_client_side_arrays,
                                           gpu_control_.get()));
       }
 
       // The client should be set to something non-null.
       EXPECT_CALL(*gpu_control_, SetGpuControlClient(gl_.get())).Times(1);
 
       if (!gl_->Initialize(kTransferBufferSize, kTransferBufferSize,
                            kTransferBufferSize, SharedMemoryLimits::kNoLimit))
         return false;
 
       helper_->CommandBufferHelper::Finish();
-      ::testing::Mock::VerifyAndClearExpectations(gl_.get());
+      Mock::VerifyAndClearExpectations(gl_.get());
 
       scoped_refptr<Buffer> ring_buffer = helper_->get_ring_buffer();
       commands_ = static_cast<CommandBufferEntry*>(ring_buffer->memory()) +
                   command_buffer()->GetPutOffset();
       ClearCommands();
       EXPECT_TRUE(transfer_buffer_->InSync());
 
-      ::testing::Mock::VerifyAndClearExpectations(command_buffer());
+      Mock::VerifyAndClearExpectations(command_buffer());
       return true;
     }
 
     void TearDown() {
       Mock::VerifyAndClear(gl_.get());
       EXPECT_CALL(*command_buffer(), OnFlush()).Times(AnyNumber());
       // For command buffer.
       EXPECT_CALL(*command_buffer(), DestroyTransferBuffer(_))
           .Times(AtLeast(1));
       // The client should be unset.
@@ skipping 3414 matching lines @@
   EXPECT_EQ(GL_NO_ERROR, CheckError());
 
   // No more corresponding begin tracer marker should error.
   gl_->TraceEndCHROMIUM();
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
 }
 
 TEST_F(GLES2ImplementationTest, InsertFenceSyncCHROMIUM) {
   const GLuint64 kFenceSync = 123u;
   EXPECT_CALL(*gpu_control_, GenerateFenceSyncRelease())
-      .WillOnce(testing::Return(kFenceSync));
+      .WillOnce(Return(kFenceSync));
 
   struct Cmds {
     cmds::InsertFenceSyncCHROMIUM insert_fence_sync;
   };
   Cmds expected;
   expected.insert_fence_sync.Init(kFenceSync);
 
   const GLuint64 fence_sync = gl_->InsertFenceSyncCHROMIUM();
   EXPECT_EQ(kFenceSync, fence_sync);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, GenSyncTokenCHROMIUM) {
   const CommandBufferNamespace kNamespaceId = CommandBufferNamespace::GPU_IO;
   const CommandBufferId kCommandBufferId =
       CommandBufferId::FromUnsafeValue(234u);
   const GLuint64 kFenceSync = 123u;
   GLbyte sync_token_data[GL_SYNC_TOKEN_SIZE_CHROMIUM];
 
   EXPECT_CALL(*gpu_control_, GetNamespaceID())
-      .WillRepeatedly(testing::Return(kNamespaceId));
+      .WillRepeatedly(Return(kNamespaceId));
   EXPECT_CALL(*gpu_control_, GetCommandBufferID())
-      .WillRepeatedly(testing::Return(kCommandBufferId));
+      .WillRepeatedly(Return(kCommandBufferId));
   EXPECT_CALL(*gpu_control_, GetExtraCommandBufferData())
-      .WillRepeatedly(testing::Return(0));
+      .WillRepeatedly(Return(0));
 
   gl_->GenSyncTokenCHROMIUM(kFenceSync, nullptr);
   EXPECT_EQ(GL_INVALID_VALUE, CheckError());
 
   EXPECT_CALL(*gpu_control_, IsFenceSyncRelease(kFenceSync))
-      .WillOnce(testing::Return(false));
+      .WillOnce(Return(false));
   gl_->GenSyncTokenCHROMIUM(kFenceSync, sync_token_data);
   EXPECT_EQ(GL_INVALID_VALUE, CheckError());
 
   EXPECT_CALL(*gpu_control_, IsFenceSyncRelease(kFenceSync))
-      .WillOnce(testing::Return(true));
+      .WillOnce(Return(true));
   EXPECT_CALL(*gpu_control_, IsFenceSyncFlushReceived(kFenceSync))
-      .WillOnce(testing::Return(false));
+      .WillOnce(Return(false));
   gl_->GenSyncTokenCHROMIUM(kFenceSync, sync_token_data);
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
 
   EXPECT_CALL(*gpu_control_, IsFenceSyncRelease(kFenceSync))
-      .WillOnce(testing::Return(true));
+      .WillOnce(Return(true));
   EXPECT_CALL(*gpu_control_, IsFenceSyncFlushReceived(kFenceSync))
-      .WillOnce(testing::Return(true));
+      .WillOnce(Return(true));
   ClearCommands();
   gl_->GenSyncTokenCHROMIUM(kFenceSync, sync_token_data);
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(GL_NO_ERROR, CheckError());
 
   SyncToken sync_token;
   memcpy(&sync_token, sync_token_data, sizeof(SyncToken));
   EXPECT_TRUE(sync_token.verified_flush());
   EXPECT_EQ(kNamespaceId, sync_token.namespace_id());
   EXPECT_EQ(kCommandBufferId, sync_token.command_buffer_id());
   EXPECT_EQ(kFenceSync, sync_token.release_count());
 }
 
 TEST_F(GLES2ImplementationTest, GenUnverifiedSyncTokenCHROMIUM) {
   const CommandBufferNamespace kNamespaceId = CommandBufferNamespace::GPU_IO;
   const CommandBufferId kCommandBufferId =
       CommandBufferId::FromUnsafeValue(234u);
   const GLuint64 kFenceSync = 123u;
   GLbyte sync_token_data[GL_SYNC_TOKEN_SIZE_CHROMIUM];
 
   EXPECT_CALL(*gpu_control_, GetNamespaceID())
-      .WillRepeatedly(testing::Return(kNamespaceId));
+      .WillRepeatedly(Return(kNamespaceId));
   EXPECT_CALL(*gpu_control_, GetCommandBufferID())
-      .WillRepeatedly(testing::Return(kCommandBufferId));
+      .WillRepeatedly(Return(kCommandBufferId));
   EXPECT_CALL(*gpu_control_, GetExtraCommandBufferData())
-      .WillRepeatedly(testing::Return(0));
+      .WillRepeatedly(Return(0));
 
   gl_->GenUnverifiedSyncTokenCHROMIUM(kFenceSync, nullptr);
   EXPECT_EQ(GL_INVALID_VALUE, CheckError());
 
   EXPECT_CALL(*gpu_control_, IsFenceSyncRelease(kFenceSync))
-      .WillOnce(testing::Return(false));
+      .WillOnce(Return(false));
   gl_->GenUnverifiedSyncTokenCHROMIUM(kFenceSync, sync_token_data);
   EXPECT_EQ(GL_INVALID_VALUE, CheckError());
 
   EXPECT_CALL(*gpu_control_, IsFenceSyncRelease(kFenceSync))
-      .WillOnce(testing::Return(true));
+      .WillOnce(Return(true));
   EXPECT_CALL(*gpu_control_, IsFenceSyncFlushed(kFenceSync))
-      .WillOnce(testing::Return(false));
+      .WillOnce(Return(false));
   gl_->GenUnverifiedSyncTokenCHROMIUM(kFenceSync, sync_token_data);
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
 
   EXPECT_CALL(*gpu_control_, IsFenceSyncRelease(kFenceSync))
-      .WillOnce(testing::Return(true));
+      .WillOnce(Return(true));
   EXPECT_CALL(*gpu_control_, IsFenceSyncFlushed(kFenceSync))
-      .WillOnce(testing::Return(true));
+      .WillOnce(Return(true));
   ClearCommands();
   gl_->GenUnverifiedSyncTokenCHROMIUM(kFenceSync, sync_token_data);
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(GL_NO_ERROR, CheckError());
 
   SyncToken sync_token;
   memcpy(&sync_token, sync_token_data, sizeof(SyncToken));
   EXPECT_FALSE(sync_token.verified_flush());
   EXPECT_EQ(kNamespaceId, sync_token.namespace_id());
   EXPECT_EQ(kCommandBufferId, sync_token.command_buffer_id());
   EXPECT_EQ(kFenceSync, sync_token.release_count());
 }
 
 TEST_F(GLES2ImplementationTest, VerifySyncTokensCHROMIUM) {
   ExpectedMemoryInfo result =
       GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillRepeatedly(SetMemory(result.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
 
   const CommandBufferNamespace kNamespaceId = CommandBufferNamespace::GPU_IO;
   const CommandBufferId kCommandBufferId =
       CommandBufferId::FromUnsafeValue(234u);
   const GLuint64 kFenceSync = 123u;
   gpu::SyncToken sync_token;
   GLbyte* sync_token_datas[] = { sync_token.GetData() };
 
   EXPECT_CALL(*gpu_control_, GetNamespaceID())
-      .WillRepeatedly(testing::Return(kNamespaceId));
+      .WillRepeatedly(Return(kNamespaceId));
   EXPECT_CALL(*gpu_control_, GetCommandBufferID())
-      .WillRepeatedly(testing::Return(kCommandBufferId));
+      .WillRepeatedly(Return(kCommandBufferId));
   EXPECT_CALL(*gpu_control_, GetExtraCommandBufferData())
-      .WillRepeatedly(testing::Return(0));
+      .WillRepeatedly(Return(0));
 
   EXPECT_CALL(*gpu_control_, IsFenceSyncRelease(kFenceSync))
-      .WillOnce(testing::Return(true));
+      .WillOnce(Return(true));
   EXPECT_CALL(*gpu_control_, IsFenceSyncFlushed(kFenceSync))
-      .WillOnce(testing::Return(true));
+      .WillOnce(Return(true));
   gl_->GenUnverifiedSyncTokenCHROMIUM(kFenceSync, sync_token.GetData());
   ASSERT_TRUE(sync_token.HasData());
   ASSERT_FALSE(sync_token.verified_flush());
 
   ClearCommands();
   EXPECT_CALL(*gpu_control_, CanWaitUnverifiedSyncToken(_))
-      .WillOnce(testing::Return(false));
+      .WillOnce(Return(false));
   gl_->VerifySyncTokensCHROMIUM(sync_token_datas, 1);
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE), gl_->GetError());
   EXPECT_FALSE(sync_token.verified_flush());
 
   ClearCommands();
   EXPECT_CALL(*gpu_control_, CanWaitUnverifiedSyncToken(_))
-      .WillOnce(testing::Return(true));
+      .WillOnce(Return(true));
   EXPECT_CALL(*gpu_control_, EnsureWorkVisible());
   gl_->VerifySyncTokensCHROMIUM(sync_token_datas, arraysize(sync_token_datas));
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(GL_NO_ERROR, CheckError());
 
   EXPECT_EQ(kNamespaceId, sync_token.namespace_id());
   EXPECT_EQ(kCommandBufferId, sync_token.command_buffer_id());
   EXPECT_EQ(kFenceSync, sync_token.release_count());
   EXPECT_TRUE(sync_token.verified_flush());
 }
@@ skipping 61 matching lines @@
 }
 
 TEST_F(GLES2ImplementationTest, WaitSyncTokenCHROMIUM) {
   const CommandBufferNamespace kNamespaceId = CommandBufferNamespace::GPU_IO;
   const CommandBufferId kCommandBufferId =
       CommandBufferId::FromUnsafeValue(234u);
   const GLuint64 kFenceSync = 456u;
   GLbyte sync_token[GL_SYNC_TOKEN_SIZE_CHROMIUM];
 
   EXPECT_CALL(*gpu_control_, IsFenceSyncRelease(kFenceSync))
-      .WillOnce(testing::Return(true));
+      .WillOnce(Return(true));
   EXPECT_CALL(*gpu_control_, IsFenceSyncFlushReceived(kFenceSync))
-      .WillOnce(testing::Return(true));
-  EXPECT_CALL(*gpu_control_, GetNamespaceID())
-      .WillOnce(testing::Return(kNamespaceId));
+      .WillOnce(Return(true));
+  EXPECT_CALL(*gpu_control_, GetNamespaceID()).WillOnce(Return(kNamespaceId));
   EXPECT_CALL(*gpu_control_, GetCommandBufferID())
-      .WillOnce(testing::Return(kCommandBufferId));
-  EXPECT_CALL(*gpu_control_, GetExtraCommandBufferData())
-      .WillOnce(testing::Return(0));
+      .WillOnce(Return(kCommandBufferId));
+  EXPECT_CALL(*gpu_control_, GetExtraCommandBufferData()).WillOnce(Return(0));
   gl_->GenSyncTokenCHROMIUM(kFenceSync, sync_token);
 
   struct Cmds {
     cmds::WaitSyncTokenCHROMIUM wait_sync_token;
   };
   Cmds expected;
   expected.wait_sync_token.Init(kNamespaceId, kCommandBufferId.GetUnsafeValue(),
                                 kFenceSync);
 
   gl_->WaitSyncTokenCHROMIUM(sync_token);
@@ skipping 18 matching lines @@
   gpu::SyncToken invalid_sync_token;
   gl_->WaitSyncTokenCHROMIUM(invalid_sync_token.GetConstData());
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
 
   // Unverified sync token should produce INVALID_OPERATION.
   ClearCommands();
   gpu::SyncToken unverified_sync_token(CommandBufferNamespace::GPU_IO, 0,
                                        gpu::CommandBufferId(), 0);
   EXPECT_CALL(*gpu_control_, CanWaitUnverifiedSyncToken(_))
-      .WillOnce(testing::Return(false));
+      .WillOnce(Return(false));
   gl_->WaitSyncTokenCHROMIUM(unverified_sync_token.GetConstData());
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE), gl_->GetError());
 }
 
 TEST_F(GLES2ImplementationTest, IsEnabled) {
   // If we use a valid enum, its state is cached on client side, so no command
   // is actually generated, and this test will fail.
   // TODO(zmo): it seems we never need the command. Maybe remove it.
   GLenum kCap = 1;
@@ skipping 210 matching lines @@
                     result1.id, result1.offset);
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr,
                           SizedResultHelper<ResultType>(kNumSampleCounts)))
       .RetiresOnSaturation();
   gl_->GetInternalformativ(123, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 1, &result);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_EQ(static_cast<ResultType>(kNumSampleCounts), result);
 }
 
+static void CountCallback(int* count) {
+  (*count)++;
+}
+
+TEST_F(GLES2ImplementationTest, SignalSyncToken) {
+  EXPECT_CALL(*gpu_control_, GenerateFenceSyncRelease()).WillOnce(Return(1));
+  const uint64_t fence_sync = gl_->InsertFenceSyncCHROMIUM();
+  gl_->ShallowFlushCHROMIUM();
+
+  EXPECT_CALL(*gpu_control_, IsFenceSyncRelease(fence_sync))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*gpu_control_, IsFenceSyncFlushReceived(fence_sync))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*gpu_control_, GetNamespaceID()).WillOnce(Return(GPU_IO));
+  EXPECT_CALL(*gpu_control_, GetExtraCommandBufferData()).WillOnce(Return(0));
+  EXPECT_CALL(*gpu_control_, GetCommandBufferID())
+      .WillOnce(Return(CommandBufferId::FromUnsafeValue(1)));
+  gpu::SyncToken sync_token;
+  gl_->GenSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
+
+  int signaled_count = 0;
+
+  // Request a signal sync token, which gives a callback to the GpuControl to
+  // run when the sync token is reached.
+  base::Closure signal_closure;
+  EXPECT_CALL(*gpu_control_, SignalSyncToken(_, _))
+      .WillOnce(SaveArg<1>(&signal_closure));
+  gl_->SignalSyncToken(sync_token, base::Bind(&CountCallback, &signaled_count));
+  EXPECT_EQ(0, signaled_count);
+
+  // When GpuControl runs the callback, the original callback we gave to
+  // GLES2Implementation is run.
+  signal_closure.Run();
+  EXPECT_EQ(1, signaled_count);
+}
+
+TEST_F(GLES2ImplementationTest, SignalSyncTokenAfterContextLoss) {
+  EXPECT_CALL(*gpu_control_, GenerateFenceSyncRelease()).WillOnce(Return(1));
+  const uint64_t fence_sync = gl_->InsertFenceSyncCHROMIUM();
+  gl_->ShallowFlushCHROMIUM();
+
+  EXPECT_CALL(*gpu_control_, IsFenceSyncRelease(fence_sync))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*gpu_control_, IsFenceSyncFlushReceived(fence_sync))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*gpu_control_, GetNamespaceID()).WillOnce(Return(GPU_IO));
+  EXPECT_CALL(*gpu_control_, GetExtraCommandBufferData()).WillOnce(Return(0));
+  EXPECT_CALL(*gpu_control_, GetCommandBufferID())
+      .WillOnce(Return(CommandBufferId::FromUnsafeValue(1)));
+  gpu::SyncToken sync_token;
+  gl_->GenSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
+
+  int signaled_count = 0;
+
+  // Request a signal sync token, which gives a callback to the GpuControl to
+  // run when the sync token is reached.
+  base::Closure signal_closure;
+  EXPECT_CALL(*gpu_control_, SignalSyncToken(_, _))
+      .WillOnce(SaveArg<1>(&signal_closure));
+  gl_->SignalSyncToken(sync_token, base::Bind(&CountCallback, &signaled_count));
+  EXPECT_EQ(0, signaled_count);
+
+  // Inform the GLES2Implementation that the context is lost.
+  GpuControlClient* gl_as_client = gl_;
+  gl_as_client->OnGpuControlLostContext();
+
+  // When GpuControl runs the callback, the original callback we gave to
+  // GLES2Implementation is *not* run, since the context is lost and we
+  // have already run the lost context callback.
+  signal_closure.Run();
+  EXPECT_EQ(0, signaled_count);
+}
+
 TEST_F(GLES2ImplementationManualInitTest, LoseContextOnOOM) {
   ContextInitOptions init_options;
   init_options.lose_context_when_out_of_memory = true;
   ASSERT_TRUE(Initialize(init_options));
 
   struct Cmds {
     cmds::LoseContextCHROMIUM cmd;
   };
 
   GLsizei max = std::numeric_limits<GLsizei>::max();
@@ skipping 42 matching lines @@
   ContextInitOptions init_options;
   init_options.transfer_buffer_initialize_fail = true;
   EXPECT_FALSE(Initialize(init_options));
 }
 
 #include "base/macros.h"
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu