Fix VAOs and client side arrays

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/gl2ext.h>
 #include "gpu/command_buffer/client/client_test_helper.h"
@@ skipping 1177 matching lines @@
   static const float verts[1] = { 0.0f, };
   const GLuint kAttribIndex1 = 1;
   const GLuint kAttribIndex2 = 3;
   const GLint kNumComponents1 = 3;
   const GLint kNumComponents2 = 2;
   const GLsizei kStride1 = 12;
   const GLsizei kStride2 = 0;
   const GLuint kBufferId = 0x123;
   const GLint kOffset2 = 0x456;
 
-  // Only one set and one get because the client side buffer's info is stored
-  // on the client side.
+  // It's all cached on the client side so no get commands are issued.
   struct Cmds {
     BindBuffer bind;
     VertexAttribPointer set_pointer;
-    GetVertexAttribPointerv get_pointer;
   };
 
-  ExpectedMemoryInfo mem1 = GetExpectedResultMemory(16);
-
   Cmds expected;
   expected.bind.Init(GL_ARRAY_BUFFER, kBufferId);
   expected.set_pointer.Init(kAttribIndex2, kNumComponents2, GL_FLOAT, GL_FALSE,
                             kStride2, kOffset2);
-  expected.get_pointer.Init(kAttribIndex2, GL_VERTEX_ATTRIB_ARRAY_POINTER,
-                            mem1.id, mem1.offset);
-
-  // One call to flush to way for GetVertexAttribPointerv
-  EXPECT_CALL(*command_buffer(), OnFlush())
-      .WillOnce(SetMemory(mem1.ptr, SizedResultHelper<uint32>(kOffset2)))
-      .RetiresOnSaturation();
 
   // Set one client side buffer.
   gl_->VertexAttribPointer(kAttribIndex1, kNumComponents1,
                            GL_FLOAT, GL_FALSE, kStride1, verts);
   // Set one VBO
   gl_->BindBuffer(GL_ARRAY_BUFFER, kBufferId);
   gl_->VertexAttribPointer(kAttribIndex2, kNumComponents2,
                            GL_FLOAT, GL_FALSE, kStride2,
                            reinterpret_cast<const void*>(kOffset2));
   // now get them both.
   void* ptr1 = NULL;
   void* ptr2 = NULL;
 
   gl_->GetVertexAttribPointerv(
       kAttribIndex1, GL_VERTEX_ATTRIB_ARRAY_POINTER, &ptr1);
   gl_->GetVertexAttribPointerv(
       kAttribIndex2, GL_VERTEX_ATTRIB_ARRAY_POINTER, &ptr2);
 
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_TRUE(static_cast<const void*>(&verts) == ptr1);
-  // because the service is not running ptr2 is not read.
   EXPECT_TRUE(ptr2 == reinterpret_cast<void*>(kOffset2));
 }
 
 TEST_F(GLES2ImplementationTest, GetVertexAttrib) {
   static const float verts[1] = { 0.0f, };
   const GLuint kAttribIndex1 = 1;
   const GLuint kAttribIndex2 = 3;
   const GLint kNumComponents1 = 3;
   const GLint kNumComponents2 = 2;
   const GLsizei kStride1 = 12;
   const GLsizei kStride2 = 0;
   const GLuint kBufferId = 0x123;
   const GLint kOffset2 = 0x456;
 
   // Only one set and one get because the client side buffer's info is stored
   // on the client side.
   struct Cmds {
     EnableVertexAttribArray enable;
     BindBuffer bind;
     VertexAttribPointer set_pointer;
-    GetVertexAttribiv get1;  // for getting the buffer from attrib2
     GetVertexAttribfv get2;  // for getting the value from attrib1
   };
 
-  ExpectedMemoryInfo mem1 = GetExpectedResultMemory(16);
   ExpectedMemoryInfo mem2 = GetExpectedResultMemory(16);
 
   Cmds expected;
   expected.enable.Init(kAttribIndex1);
   expected.bind.Init(GL_ARRAY_BUFFER, kBufferId);
   expected.set_pointer.Init(kAttribIndex2, kNumComponents2, GL_FLOAT, GL_FALSE,
                             kStride2, kOffset2);
-  expected.get1.Init(kAttribIndex2,
-                     GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING,
-                     mem1.id, mem1.offset);
   expected.get2.Init(kAttribIndex1,
                      GL_CURRENT_VERTEX_ATTRIB,
                      mem2.id, mem2.offset);
 
   FourFloats current_attrib(1.2f, 3.4f, 5.6f, 7.8f);
 
-  // One call to flush to way for GetVertexAttribiv
+  // One call to flush to wait for last call to GetVertexAttribiv
+  // as others are all cached.
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(
-          mem1.ptr, SizedResultHelper<GLuint>(kBufferId)))
-      .WillOnce(SetMemory(
           mem2.ptr, SizedResultHelper<FourFloats>(current_attrib)))
       .RetiresOnSaturation();
 
   gl_->EnableVertexAttribArray(kAttribIndex1);
   // Set one client side buffer.
   gl_->VertexAttribPointer(kAttribIndex1, kNumComponents1,
                            GL_FLOAT, GL_FALSE, kStride1, verts);
   // Set one VBO
   gl_->BindBuffer(GL_ARRAY_BUFFER, kBufferId);
   gl_->VertexAttribPointer(kAttribIndex2, kNumComponents2,
@@ skipping 1266 matching lines @@
       gl_->Enable(state);
       EXPECT_EQ(0, memcmp(&expected, commands, sizeof(expected)));
     }
     ClearCommands();
     result = gl_->IsEnabled(state);
     EXPECT_TRUE(result);
     EXPECT_TRUE(NoCommandsWritten());
   }
 }
 
+TEST_F(GLES2ImplementationTest, BindVertexArrayOES) {
+  GLuint id = 0;
+  gl_->GenVertexArraysOES(1, &id);
+  ClearCommands();
+
+  struct Cmds {
+    BindVertexArrayOES cmd;
+  };
+  Cmds expected;
+  expected.cmd.Init(id);
+
+  const void* commands = GetPut();
+  gl_->BindVertexArrayOES(id);
+  EXPECT_EQ(0, memcmp(&expected, commands, sizeof(expected)));
+  ClearCommands();
+  gl_->BindVertexArrayOES(id);
+  EXPECT_TRUE(NoCommandsWritten());
+}
+
 TEST_F(GLES2ImplementationTest, BeginEndQueryEXT) {
   // Test GetQueryivEXT returns 0 if no current query.
   GLint param = -1;
   gl_->GetQueryivEXT(GL_ANY_SAMPLES_PASSED_EXT, GL_CURRENT_QUERY_EXT, &param);
   EXPECT_EQ(0, param);
 
   GLuint expected_ids[2] = { 1, 2 }; // These must match what's actually genned.
   struct GenCmds {
     GenQueriesEXTImmediate gen;
     GLuint data[2];
@@ skipping 217 matching lines @@
   gl_->Enable(GL_BLEND);
   EXPECT_TRUE(NoCommandsWritten());
 }
 
 
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu