Revert of gpu: Add CHROMIUM_sync_query extension.

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.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
@@ skipping 7094 matching lines @@
   GLenum type;
   bool is_gl;
 };
 
 const QueryType kQueryTypes[] = {
   { GL_COMMANDS_ISSUED_CHROMIUM, false },
   { GL_LATENCY_QUERY_CHROMIUM, false },
   { GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM, false },
   { GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, false },
   { GL_GET_ERROR_QUERY_CHROMIUM, false },
-  { GL_COMMANDS_COMPLETED_CHROMIUM, false },
   { GL_ANY_SAMPLES_PASSED_EXT, true },
 };
 
 static void CheckBeginEndQueryBadMemoryFails(
     GLES2DecoderTestBase* test,
     GLuint client_id,
     GLuint service_id,
     const QueryType& query_type,
     int32 shm_id,
     uint32 shm_offset) {
   // We need to reset the decoder on each iteration, because we lose the
   // context every time.
   GLES2DecoderTestBase::InitState init;
-  init.extensions = "GL_EXT_occlusion_query_boolean GL_ARB_sync";
+  init.extensions = "GL_EXT_occlusion_query_boolean";
   init.gl_version = "opengl es 2.0";
   init.has_alpha = true;
   init.request_alpha = true;
   init.bind_generates_resource = true;
   test->InitDecoder(init);
   ::testing::StrictMock< ::gfx::MockGLInterface>* gl = test->GetGLMock();
 
   BeginQueryEXT begin_cmd;
 
   test->GenHelper<GenQueriesEXTImmediate>(client_id);
@@ skipping 14 matching lines @@
   if (query_type.is_gl) {
     EXPECT_CALL(*gl, EndQueryARB(query_type.type))
         .Times(1)
         .RetiresOnSaturation();
   }
   if (query_type.type == GL_GET_ERROR_QUERY_CHROMIUM) {
     EXPECT_CALL(*gl, GetError())
         .WillOnce(Return(GL_NO_ERROR))
         .RetiresOnSaturation();
   }
-  GLsync kGlSync = reinterpret_cast<GLsync>(0xdeadbeef);
-  if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM) {
-    EXPECT_CALL(*gl, Flush()).RetiresOnSaturation();
-    EXPECT_CALL(*gl, FenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0))
-        .WillOnce(Return(kGlSync))
-        .RetiresOnSaturation();
-  }
 
   EndQueryEXT end_cmd;
   end_cmd.Init(query_type.type, 1);
   error::Error error2 = test->ExecuteCmd(end_cmd);
 
   if (query_type.is_gl) {
     EXPECT_CALL(*gl,
         GetQueryObjectuivARB(service_id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
         .WillOnce(SetArgumentPointee<2>(1))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl,
         GetQueryObjectuivARB(service_id, GL_QUERY_RESULT_EXT, _))
         .WillOnce(SetArgumentPointee<2>(1))
         .RetiresOnSaturation();
   }
-  if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM) {
-    EXPECT_CALL(*gl, ClientWaitSync(kGlSync, _, _))
-        .WillOnce(Return(GL_ALREADY_SIGNALED))
-        .RetiresOnSaturation();
-  }
 
   QueryManager* query_manager = test->GetDecoder()->GetQueryManager();
   ASSERT_TRUE(query_manager != NULL);
   bool process_success = query_manager->ProcessPendingQueries();
 
   EXPECT_TRUE(error1 != error::kNoError ||
               error2 != error::kNoError ||
               !process_success);
 
   if (query_type.is_gl) {
     EXPECT_CALL(*gl, DeleteQueriesARB(1, _))
         .Times(1)
         .RetiresOnSaturation();
   }
-  if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM)
-    EXPECT_CALL(*gl, DeleteSync(kGlSync)).Times(1).RetiresOnSaturation();
   test->ResetDecoder();
 }
 
 TEST_F(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryIdFails) {
   for (size_t i = 0; i < arraysize(kQueryTypes); ++i) {
     CheckBeginEndQueryBadMemoryFails(
         this, kNewClientId, kNewServiceId,
         kQueryTypes[i],
         kInvalidSharedMemoryId, kSharedMemoryOffset);
   }
@@ skipping 67 matching lines @@
 
   EndQueryEXT end_cmd;
   end_cmd.Init(GL_GET_ERROR_QUERY_CHROMIUM, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_FALSE(query->pending());
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE),
             static_cast<GLenum>(sync->result));
 }
 
-TEST_F(GLES2DecoderManualInitTest, BeginEndQueryEXTCommandsCompletedCHROMIUM) {
-  InitState init;
-  init.extensions = "GL_EXT_occlusion_query_boolean GL_ARB_sync";
-  init.gl_version = "opengl es 2.0";
-  init.has_alpha = true;
-  init.request_alpha = true;
-  init.bind_generates_resource = true;
-  InitDecoder(init);
-
-  GenHelper<GenQueriesEXTImmediate>(kNewClientId);
-
-  BeginQueryEXT begin_cmd;
-  begin_cmd.Init(GL_COMMANDS_COMPLETED_CHROMIUM,
-                 kNewClientId,
-                 kSharedMemoryId,
-                 kSharedMemoryOffset);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-
-  QueryManager* query_manager = decoder_->GetQueryManager();
-  ASSERT_TRUE(query_manager != NULL);
-  QueryManager::Query* query = query_manager->GetQuery(kNewClientId);
-  ASSERT_TRUE(query != NULL);
-  EXPECT_FALSE(query->pending());
-
-  GLsync kGlSync = reinterpret_cast<GLsync>(0xdeadbeef);
-  EXPECT_CALL(*gl_, Flush()).RetiresOnSaturation();
-  EXPECT_CALL(*gl_, FenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0))
-      .WillOnce(Return(kGlSync))
-      .RetiresOnSaturation();
-
-  EndQueryEXT end_cmd;
-  end_cmd.Init(GL_COMMANDS_COMPLETED_CHROMIUM, 1);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_TRUE(query->pending());
-
-  EXPECT_CALL(*gl_, ClientWaitSync(kGlSync, _, _))
-      .WillOnce(Return(GL_TIMEOUT_EXPIRED))
-      .RetiresOnSaturation();
-  bool process_success = query_manager->ProcessPendingQueries();
-
-  EXPECT_TRUE(process_success);
-  EXPECT_TRUE(query->pending());
-
-  EXPECT_CALL(*gl_, ClientWaitSync(kGlSync, _, _))
-      .WillOnce(Return(GL_ALREADY_SIGNALED))
-      .RetiresOnSaturation();
-  process_success = query_manager->ProcessPendingQueries();
-
-  EXPECT_TRUE(process_success);
-  EXPECT_FALSE(query->pending());
-  QuerySync* sync = static_cast<QuerySync*>(shared_memory_address_);
-  EXPECT_EQ(static_cast<GLenum>(0), static_cast<GLenum>(sync->result));
-
-  EXPECT_CALL(*gl_, DeleteSync(kGlSync)).Times(1).RetiresOnSaturation();
-  ResetDecoder();
-}
-
 TEST_F(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
   Mailbox mailbox = Mailbox::Generate();
 
   memcpy(shared_memory_address_, mailbox.name, sizeof(mailbox.name));
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
@@ skipping 2156 matching lines @@
 // TODO(gman): TexImage2DImmediate
 
 // TODO(gman): TexSubImage2DImmediate
 
 // TODO(gman): UseProgram
 
 // TODO(gman): SwapBuffers
 
 }  // namespace gles2
 }  // namespace gpu