gpu: Add a new extension CHROMIUM_deschedule.

gpu/command_buffer/service/gles2_cmd_decoder_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.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/command_line.h"
@@ skipping 1674 matching lines @@
   cmds_[1].header.size += 1;
   int num_processed = -1;
   SetExpectationsForNCommands(1);
   EXPECT_EQ(error::kInvalidArguments,
             decoder_->DoCommands(
                 2, &cmds_, entries_per_cmd_ * 2 + 1, &num_processed));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(entries_per_cmd_ + cmds_[1].header.size, num_processed);
 }
 
+class GLES2DecoderDescheduleUntilFinishedTest : public GLES2DecoderTest {
+ public:
+  GLES2DecoderDescheduleUntilFinishedTest() {
+  }
+
+  void SetUp() override {
+    InitState init;
+    init.gl_version = "4.4";
+    init.extensions += " GL_ARB_compatibility GL_ARB_sync";
+    InitDecoder(init);
+
+    GetDecoder()->SetDescheduleUntilFinishedCallback(
+        base::Bind(&GLES2DecoderDescheduleUntilFinishedTest::
+                       DescheduleUntilFinishedCallback,
+                   base::Unretained(this)));
+    GetDecoder()->SetRescheduleAfterFinishedCallback(
+        base::Bind(&GLES2DecoderDescheduleUntilFinishedTest::
+                       RescheduleAfterFinishedCallback,
+                   base::Unretained(this)));
+
+    EXPECT_CALL(*gl_, FenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0))
+        .Times(1)
+        .WillOnce(Return(sync_service_id_))
+        .RetiresOnSaturation();
+    EXPECT_CALL(*gl_, IsSync(sync_service_id_)).WillRepeatedly(Return(GL_TRUE));
+    EXPECT_CALL(*gl_, Flush()).RetiresOnSaturation();
+    EXPECT_CALL(*gl_, DeleteSync(sync_service_id_))
+        .Times(1)
+        .RetiresOnSaturation();
+  }
+
+  void DescheduleUntilFinishedCallback() {
+    deschedule_until_finished_callback_count_++;
+  }
+  void RescheduleAfterFinishedCallback() {
+    reschedule_after_finished_callback_count_++;
+  }
+
+ protected:
+  int deschedule_until_finished_callback_count_ = 0;
+  int reschedule_after_finished_callback_count_ = 0;
+  GLsync sync_service_id_ = reinterpret_cast<GLsync>(0x15);
+};
+
+TEST_P(GLES2DecoderDescheduleUntilFinishedTest, AlreadySignalled) {
+  EXPECT_CALL(*gl_, ClientWaitSync(sync_service_id_, 0, 0))
+      .Times(1)
+      .WillOnce(Return(GL_ALREADY_SIGNALED))
+      .RetiresOnSaturation();
+
+  cmds::DescheduleUntilFinishedCHROMIUM cmd;
+  cmd.Init();
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(0, deschedule_until_finished_callback_count_);
+  EXPECT_EQ(0, reschedule_after_finished_callback_count_);
+}
+
+TEST_P(GLES2DecoderDescheduleUntilFinishedTest, NotYetSignalled) {
+  EXPECT_CALL(*gl_, ClientWaitSync(sync_service_id_, 0, 0))
+      .Times(1)
+      .WillOnce(Return(GL_TIMEOUT_EXPIRED))
+      .RetiresOnSaturation();
+
+  cmds::DescheduleUntilFinishedCHROMIUM cmd;
+  cmd.Init();
+  EXPECT_EQ(error::kDeferLaterCommands, ExecuteCmd(cmd));
+  EXPECT_EQ(1, deschedule_until_finished_callback_count_);
+  EXPECT_EQ(0, reschedule_after_finished_callback_count_);
+}
+
 void GLES3DecoderWithESSL3ShaderTest::SetUp() {
   base::CommandLine command_line(0, nullptr);
   command_line.AppendSwitch(switches::kEnableUnsafeES3APIs);
   InitState init;
   init.gl_version = "OpenGL ES 3.0";
   init.bind_generates_resource = true;
   init.context_type = CONTEXT_TYPE_OPENGLES3;
   InitDecoderWithCommandLine(init, &command_line);
   SetupDefaultProgram();
 }
 
 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderTest, ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderWithShaderTest, ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderManualInitTest, ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service,
                         GLES2DecoderRGBBackbufferTest,
                         ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderDoCommandsTest, ::testing::Bool());
 
+INSTANTIATE_TEST_CASE_P(Service,
+                        GLES2DecoderDescheduleUntilFinishedTest,
+                        ::testing::Bool());
+
 INSTANTIATE_TEST_CASE_P(Service, GLES3DecoderTest, ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service,
                         GLES3DecoderWithESSL3ShaderTest,
                         ::testing::Bool());
 
 }  // namespace gles2
 }  // namespace gpu