Implement new behavior for DescheduleUntilFinishedCHROMIUM.

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 1700 matching lines @@
     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)
+        .Times(2)
         .WillOnce(Return(sync_service_id_))
+        .WillOnce(Return(sync_service_id2_))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, IsSync(sync_service_id_)).WillRepeatedly(Return(GL_TRUE));
-    EXPECT_CALL(*gl_, Flush()).RetiresOnSaturation();
+    EXPECT_CALL(*gl_, Flush()).Times(2).RetiresOnSaturation();
     EXPECT_CALL(*gl_, DeleteSync(sync_service_id_))
         .Times(1)
         .RetiresOnSaturation();
+    EXPECT_CALL(*gl_, DeleteSync(sync_service_id2_))
+        .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);
+  GLsync sync_service_id2_ = 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_);
+
+  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::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(0, deschedule_until_finished_callback_count_);
+  EXPECT_EQ(0, reschedule_after_finished_callback_count_);
+
   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";
@@ skipping 20 matching lines @@
                         ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service, GLES3DecoderTest, ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service,
                         GLES3DecoderWithESSL3ShaderTest,
                         ::testing::Bool());
 
 }  // namespace gles2
 }  // namespace gpu